Java, Motivo di progettazione: più origini di eventi e un gestore di eventi One

Question

Desidero implementare un progetto in Java in cui dispongo di più origini di eventi (thread). Tale origine di eventi svolge un'attività specifica e ha dovuto notificare l'esclusivo Gestore di eventi (Classe) e questo deve eseguire altre attività in base alle notifiche delle fonti di eventi.

La mia domanda è: come implementare questo desiqn nel modo appropriato in Java? C'è un motivo di progettazione simile a questo disegno?

Grazie in anticipo :).

Answer 1

Penso che stiate cercando il modello Observer. Java ha alcune interfacce standard (java.util.Observer, java.util.Observable), sebbene queste non siano specifiche per tipo; quindi potresti considerarlo tuo se il dominio lo richiede.

class MyThread implements Runnable { 
Observable observable; 

public MyThread(EventHandler observer) { 
    observable = new Observable(); 
    observable.addObserver(observer); 
} 

public void run() { 
    while (!done()) { 
    Object result = doStuff(); 
    observable.notifyObservers(result); 
    } 
} 
} 

// might have this be singleton 
class EventHandler implements Observer { 
public synchronized void update(Observable o, Object arg) { 
    accomplishOtherTask(); 
} 
} 

Answer 2

Suona come un modello di attore per me. Ogni thread funge da attore, realizzando un singolo compito. Il risultato è impostato su una coda (sì) per essere elaborato dal prossimo attore.

Non ho esperienza con i framework di java actor, però. Consulta Google per questo.

Answer 3

In GWT, questo è chiamato event bus. O GWT. HandlerManager o GWTx. PropertyChangeSupport sono le implementazioni consigliate da Google. Quest'ultimo è disponibile in J2SE dal 1.4.2

Answer 4

Forse non capisco la tua domanda, ma penso che non sia necessario alcun modello di progettazione, ma qualcosa dal pacchetto java.util.concurrent.

A ThreadPoolExecutor?

Answer 5

Il pattern osservabile non ha valore sulla filettatura. In EventThread pattern il listener può indicare in quale thread e quando viene gestito l'evento.

public class MyObservableObject { 
    ... 
    void addListener(MyListener listener, Executor executor); 
} 
public interface MyListener { 
    void onEvent(Object sender, Object event); 
} 

// Example 
obj.addListener(myListener, CURRENT_THREAD); 
obj.addListener(myListener, myWorkQueue); 
obj.addListener(myListener, AWT_EDT); // or SWT_EDT 
obj.addListener(myListener, Executors.newSingleThreadScheduledExecutor());