本文深入探讨了Java生产者-消费者模式中因并发访问共享变量而导致的数据不一致问题。通过分析一个具体的Java代码示例，揭示了在非同步代码块中读取共享状态可能引发的竞态条件，导致消费者获取到旧值。文章提供了解决方案，强调了在并发环境中对所有共享可变状态的读写操作都必须进行同步，以确保数据可见性和一致性，并澄清了“线程化对象”的概念。
1. 生产者-消费者模式与并发挑战
生产者-消费者模式是多线程编程中一个经典的同步问题，它描述了多个生产者线程生产数据并将其放入共享缓冲区，以及多个消费者线程从缓冲区取出数据进行处理的场景。在这种模式中，确保数据在生产者和消费者之间正确、安全地传递至关重要。Java提供了synchronized关键字、wait()和notify()（或notifyAll()）方法来协调线程间的操作，以防止数据损坏和不一致。
然而，即使使用了这些同步机制，如果不严格遵循同步规则，仍可能出现数据可见性问题或竞态条件，导致线程读取到过时的数据。
2. 共享变量的可见性问题分析
考虑以下Java代码实现的生产者-消费者模型，其中Q2类作为共享缓冲区，Producer2和Consumer2分别代表生产者和消费者：
立即学习“Java免费学习笔记（深入）”；
class Q2 {
int n;
boolean valueSet = false;
synchronized int get() {
while(!valueSet) {
try {
System.out.println("Consumer waiting ...");
wait();
} catch(InterruptedException e) {
System.err.println("InterruptedException caught");
}
}
System.out.println("Consumer awakened");
System.out.println("Got: "+n);
valueSet = false;
notify();
System.out.println("Consumer called notify()");
return n;
}
synchronized void put(int n) {
while(valueSet) {
try {
System.out.println("Producer waiting ...");
wait();
} catch(InterruptedException e) {
System.err.println("InterruptedException caught");
}
}
System.out.println("Producer awakened");
System.out.println("Before put n is: " + this.n);
this.n = n;
valueSet = true;
System.out.println("Put: " + this.n);
notify();
System.out.println("Producer called notify()");
}
}
class Producer2 implements Runnable {
Q2 q;
int noOfTimes;
Producer2(Q2 q) {
this.q = q;
new Thread(this, "Producer").start();
}
public void run() {
int i=0;
noOfTimes=0;
while(q.n < 2) { // 循环条件依赖q.n
q.put(i++);
noOfTimes++;
}
System.out.println("Producer ran: " + noOfTimes + " times.");
}
}
class Consumer2 implements Runnable {
Q2 q;
int noOfTimes;
Consumer2(Q2 q) {
this.q = q;
new Thread(this, "Consumer").start();
}
public void run() {
int i=0;
noOfTimes=0;
while(q.n < 2) { // 循环条件依赖q.n，且此处读取q.n
System.out.println("Iteration " + (noOfTimes+1) + "; Before get() n is: " + q.n); // 潜在问题点
int val = q.get();
System.out.println("After get() n is: " + q.n);
noOfTimes++;
}
System.out.println("Consumer ran: " + noOfTimes + " times.");
System.out.println("n: " + q.n);
}
}
public class PCFixed {
public static void main(String[] args) {
Q2 q = new Q2();
new Producer2(q);
new Consumer2(q);
}
}在上述代码的某个特定输出中，我们观察到以下现象：
... Producer awakened Before put n is: 1 Put: 2 // #### line 1: 生产者将n设置为2 Producer called notify() Iteration 3; Before get() n is: 1 // #### line 2: 消费者读取n为1 Producer ran: 3 times. Consumer awakened Got: 2 // 消费者最终获取到2 Consumer called notify() After get() n is: 2 Consumer ran: 3 times. n: 2
在line 1处，生产者已经成功将共享变量q.n的值更新为2并调用了notify()。然而，紧接着在line 2处，消费者线程在调用q.get()之前，通过System.out.println("... Before get() n is: " + q.n);语句读取到的q.n值却是1，而非最新的2。这表明消费者读取到了一个陈旧（stale）的值。
3. 竞态条件产生的原因
问题的根源在于Consumer2类中run()方法里的这行代码： System.out.println("Iteration " + (noOfTimes+1) + "; Before get() n is: " + q.n);
尽管Q2类中的get()和put()方法都使用了synchronized关键字来确保互斥访问和内存可见性，但Consumer2::run方法中打印q.n的语句却位于q.get()调用之外，也即不在任何synchronized块的保护之下。
当生产者线程调用q.put(2)并成功更新q.n为2时，它会释放Q2对象的锁。此时，如果操作系统调度器将CPU时间片分配给消费者线程，并且消费者线程在尝试获取Q2对象的锁以调用q.get()之前，执行了System.out.println("... Before get() n is: " + q.n);这行代码，那么它读取到的q.n可能仍然是上一次get()操作后的值（即1），因为这次读取没有被Q2对象的锁保护，无法保证读取到最新的、由生产者写入的值。
这种在并发环境中，多个线程对同一个共享资源进行读写操作，且至少有一个是写操作，最终结果依赖于线程执行顺序的情况，就是典型的竞态条件（Race Condition）。
4. 解决方案：确保所有共享状态访问的同步
要解决这个问题，核心原则是：所有对共享可变状态的读写操作都必须在同一个锁的保护下进行。
这意味着，如果q.n是一个共享变量，并且它的值由生产者更新，由消费者读取，那么消费者在读取q.n（无论是为了业务逻辑还是仅仅为了打印日志）时，也必须持有Q2对象的锁。
最直接的解决方案是将System.out.println("... Before get() n is: " + q.n);这行代码移动到q.get()方法内部，使其在持有Q2对象锁的情况下执行。
修改后的 Consumer2 类 (仅展示 run 方法相关部分):
class Consumer2 implements Runnable {
Q2 q;
int noOfTimes;
Consumer2(Q2 q) {
this.q = q;
new Thread(this, "Consumer").start();
}
public void run() {
int i=0;
noOfTimes=0;
while(q.n < 2) {
// 移除此处对 q.n 的非同步读取
// System.out.println("Iteration " + (noOfTimes+1) + "; Before get() n is: " + q.n);
int val = q.get(); // get() 方法内部现在可以安全地打印 n 的值
System.out.println("After get() n is: " + q.n);
noOfTimes++;
}
System.out.println("Consumer ran: " + noOfTimes + " times.");
System.out.println("n: " + q.n);
}
}修改后的 Q2 类 (仅展示 get 方法相关部分):
class Q2 {
int n;
boolean valueSet = false;
synchronized int get() {
while(!valueSet) {
try {
System.out.println("Consumer waiting ...");
wait();
} catch(InterruptedException e) {
System.err.println("InterruptedException caught");
}
}
System.out.println("Consumer awakened");
// 将打印语句移入同步块，确保读取的是最新值
System.out.println("Iteration " + (Thread.currentThread().getName().equals("Consumer") ? ((Consumer2)Thread.currentThread().getRunnable()).noOfTimes + 1 : "N/A") + "; Got: "+n);
// 注意：上面这行代码为了演示，强行获取了Consumer2的noOfTimes，实际生产中应避免这种耦合，
// 或者将迭代次数作为参数传递，或者只打印get到的值。
// 更简洁的修正：
// System.out.println("Got: "+n);
valueSet = false;
notify();
System.out.println("Consumer called notify()");
return n;
}
// ... put 方法不变
}通过将对q.n的读取操作（即使是用于日志输出）移动到synchronized方法get()内部，可以确保在读取n时，线程已经获得了Q2对象的锁，并且能够看到n的最新值（因为synchronized关键字保证了内存可见性）。
5. 关于“线程化对象”的澄清
问题中提到了“threaded object”的含义。在Java并发编程中，通常没有“线程化对象”这一术语。更准确的理解是：一个对象（例如本例中的Q2实例）可以被多个线程共享，并且这些线程会并发地访问和操作这个对象的成员变量和方法。
当一个对象被多个线程共享时，我们就需要特别关注其状态的一致性和可见性问题，并采取适当的同步机制（如synchronized、volatile、Lock接口等）来保护共享状态，防止竞态条件和内存可见性问题。Q2实例就是一个典型的共享对象，它的n和valueSet成员变量是共享状态，需要synchronized方法来保证并发访问的正确性。
6. 总结与最佳实践
本教程通过一个具体的生产者-消费者问题，揭示了Java并发编程中一个常见的陷阱：即使使用了synchronized和wait/notify等高级同步机制，如果在访问共享状态时存在未被同步块保护的代码路径，仍然可能导致数据不一致。
关键 takeaways：
- 全面同步原则： 对任何共享的可变状态，其所有的读写操作都必须在同一个锁的保护下进行。
- 日志输出也需谨慎： 即使是用于调试或日志记录的共享变量读取，如果它发生在非同步上下文中，也可能观察到陈旧数据，从而误导问题分析。
- 理解内存可见性： synchronized关键字不仅提供互斥访问，还保证了内存可见性。当一个线程释放锁时，它对共享变量的修改会刷新到主内存；当另一个线程获取锁时，它会从主内存中读取共享变量的最新值。
- 避免竞态条件： 仔细审查所有对共享资源的访问点，确保它们都被适当的同步机制所保护。
通过遵循这些最佳实践，可以有效地构建健壮、正确且高效的并发应用程序。
