package ru.rtec.test.gc;

public class TestGC
{
     static long TEST_LENGTH = 15 * 1000;

     static int blockSize;

     public static void main(String[] args)
     {
         for (blockSize = 256; blockSize < 512 * 1024;
              blockSize = blockSize * 2)
         {
             System.out.println("---\nBlockSize: " + blockSize + " b");
             test();
         }
     }

     private static void test()
     {
         long maxTime = 0;
         long testStart = System.currentTimeMillis();
         long allocCount = 0;
         while (System.currentTimeMillis() - testStart < TEST_LENGTH)
         {
             long startCreate = System.currentTimeMillis();
             byte[] data = new byte[blockSize];
             long cLength = System.currentTimeMillis() - startCreate;
             data[0] = 1;//обманем оптимизатор на всякий случай.
             //16 мс - OS context switch
             if ((cLength!= 16)&&(cLength > maxTime))
             {
                 maxTime = cLength;
             }
             allocCount++;
         }
         System.out.println("Max time: " + maxTime + " ms");
         System.out.println("Allocation count: " + allocCount);
         System.out.println(
                 "Total allocated: " +
                         allocCount * blockSize / 1024 / 1024 + " Mb");
     }

}

public interface Subscription<T> {
    public void add(T o);
    public void remove(T o);
}

public final class Multicast<T> implements Subscription<T> {
    // . . .
}

    protected final Multicast<ComponentListener> onComponentEventMulticast = Multicast.create(ComponentListener.class);
    public Subscription<ComponentListener> onComponentEvent() {
        return onComponentEventMulticast;
    }

D>>Однако, если реализовать подписку классическим вариантом, то можно заметить, что много кода буквально дублируется. Код подписки для различных listener'ов похож до безобразия. Поэтому было бы неплохо его написать один раз и потом использовать (а не переписывать для каждого типа listener'а заново).

 protected void fireFooXXX() {
     // Guaranteed to return a non-null array
     Object[] listeners = listenerList.getListenerList();
     // Process the listeners last to first, notifying
     // those that are interested in this event
     for (int i = listeners.length-2; i>=0; i-=2) {
         if (listeners[i]==FooListener.class) {
             // Lazily create the event:
             if (fooEvent == null)
                 fooEvent = new FooEvent(this);
             ((FooListener)listeners[i+1]).fooXXX(fooEvent);
         }
     }
 }

    public synchronized void addComponentListener(ComponentListener l)
    public synchronized void removeComponentListener(ComponentListener l)
    public synchronized ComponentListener[] getComponentListeners()

    public synchronized void addFocusListener(FocusListener l)
    public synchronized void removeFocusListener(FocusListener l)
    public synchronized FocusListener[] getFocusListeners()

    public void addHierarchyListener(HierarchyListener l)
    public void removeHierarchyListener(HierarchyListener l)
    public synchronized HierarchyListener[] getHierarchyListeners()

    public void addHierarchyBoundsListener(HierarchyBoundsListener l)
    public void removeHierarchyBoundsListener(HierarchyBoundsListener l)
    public synchronized HierarchyBoundsListener[] getHierarchyBoundsListeners()

    public synchronized void addKeyListener(KeyListener l)
    public synchronized void removeKeyListener(KeyListener l)
    public synchronized KeyListener[] getKeyListeners()

    public synchronized void addMouseListener(MouseListener l)
    public synchronized void removeMouseListener(MouseListener l)
    public synchronized MouseListener[] getMouseListeners()

    public synchronized void addMouseMotionListener(MouseMotionListener l)
    public synchronized void removeMouseMotionListener(MouseMotionListener l)
    public synchronized MouseMotionListener[] getMouseMotionListeners()

    public synchronized void addMouseWheelListener(MouseWheelListener l)
    public synchronized void removeMouseWheelListener(MouseWheelListener l)
    public synchronized MouseWheelListener[] getMouseWheelListeners()

    public synchronized void addInputMethodListener(InputMethodListener l)
    public synchronized void removeInputMethodListener(InputMethodListener l)
    public synchronized InputMethodListener[] getInputMethodListeners()

    public ComponentListener.Hub onComponentEvent=....
    public FocusListener.Hub onFocusEvent=....
    public HierarchyListener.Hub onHierarchyEvent=....

........

        public interface ComponentListener extends EventListener
    {
        public void componentResized(ComponentEvent e);
        public void componentMoved(ComponentEvent e);
        public void componentShown(ComponentEvent e);
        public void componentHidden(ComponentEvent e);
        
        public class Hub
        {
            public void add(ComponentListener c){};
            public void del(ComponentListener c){};
            public ComponentListener get(){};
        }
        
    }
........

......
comp.onComponentEvent.add(componentListener);//добавление обработчика
comp.onComponentEvent.del(componentListener);//удаление обработчика
comp.onComponentEvent.get().componentShown(componentEvent);//вызов (invoke) у всех зарег. обработчиков componentShown(ComponentEvent e)
.....

addKeyListener(IKeyListener.KeyPress | IKeyListener.KeyTyped | IKeyListener.KeyRelease, IKeyListener l)
addMouseListener(IMouseListener.MouseEnter| IMouseListener.MouseExit | IMouseListener.MouseMove, IMouseListener l)

comp.onComponentEvent.add(componentListener);//добавление обработчика
comp.onComponentEvent.del(componentListener);//удаление обработчика
comp.onComponentEvent.get().componentShown(componentEvent);//вызов (invoke) у всех зарег. обработчиков

Т>Но (!) как это может быть устроено внутри? что думаете?

Т>лично я нахожу откровенно корявым и загаживающим API. (нет? )

T> что думаете?

Избегайте опосредованных вызовов методов других классов.
Непосредственные связи довольно опасны. Опосредованные связи, такие как account.ContactPerson().DaytimeContactlnfo().PhoneNumberO, опасны еще больше. В связи с этим ученые сформулировали «Правило Деметры (Law of Demeter)» (Lieberherr and Holland, 1989), которое гласит, что Объект А может вызывать любые из собственнных методов. Если он создает Объект В, он может вызывать любые методы Объекта В, но ему не следует вызывать методы объектов, возвращаемых Объектом В. В нашем случае это означает, что вызов account.ContactPerson() приемлем, однако вызова account.ContactPerson().DaytimeContactlnfo() следовало бы избежать.

//а мине вот так писать ндравилось фсигда ;) 
new Thread()
{
    public void run()
    {
        asych_call();
    }

}.start();

myFrame.myTable.getModel().getRow().getЧтонибудьеще()

    public synchronized void addComponentListener(ComponentListener l)
    public synchronized void removeComponentListener(ComponentListener l)
    public synchronized ComponentListener[] getComponentListeners()

    public ComponentListener.Hub onComponentEvent=....

AB>myFrame.myTable.getModel().getRow().getЧтонибудьеще()
AB>

Т>    public synchronized void addComponentListener(ComponentListener l)
Т>    public synchronized void removeComponentListener(ComponentListener l)
Т>    public synchronized ComponentListener[] getComponentListeners()
Т>

Т>    public ComponentListener.Hub onComponentEvent=....
Т>

  public interface ComponentListener extends EventListener
    {
        public void componentResized(ComponentEvent e);
        public void componentMoved(ComponentEvent e);
        public void componentShown(ComponentEvent e);
        public void componentHidden(ComponentEvent e);
        
        public class Hub
        {
            public void add(ComponentListener c){};
            public void del(ComponentListener c){};
            public ComponentListener get(){};
        }
        
    }

Т>причем тут архитектура? то о чем Вы говорите — это уже использование некоторой архитектуры.

Т>такую последовательность вызовов несможет предотвратить ни одна архитектура, ну, кроме разве той, согласно которой методу запрещено возвращать ссылку на объект. но это не идеология JAVA, вроди так

Т>......
Т>comp.onComponentEvent.add(componentListener);//добавление обработчика
Т>comp.onComponentEvent.del(componentListener);//удаление обработчика
Т>comp.onComponentEvent.get().componentShown(componentEvent);//вызов (invoke) у всех зарег. обработчиков componentShown(ComponentEvent e)
Т>.....
Т>

Т>Но (!) как это может быть устроено внутри? что думаете?

package muticast;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

/**
 * @author dshe
 *
 */
public final class Multicast<T> {
    private static final Map<Class<?>, Object> DEF_VALUES_CLASS_TO_OBJECT;
    static {
        DEF_VALUES_CLASS_TO_OBJECT = new HashMap<Class<?>, Object>();
        DEF_VALUES_CLASS_TO_OBJECT.put(boolean.class, Boolean.FALSE);
        DEF_VALUES_CLASS_TO_OBJECT.put(byte.class, new Byte((byte) 0));
        DEF_VALUES_CLASS_TO_OBJECT.put(short.class, new Short((short) 0));
        DEF_VALUES_CLASS_TO_OBJECT.put(char.class, new Character('\0'));
        DEF_VALUES_CLASS_TO_OBJECT.put(int.class, new Integer(0));
        DEF_VALUES_CLASS_TO_OBJECT.put(long.class, new Long(0L));
        DEF_VALUES_CLASS_TO_OBJECT.put(float.class, new Float(0f));
        DEF_VALUES_CLASS_TO_OBJECT.put(double.class, new Double(0d));
    }

    class Handler implements InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object[] array = _list.toArray();
            Throwable thrown = null;
            for(int i = 0, n = array.length; i < n; ++i) {
                try {
                    method.invoke(array[i], args);
                }
                catch(IllegalAccessException exc) {
                    throw (Error) new IllegalAccessError().initCause(exc);
                }
                catch(InvocationTargetException exc) {
                    thrown = exc.getTargetException();
                }
            }
            // rethrow last occured exception
            if(thrown != null)
                throw thrown;
            // we cannot return null if method returns primitive value
            // thus we lookup default value is a table.
            return DEF_VALUES_CLASS_TO_OBJECT.get(method.getReturnType());
        }
    }

    private final List<T> _list;
    private final Class<T> _iface;
    private final T _proxy;

    private Multicast(Class<T> iface) {
        _list = new Vector<T>();
        _iface = iface;
        // unchecked cast: dont worry
        _proxy = (T) Proxy.newProxyInstance(iface.getClassLoader(), new Class[] { iface }, new Handler());
    }

    // static factory method is just for convenient type inference
    public static <U> Multicast<U> create(Class<U> iface) {
        return new Multicast<U>(iface);
    }

    public T fire() {
        return _proxy;
    }

    public void add(T obj) {
        if(!_iface.isInstance(obj))
            throw new IllegalArgumentException("obj : " + obj);
        _list.add(obj);
    }

    public void remove(T obj) {
        if(!_iface.isInstance(obj))
            throw new IllegalArgumentException("obj : " + obj);
        _list.remove(obj);
    }
}

        Multicast<Runnable> multicast = Multicast.create(Runnable.class);
        Runnable a = new Runnable() {
            public void run() {
                System.out.println("one");
            }
        };
        Runnable b = new Runnable() {
            public void run() {
                System.out.println("two");
            }
        };
        multicast.add(a);
        multicast.add(b);
        multicast.fire().run();
        multicast.remove(b);
        multicast.fire().run();

Т>>лично я нахожу откровенно корявым и загаживающим API. (нет? )

T>> что думаете?

comp.addComponentListener(componentListener);
comp.removeComponentListener(componentListener);
comp.fireComponentShown(componentEvent);

comp.onComponentEvent.add(componentListener);
comp.onComponentEvent.del(componentListener);
comp.onComponentEvent.get().componentShown(componentEvent);

Lightweight events concept

This is a very important chapter. The LwVCL library uses listener concept like Java AWT or SWING libraries. It means that if you want to handle any event you should register an appropriate event listener. The events and listeners are much like in AWT library (see package org.zaval.lw.event.*) and hope, you'll get it easily. But there are several key differences:

First of all, lightweight components don't provide listener support. The lightweight component doesn't implement event distribution functionality and this is really good, because event distribution is concentrated in one place — event manager. This way has one more advantage: it decreases memory usage because lightweight components should not contain the list of listeners (listeners support). It's very simple: if you want to catch events inside your lightweight component, it is necessary just to implement an appropriate listener interface and the library event manager will immediately start sending the events to the component. For example, to catch mouse events inside your component, you should implement LwMouseListener listener interface. As it was described above, a lightweight component doesn't provide listeners support for mouse, key, component, container, focus and other events unlike a Java AWT component. But it is possible to handle all these events using LwEventManager event manager, by registering an appropriate listener. In this case the registered listener will get the events for all components, so if you want to listen the events for the certain lightweight component you should test a source of the events.

The lightweight library provides the mechanism to control input child events. The input event is an event that is initiated by mouse, keyboard or any other input device. This is very important to have this feature for creating composite components. Composite component is a container that consists of several components (child components) that have to work together. For example the LwButton component is a composite component. The button component can have other components (including composite components) as its child. The problem, in this case, is following: if a mouse button has been clicked over any child component, the button mouse listener will not get the mouse event and so cannot handle it. There are several ways to resolve the problem:

Register a mouse listener in by the event manager and test if the source object is the button component or its child component. This solution is like Java AWT (but in this case it is necessary to test if the event source of the event is the child of the composite component), but this way doesn't solve the problem if you want to use other composite component as the button container child component (you cannot control a composite child component).

Control child components' events. The Java AWT hasn't anything like that. The main idea is the parent component can control input events distributing process for its child components. In this case the parent should implement the LwComposite interface and starting from the moment the event manager will "ask" the composite component if the child component input event should be re-directed to the parent. If the composite component says to redirect the input event, the lightweight event manager distributes the event as if the child component doesn't exist. The child becomes "transparent" for the input event. The image below illustrates the composite components concept:

Т>лично я нахожу откровенно корявым и загаживающим API. (нет? )

Т>Но (!) как это может быть устроено внутри? что думаете?

   addListener(int type, IListener l);
   removeListener(int type, IListener l);
   getListeners(int type);
   fireEvent(int type, Event event);

   addListener(type1 | type2 | type3, IListener l)

package ru.rtec.test.co;

/**
  * Интерфейс фабрики объектов.
  *
  * <p><b>Author</b> : Denis Tsyplakov <b> Date</b>: 11.01.2006 13:46:50</p>
  */
public interface IObjectFactory
{
     Object getObject();
}

package ru.rtec.test.co;

/**
  * Фабрика бинов
  *
  * <p><b>Author</b> : Denis Tsyplakov <b> Date</b>: 11.01.2006 13:58:18</p>
  */
public class BeanFactory implements IObjectFactory
{

     public Object getObject()
     {
         return new CustomBean();
     }

     class CustomBean
     {
         int i;

         long j;

         boolean b;
     }

}

package ru.rtec.test.co;

/**
  * Фабрика строк 0,1,2,3,...
  *
  * <p><b>Author</b> : Denis Tsyplakov <b> Date</b>: 11.01.2006 13:52:09</p>
  */
public class StringFactory implements IObjectFactory
{
     long counter = 0;

     public synchronized Object getObject()
     {
         return new String (""+counter++);
     }
}

package ru.rtec.test.co;

public class Tester
{

     private static final int TEST_LEHGTH = 100000;

     static Object[] objs = new Object[TEST_LEHGTH];

     public static void main(String[] args)
     {
         System.out.println("кол-во создаваемых объектов: " +
            TEST_LEHGTH);
         test("String Factory",(IObjectFactory)new StringFactory());
         test("Custom bean Factory",(IObjectFactory)new BeanFactory());
     }

     private static void test(final String name,
                              final IObjectFactory factory)
     {
         long start = System.currentTimeMillis();
         for ( int i = 0;i<TEST_LEHGTH;i++)
         {
             objs[i] = factory.getObject();
         }
         long len = System.currentTimeMillis() - start;
         System.out.println(name + " : " + len + " ms.");
     }
}

package ru.rtec.test.gc;

import java.util.*;

public class TestGC
{
     static long TEST_LENGTH = 1 * 1000;

     static int blockSize;

     static Queue<byte[]> queue = new LinkedList<byte[]>();

     static int queueSeed = 1;

     public static void main(String[] args)
     {
         for (blockSize = 256; blockSize <= 64 * 1024;
              blockSize = blockSize * 2)
         {
             System.out.println("---\nBlockSize: " + blockSize + " b");
             test();
         }
     }

     private static void test()
     {
         long maxTime = 0;
         long testStart = System.currentTimeMillis();
         long allocCount = 0;
         while (System.currentTimeMillis() - testStart < TEST_LENGTH)
         {
             long startCreate = System.currentTimeMillis();
             byte[] data = new byte[blockSize];
             long cLength = System.currentTimeMillis() - startCreate;
             if (queueSeed % 2 == 1)
             {
                 queue.add(data);
                 if (queue.size() > 20 )
                 {
                     queue.remove();
                 }
             }
             queueSeed++;
             if ( queueSeed > blockSize - 1 )
             {
                 queueSeed = 1;
             }
             if (cLength > maxTime)
             {
                 maxTime = cLength;
             }
             allocCount++;
         }
         System.out.println("Max time: " + maxTime + " ms");
         System.out.println("Allocation count: " + allocCount);
         System.out.println(
                 "Total allocated: " +
                         allocCount * blockSize / 1024 / 1024 + " Mb");
     }

}