java線程同步問題，如何實現可觀察線程

Question

問題是：類C控制類B是否讓B再次將A添加到queueOfA，但是我怎樣才能確保當A通知C，並在B的queueOfA變空之前立即更新，因爲B類運行速度非常快，可能會刪除所有A，因此在C更新之前變爲空queueOfA，這可能會導致C的run方法結束。

請幫我一把！

class A extends Observable implements Runnable{ 
    //... 
    void run(){ 
    //... 
    if (goBackToTheQueueAgain == true){ 
     setChanged(); 
     notifyObservers();//notify C that to let B add itself back 
    } 
    //... 
} 

class B extends implements Runnable{ 
    Queue<A> queueOfA;// initialy, queueOfA contains several A's 
    //... 
    void run(){ 
     //... 
     A retrieved = queueOFA.remove(); 
     Thread aThread = new Thread(retrieved); 
     aThread.start(); 
     //... 
    } 
} 

class C implements Observer, Runnable { 
    B b; //initially class C contains an instance of B 
    //... 
    void update(Observable o, Object arg){ 
     if(o instanceof A){ 
     A a = (A) o; 
     b.queueOfA.add(a); 
     } 
    } 
    //... 
    void run(){ 
     //... 
     Thread bThread = new Thread(b); 
     bThread.start(); 
     while (b.queueOfA.isEmpty() == false){ 
      // if queueOfA is not empty loop for ever 
     } 
     //.. 
    } 
} 

Answer 1

的問題不在於你必須儘快通知更新 - 你不能保證。例如，考慮你在隊列中只有一個元素開始。這將從隊列中移除，然後隊列爲空，但該元素仍在處理中。 A線程可以採取它喜歡的時間 - 即使隊列爲空，C也不應該終止。

修復方法是C應該等到所有A都完全處理完畢。也就是說，A的運行方法已經結束，而不會將A重新放回隊列。這可以使用倒計時鎖存器來完成。最初將鎖存器設置爲隊列的大小（A的數量），並在每次A完全處理時減少該鎖存器。只有當該鎖存器變爲零時C纔會退出。

C相類似這樣

CountdownLatch latch; 

void run(){ 
    //... 
    this.latch = new CountDownLatch(queueOfA.size()); 
    Thread bThread = new Thread(b); 
    bThread.start(); 
    latch.await(); 
    //.. catch InterruptedException etc.. 
} 

void notifyDone(A a) { 
    this.latch.countDown(); 
} 

和A的run方法是

void run(){ 
    //... 
    C c = ...; // passed in from somewhere 
    if (goBackToTheQueueAgain == true){ 
     setChanged(); 
     notifyObservers();//notify C that to let B add itself back 
    } 
    else 
     c.notifyDone(this); 
} 

A需要到C的引用，以便它可以直接在它完成通知。

就我個人而言，我不會在這裏使用Observer/Observable，因爲您的通知具有特定含義 - 該項目可以重新排序。觀察者模式最適合通知狀態的變化，狀態可以從被觀察的實例中獲得。這不是這種情況，並且從這種抽象的解耦中沒有真正的收益。如果你想保持抽象而不是將A耦合到C，你可以引入一個額外的接口，例如

interface QueueHandler<T> 
{ 
    void requeue(T t); 
    void completed(T t); 
} 

並在C上實現它，並將它傳遞給每個A而不是當前的Observer接口。但同樣，A類和C類緊密耦合，所以你也可以將C傳遞給A並讓它直接通知。

Answer 2

我用一個有效的代碼示例回答了這個問題 - 它非常接近。所有你需要做的就是添加一個觀察者到具有主體的線程。

Image processing in a multhithreaded mode using Java