Java 我的程序中的线程和锁定

我是多线程新手，程序中的线程和锁定有问题

我通过创建下面的代码简化了我的问题

private final ConcurrentLinkedQueue<String> valueQueue = new ConcurrentLinkedQueue<String>();
private final Object lock = new Lock();
private ProcessValue processor = new ProcessValues();

public void addValue(String value){
        synchronized (lock) {
        valueQueue.add(value);
        lock.notify();
    }
}

public void waitForValuesToBeAdded(){
        synchronized (lock) {
        lock.wait();
        executeValues();
    }
}

public void executeValues(){
        synchronized (lock) {
        processor.processValues();
        valueQueue.clear();
        lock.notify()
    }
}

private final ConcurrentLinkedQueue valueQueue=new ConcurrentLinkedQueue（）；
私有最终对象锁=新锁（）；
私有ProcessValue处理器=新的ProcessValue（）；
公共void addValue（字符串值）{
已同步（锁定）{
valueQueue.add（值）；
lock.notify（）；
}
}
public void waitforvaluestobeaded（）{
已同步（锁定）{
lock.wait（）；
executeValue（）；
}
}
public void executeValues（）{
已同步（锁定）{
processValues（）；
valueQueue.clear（）；
lock.notify（）
}
}

当程序启动时，它执行

waitforvaluestobeaded

。顾名思义，这只是等待将值添加到队列中。当添加值时，我们不再等待，因此调用

executeValues（）

执行

processor.processValues（）

时，我不希望将值添加到队列（

valueQueue.add（value）

）。我需要他们等到

processValues（）

完成。 我认为如果我使用同步块，它将阻止插入，但是当我在执行

processValue

时添加另一个值时，所有内容都会挂起

---

我的程序中遗漏了什么吗？

尝试使用jvisualvm查看线程被阻塞的位置。您可以执行“线程转储”来分析此问题。

重写如下：

private final ConcurrentLinkedQueue<String> valueQueue = new ConcurrentLinkedQueue<String>();
private final Object lock = new Lock();
private ProcessValue processor = new ProcessValues();

public void addValue(String value) {
    synchronized (lock) {
        valueQueue.add(value);
        lock.notifyAll();
    }
}

public void waitForValuesToBeAdded() throws InterruptedException {
    synchronized (lock) {
        while (valueQueue.size() == 0) {
            lock.wait();
        }
        executeValues();
    }
}

public void executeValues() {
    synchronized (lock) {
        processor.processValues();
        valueQueue.clear();
        lock.notifyAll()
    }
}

private final ConcurrentLinkedQueue valueQueue=new ConcurrentLinkedQueue（）；
私有最终对象锁=新锁（）；
私有ProcessValue处理器=新的ProcessValue（）；
公共void addValue（字符串值）{
已同步（锁定）{
valueQueue.add（值）；
lock.notifyAll（）；
}
}
public void waitForValuestobeaded（）引发InterruptedException{
已同步（锁定）{
while（valueQueue.size（）==0）{
lock.wait（）；
}
executeValue（）；
}
}
public void executeValues（）{
已同步（锁定）{
processValues（）；
valueQueue.clear（）；
lock.notifyAll（）
}
}

同步块的目的是防止两个呼叫者同时进入同步代码块。第二个呼叫者将被阻止，直到第一个呼叫者退出该块。这可以防止第二个调用方破坏第一个调用方正在读取或写入的状态（变量）。没有这种锁定，并发集合是安全的；如果您强制其他呼叫者等待，您需要一个

ConcurrentLinkedQueue

来做什么？您能告诉我们一些操作吗？上面的方法在哪里调用？如果队列一次只保存一个对象，那么您可能需要使用instead@RobertHarvey我设置锁的原因是阻止添加到队列中的任何内容，并强制线程等待，直到它们能够向我显示主程序，在那里创建类的实例等等。