具有Observer模式的Java线程可进行长时间操作

Question

在我的应用程序中，我有两个线程分别为ThreadA和ThreadB。 ThreadA是一个持有并处理某些数据的线程（生产者），而ThreadB是从ThreadA读取的相应使用者线程（只读）。
我想实现ThreadB通知ThreadA更新数据（这可能需要一些时间），并且当数据更改时，ThreadB应该从ThreadA获取/请求它。 只要ThreadA尚未完成数据的更新，ThreadB就不会等待，而是继续使用他拥有的当前（旧）数据进行工作。 现在我的想法是使用观察者模式通知ThreadB ThreadA已完成更新

public class ThreadA implements Runnable {

private boolean sometimesTrue = false;
private int[] someBigArray = new int[XXX];


private synchronized int[] getBigArray() {
    return this.someBigArray;
}

private void fireListenerDataChanged() {
    for(ThreadAListener l : listeners) 
        l.notify();
}

private synchronized void updateArray() {
    //do some stuff on the array that takes a lot of time
}

@Override
public void run() {
    while(true) {
        if(sometimesTrue) {
            updateArray();
        }
    }
}


public void doUpdate() {
    this.sometimesTrue = true;
}

}

public class ThreadB implements Runnable, ThreadAListener  {

private int[] bigDataToWorkOn;
private Thread threadA;

public ThreadB(ThreadA threadA) {
    this.threadA = threadA;
}

@Override
public void run() {
        //do my stuff with bigDataToWorkOn 
        if(sometimesTrue) {
            threadA.doUpdate();
        }
}


public void notify() {
    this.bigDataToWorkOn = threadB.getBigArray();
}      

}

我的主要目标是避免使用某种BlockingQueue，因为afaik ThreadB会等他的工作，直到ThreadA传递队列中的数据。 如果我在ThreadB的while循环中调用getBigArray，则会发生相同的问题，因为当ThreadA当前在updateArray中工作时，ThreadA将被锁定，并且ThreadB也将等待ThreadA完成。 那么这是一种适当的方法吗？

Answer 1

这种方法可能是可行的解决方案，但事实是，如果您不想在ThreadA run()方法中使用无限循环，则sometimesTrue必须使用volatile修饰符标记ThreadA 。

此外，如果您不希望ThreadA吃掉100％的单核，则必须在其run()方法内的循环中添加一些延迟：

public void run() {
    try {
        while(true) {
            if(sometimesTrue) {
               updateArray();
            }
            Thread.sleep(100);
        }
    } catch (InterruptedException e) {
      // ... do something with e 
    }
}