Как использовать runnable для работы в Singleton?

Question

У меня есть вопрос об использовании runnable для работы в singleton.

У меня есть класс EventCoordinator, который является одноточечным, потому что он обрабатывает все события (и потому, что мое назначение требует от меня этого). События будут добавлены к этому координатору и будут обработаны позже. События должны обрабатываться в другом потоке, в котором запуск принимает события очереди и обрабатывает их. метод start должен начать новый поток, который принимает события очереди с помощью run.

final public class EventCoordinator implements Runnable { 

    protected final static EventCoordinator coordinator = new EventCoordinator(); 
    protected static LinkedList<QueueItem> queue = new LinkedList<QueueItem>();  
    private EventBroker() { 
    } 

    private class QueueItem { 
     protected Event event; 


     public QueueItem(Event event) { 
      this.event = event; 
     } 
    } 

    public static EventCoordinator getEventCoordinator() { 
     return coordinator; 
    } 

    public void addEventObserver(EventObserver o) { 
     //adds listeners to the coordinator 
    } 



    void addEvent(EventPublisher source, Event e) { 
      QueueItem queueItem = new QueueItem(e, source); 
      synchronized(this) { queue.add(queueItem); } 
    } 


    public void run() { 
     // Process items from the queue 
    } 

    public void start() { 
     // start a new thread that processes items of the queue 
    } 

} 

Но, как я понимаю runnables, что при создании thread = new Thread(New EventCoordinator) вы создаете новый объект EventCoordinator и, таким образом, не работают на одной и той же очереди больше. Итак, как вы можете использовать runnable для выполнения этой работы в очереди? Я старую статическую очередь? Я реализую методы для добавления и удаления элементов из очереди и вызываю их в координаторе, возвращаемом getEventCoordinator?

Answer 1

Вы хотите делать то, что сказал Роман:

public static synchronized EventCoordinator getEventCoordinator() { 
    if (coordinator == null) { 
     coordinator = new EventCoordinator(); 
    } 
    return coordinator; 
} 

Таким образом, когда вы звоните getEventCoordinator(), вы только когда-либо получить, что один экземпляр ... вы не хотите использовать thread = new Thread(new EventCoordinator()) потому, что побеждает цель одноэлементного.

Когда вы вызываете thread = new Thread(EventCoordinator.getEventCoordinator()) в свой метод start(), он создаст поток, используя экземпляр singleton, как Runnable. Затем просто определите, как вы хотите обрабатывать элементы очереди в вашем run() методе EventCoordinator.

С учетом сказанного «предпочтительный» подход к одноэлементному (согласно эффективной Java от Джошуа Блоха) заключается в использовании перечисления с одним элементом. Если вы сохраните его, как это, вы должны, по крайней мере, сделать свой coordinator полем private с помощью метода доступа, такого как Roman.

Answer 2

попытаться пойти по следующему пути (простая реализация singelton):

public static EventCoordinator getEventCoordinator() { 
    if (coordinator == null) { 
     coordinator = new EventCoordinator(); 
    } 
    return coordinator; 
} 

и

thread = new Thread(EventCoordinator.getEventCoordinator()) 

Answer 3

Вы можете начать анонимный поток из метода запуска и в методе выполнения анонимного потока можно назвать координатор мероприятия который будет фактически обрабатывать очередь. Если вы удалите исполняемый интерфейс координатора событий, вам не придется вызывать метод запуска координатора событий, а обработка очереди может выполняться непосредственно в методе запуска анонимного потока. Может быть случай, когда обработка или удаление элементов из очереди и добавление элементов в очередь происходит одновременно. Вам придется обрабатывать параллелизм там, используя либо синхронизированный блок, либо некоторую блокировку.