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

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

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

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

具有Observer模式的Java线程用于长操作

1 个答案: