Java多线程问题实例：竞态条件和死锁

原创雨点打透心脏的1/2处 2024-10-09 01:15 73阅读 0赞

在Java编程中，多线程可能会遇到以下两种常见问题：

1. 竞态条件（Race Condition）：
   这是由于多个线程同时访问共享资源导致的。例如：
   
   ```java
   // 假设有一个全局变量count
   class CounterThread extends Thread {
       private int count;

CounterThread(int count) {
           this.count = count;
       }

@Override
       public void run() {
           synchronized (CounterThread.class) { // 使用synchronized来保护共享资源
               for (int i = 0; i < 10; i++) {
                   count += i; // 这里可能会出现count不正确的情况
                   try {
                       Thread.sleep(10); // 延迟执行，模拟其他线程操作
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }}
       }
   }

public static void main(String[] args) {
       CounterThread counter = new CounterThread(0);
       counter.start();

try {
           Thread.sleep(200); // 等待线程执行完毕
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

System.out.println("Final count: " + counter.count);
   }
   ```
在这个例子中，多个CounterThread同时访问count变量。如果count在同步块内更新，那么就可能出现count不正确的竞态条件。

2. 死锁（Deadlock）：
   死锁是两个或多个线程互相等待对方释放资源的情况，从而导致所有线程都无法继续执行。例如：

```java
// 假设有一个生产者和一个消费者
class ProducerThread extends Thread {
    private int product;

ProducerThread(int product) {
        this.product = product;
    }

@Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (ConsumerThread.class) { // 使用synchronized来保护消费者线程
                if (product <= 5) { // 假设生产者只有5个产品
                    product -= 1;
                    ConsumerThread.consumer.take(); // 提取消费者需要的产品
                } else {
                    try {
                        Thread.sleep(500); // 延迟执行，模拟生产者处理资源的时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }}
        }
    }
}

class ConsumerThread extends Thread {
    private int consumer;

ConsumerThread(int consumer) {
        this.consumer = consumer;
    }

@Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (consumer <= 5) { // 假设消费者只有5个产品需求
                consumer += 1;
                ProducerThread.producer.put(consumer); // 提取并放入生产者需要的下一个产品
            } else {
                try {
                    Thread.sleep(500); // 延迟执行，模拟消费者处理产品的时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ProducerThread producer = new ProducerThread(10);
        ConsumerThread consumer = new ConsumerThread(5);

producer.start(); // 开始生产
        consumer.start(); // 开始消费

try {
            producer.join(); // 等待生产线程执行完毕
            consumer.join(); // 等待消费者线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Final product count: " + producer.producer.size()); // 输出最终产品总数
    }
}
```

在这个例子中，生产者和消费者线程同时运行。由于共享资源（如Product）的存在，可能会出现死锁的情况：当一个线程等待另一个线程释放资源时，这两个线程都无法继续执行，从而形成了死锁。

为了避免这种情况，可以使用一些策略来防止死锁，例如设置超时时间、使用死锁预防算法等。