Java多线程竞态条件问题分析及代码演示

原创墨蓝 2024-09-30 03:06 29阅读 0赞

竞态条件是指多个线程在访问和修改共享资源时，由于执行顺序的不确定而产生的错误情况。

常见的竞态条件包括：
1. 读写不一致：如一个共享变量，两个线程分别读取和写入。
2. 死锁：两个或多个线程因争夺资源而造成的一种互相等待的现象。
3. 数据丢失：多个线程同时修改同一数据，可能会导致数据的丢失。

下面是一个简单的Java多线程竞态条件问题分析及代码演示：

```java
// 创建共享变量
public class Counter {
    private int count;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalArgumentException("Counter is already zero");
        }
    }

// 简单获取当前计数
    public synchronized int getCount() {
        return count;
    }
}

// 多线程测试
public class CounterDemo {
    private final Counter counter;

public CounterDemo(Counter counter) {
        this.counter = counter;
    }

public void incrementThread() {
        new Thread(() -> {
            while (true) {
                counter.increment();
                // 模拟休眠，以观察线程调度
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        })).start();
    }

public void decrementThread() {
        new Thread(() -> {
            while (true) {
                counter.decrement();
                // 模拟休眠，以观察线程调度
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        })).start();
    }

public static void main(String[] args) {
        Counter counter = new Counter();

new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 1: Incrementing by " + i);
                counter.increment();
                // 模拟检查计数是否为0
                if (counter.getCount() == 0) {
                    break;
                }
            }
        })).start();

new Thread(() -> {
            for (int i = 5; i >= 1; i--) {
                System.out.println("Thread 2: Decrementing by " + i);
                counter.decrement();
                // 模拟检查计数是否为0
                if (counter.getCount() == 0) {
                    break;
                }
            }
        })).start();

try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Counter value: " + counter.getCount());
    }
}
```

在这个示例中，我们创建了一个共享的Counter类，两个线程分别进行递增和递减操作。由于共享资源的不安全性，可能出现读写不一致的情况。

在实际应用中，需要使用synchronized关键字、Lock接口或ReentrantLock等机制来保证多线程的正确交互。