java - 消费者生产者问题 - 同步总是必要的吗？

Question

我的问题纯粹是概念性的。仅仅是为了更深入地了解线程之间的通信。

在生产者消费者问题中，

• 有 1 个生产者线程和 1 个消费者线程。
• 生产者线程调用 Produce 方法，消费者线程调用 Consumer 方法。

The example code is taken from here

package ProducerConsumer;
import java.util.LinkedList;
import java.util.Queue;
public class ClassicProducerConsumerExample {
    public static void main(String[] args) throws InterruptedException {
        Buffer buffer = new Buffer(2);
        Thread producerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    buffer.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread consumerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    buffer.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producerThread.start();
        consumerThread.start();
        producerThread.join();
        consumerThread.join();
    }
    static class Buffer {
        private Queue<Integer> list;
        private int size;
        public Buffer(int size) {
            this.list = new LinkedList<>();
            this.size = size;
        }
        public void produce() throws InterruptedException {
            int value = 0;
            while (true) {
                synchronized (this) {
                    while (list.size() >= size) {
                        // wait for the consumer
                        wait();
                    }
                    list.add(value);
                    System.out.println("Produced " + value);
                    value++;
                    // notify the consumer
                    notify();
                    Thread.sleep(1000);
                }
            }
        }
        public void consume() throws InterruptedException {
            while (true) {
                synchronized (this) {
                    while (list.size() == 0) {
                        // wait for the producer
                        wait();
                    }
                    int value = list.poll();
                    System.out.println("Consume " + value);
                    // notify the producer
                    notify();
                    Thread.sleep(1000);
                }
            }
        }
    }
}

我读到，等待和通知应该位于同步块(synchronized block)内，以避免竞争条件。

我不明白为什么当两个线程调用不同的方法时我应该将 wait() 和 notification() 包含在同步块(synchronized block)中。消费者线程不会调用 Produce()，因此，如果我不使用 Synchronized 关键字将 wait 调用包含在 Produce 方法中，那么它的行为仍然应该相同，因为 Produce() 仅由生产者线程调用。是这样吗？

Answer 1

两个线程添加/删除的缓冲区是一个链接列表。 Java的链表不是线程安全的。

但是，您可以使用 concurrent 将这种锁定抽象到数据结构本身中。版本。

<小时/>

另一个后果:虽然在这个例子中只有生产者和一个消费者，但情况可能并非总是如此。拥有多个生产者和/或消费者可能会出现需要同步的用例，即使对于线程安全的数据结构也是如此。