Java多线程同步控制类：线程安全问题实例

原创缺乏、安全感 2024-11-26 09:00 47阅读 0赞

在Java编程中，多线程并发执行可能会带来线程安全问题。以下是一个简单的线程安全问题实例：

假设我们有一个共享的计数器（`count`变量）和两个线程（ThreadA和ThreadB）。

线程A负责递增计数器：
```java
class ThreadA implements Runnable {
    private int count = 0;
    private Object lock = new Object();

@Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (count < 10) {
                    count++;
                    System.out.println("ThreadA incremented count to " + count);
                    lock.notifyAll(); // Notify other threads waiting on lock
                    break;
                }
            } // End of synchronized block
            try {
                Thread.sleep(100); // Sleep for 100ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
线程B负责检查计数器是否达到一定值：
```java
class ThreadB implements Runnable {
    private int count = 0;
    private Object lock = new Object();

@Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (count >= 5) { // Check if count is greater than or equal to 5
                    System.out.println("ThreadB checked count and found it >= 5");
                    lock.notifyAll(); // Notify other threads waiting on lock
                    break;
                }
            } // End of synchronized block
            try {
                Thread.sleep(1000); // Sleep for 1 second (to simulate slower operation)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
问题在于，如果线程A先增加计数器到4（比如5-1），然后进入休眠状态，此时线程B检查计数器时发现是4。线程B将计数器加到5后，其他线程如线程A仍然没有被唤醒。

为了解决这个问题，我们需要使用Java的并发工具类来实现锁机制。例如，可以使用`synchronized`关键字或者更高级的锁，如`ReentrantLock`。

这样，当线程A和B共享计数器并进行操作时，它们将能够正确地控制访问，避免出现线程安全问题。