Java中多线程同步问题：锁机制实战案例

原创朱雀 2024-12-11 12:45 9阅读 0赞

在Java中，多线程同步主要是通过锁（Lock）来实现。这里我们将通过一个实际的生产者消费者模型案例来解释锁机制。

**1. 创建类结构**

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 1) 生产者
class Producer {
    private final Lock lock = new ReentrantLock();

// 2) 生产方法
    public void produce() throws InterruptedException {
        lock.acquire(); // 获取锁

try {
            // 逻辑处理，例如生产商品
            System.out.println("Producer produced an item");

// 当生产完成后，释放锁
            lock.release();
        } catch (Exception e) {
            e.printStackTrace();
            lock.release(); // 锁释放，即使有异常也要确保同步
        }
    }
}

// 2) 消费者
class Consumer {
    private final Lock lock = new ReentrantLock();

// 3) 消费方法
    public void consume() throws InterruptedException {
        lock.acquire(); // 获取锁

try {
            // 逻辑处理，例如消费商品
            System.out.println("Consumer consumed an item");

// 当消费完成后，释放锁
            lock.release();
        } catch (Exception e) {
            e.printStackTrace();
            lock.release(); // 锁释放，即使有异常也要确保同步
        }
    }
}
```

**2. 使用场景**

创建两个线程`ProducerThread`和`ConsumerThread`：

```java
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 创建生产者和消费者对象
        Producer producer = new Producer();
        Consumer consumer = new Consumer();

// 创建新线程并启动它们
        Thread producerThread = new Thread(producer, "Producer"));
        Thread consumerThread = new Thread(consumer, "Consumer"));

producerThread.start(); // 生产者开始
        consumerThread.start(); // 消费者开始

// 等待所有线程执行完毕
        producerThread.join();
        consumerThread.join();
    }
}
```

这样，你就可以通过锁机制控制多线程的同步问题。