Java多线程问题实例：竞态条件及锁机制

原创我会带着你远行 2024-12-11 12:30 8阅读 0赞

竞态条件是多线程编程中常见的问题，它会导致正确的结果在不适当的时间被读取，进而引发程序的错误行为。

以下是一个简单的Java多线程案例，其中就存在竞态条件：

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

public synchronized void increment() {
        count++;
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new RuntimeException("Can't decrement zero");
        }
    }

public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
                System.out.println("Thread 1: Increment " + i);
            }
        }));

Thread thread2 = new Thread(() -> {
            for (int i = 4; i >= 0; i--) {
                counter.decrement();
                System.out.println("Thread 2: Decrement " + i);
            }
        }));

thread1.start();
        thread2.start();

// 这里可能会导致问题，因为主线程可能在
        // 线程1完成所有增量之前读取到count的值。
        // 由于线程2是在count降为0后开始执行的，
        // 所以在这种情况下，你可能会看到线程2试图访问一个已经被零化的计数器。

要解决这个问题，需要引入锁机制（synchronized关键字）来确保在多线程环境中的操作顺序。

例如：

```java
class Counter {
    private int count = 0;
    private Object lock = new Object();

public synchronized void increment() {
        lock.lock();
        try {
            count++;
            System.out.println("Thread 1: Increment " + count);
        } finally {
            lock.unlock();
        }
    }

public synchronized void decrement() throws RuntimeException {
        lock.lock();
        try {
            if (count > 0) {
                count--;
                System.out.println("Thread 2: Decrement " + count);
                return;
            } else {
                throw new RuntimeException("Can't decrement zero");
            }
        } finally {
            lock.unlock();
        }
    }

public synchronized int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}
```

在这个例子中，每次线程尝试访问`count`、`increment`或`decrement`时，都会先获取到锁。这样可以保证在多线程环境中的正确操作顺序。