Java多线程竞态条件：实例展示

原创叁歲伎倆 2024-12-09 05:33 6阅读 0赞

在Java编程中，多线程环境下的竞态条件是一个常见的并发问题。竞态条件通常发生在共享资源的访问过程中，不同的线程对资源的操作顺序不同，导致了最终结果的不确定性。

下面是一个简单的例子：

```java
public class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
        notifyAll(); // 唤醒等待的线程
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            if (count == 0) { // 如果计数为零，通知所有等待的线程
                notifyAll();
            }
        } else {
            throw new IllegalArgumentException("Counter is already zero.");
        }
        return count;
    }

public void waitToDecrement() throws InterruptedException {
        while (!decrement()) {
            synchronized (this) { // 使用synchronized修饰整个方法，确保在同一时刻只有一个线程访问这个资源
                if (count == 0) {
                    wait(); // 等待计数为零的信号
                }
            }
        }
    }

public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> {
            try {
                counter.waitToDecrement(); // 线程A等待减1操作完成
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                System.out.println("Thread 1 decremented " + counter.decrement()); // 输出线程减1后的结果
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                counter.increment(); // 线程B先增1操作
                counter.waitToDecrement(); // 等待减1操作完成
                System.out.println("Thread 2 decremented " + counter.decrement()); // 输出线程减1后的结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {
                System.out.println("Thread 2 incremented " + counter.increment())); // 输出线程增1后的结果
            }
        }));

thread1.start(); // 启动线程A
        thread2.start(); // 启动线程B

// 等待所有线程完成执行
        thread1.join();
        thread2.join();

System.out.println("Final state: " + counter)); // 输出最终状态
    }
}
```

在这个例子中，线程A和B都在同一个`Counter`对象上进行操作。由于计数器是共享资源，因此可能存在竞态条件：线程B在增加1后，还没来得及等待减1操作完成，就被线程A唤醒去执行减1操作。这就可能导致减1的次数少于增1的次数，从而破坏了计数器的初始状态。

要避免这种情况，可以使用锁（synchronized关键字）或其他并发控制机制确保对共享资源的访问是有序且互斥的。