Java多线程同步问题：死锁、活锁的示例

原创拼搏现实的明天。 2024-09-11 11:27 106阅读 0赞

在Java多线程编程中，死锁和活锁是两个常见的并发问题。

1. 死锁示例（Java代码）：

**定义资源（线程池）**：
   ```java
   ExecutorService resourcePool = Executors.newFixedThreadPool(5);
   ```

**定义线程A和B共享资源**：
   ```java
   class Producer extends Thread {
       private Resource resource;

Producer(Resource resource) {
           this.resource = resource;
       }

@Override
       public void run() {
           // 在这里模拟生产资源
           for (int i = 0; i < 10; i++) {
               try {
                   // 将资源分配给线程B
                   resourcePool.submit(new Consumer(resource)));
               } catch (RejectedExecutionException e) {
                   // 没有资源可用，返回原线程
                   resourcePool.shutdownNow();
                   resource = null;
                   producerThread.interrupt(); // 通知线程A中断
                   break;
               }
           }
       }
   }

class Consumer extends Thread {
       private Resource resource;

Consumer(Resource resource) {
           this.resource = resource;
       }

@Override
       public void run() {
           // 在这里模拟消费资源
           for (int i = 0; i < 5; i++) {
               try {
                   Thread.sleep(100); // 模拟耗时操作
                   System.out.println("Consumer " + i + " consumed resource " + resource.getId());
                   // 资源消费后，将资源归还给生产者线程
                   producerThread.notify(); // 通知生产者线程
               } catch (InterruptedException e) {
                   // 线程中断，表示资源已经被其他线程占用或回收
                   System.out.println("Interrupted while waiting to return resource. Resource might be consumed or released by other thread.");
                   break;
               }
           }
       }
   }

// 生产者线程
   class ProducerThread extends Thread {
       private Resource resource;

ProducerThread(Resource resource) {
           this.resource = resource;
       }

@Override
       public void run() {
           try {
               // 无限循环，模拟资源持续生产
               while (true) {
                   producerThread.notify(); // 通知消费者线程等待资源归还
                   Thread.sleep(500); // 模拟生产者线程和消费者线程之间的交互时间间隔
               }
           } catch (InterruptedException e) {
               System.out.println("Interrupted during resource production loop. Production might be paused or stopped.");
           }
       }
   }

// 创建资源对象
   Resource resource = new Resource();

// 启动生产者线程和消费者线程
   producerThread.start();
   consumerThread.start();

```
这个例子中，两个线程（生产者和消费者）共享一个资源。如果线程A（生产者）在生产资源时被其他线程B（消费者）占用或归还了资源，那么线程A会等待资源可用，这可能导致死锁。

解决这个问题的方法是使用同步机制，如`synchronized`关键字、`Lock`接口等，来确保对共享资源的访问是有序和一致的。