多线程同步：Java中的Lock接口实操

原创一时失言乱红尘 2024-09-10 04:09 22阅读 0赞

在Java中，多线程同步主要通过Lock接口来实现。Lock是java.util.concurrent.locks包下的一个抽象类。

以下是一个使用Lock接口实操的例子，我们创建一个简单的生产者和消费者模型：

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

public class LockExample {

private final Lock lock = new ReentrantLock(); // 使用ReentrantLock作为示例

public void producer() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Producer creating an item...");
            Thread.sleep(2000); // 仿真生产过程
        } finally {
            lock.unlock();
            System.out.println("Producer done, unlocking the lock.");
        }
    }

public void consumer() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        Thread thread = new Thread(() -> latch.countDown()));
        thread.start();

lock.lock();
        try {
            while (latch.getCount() > 0) {
                System.out.println("Consumer waiting for an item...");
                Thread.sleep(500); // 轻微等待
            }

System.out.println("Consumer got the item, unlocking the lock.");
        } finally {
            lock.unlock();
            latch.countDown(); // 让消费者知道可以消费了
            System.out.println("Consumer done, counting down and unlocking the lock.");
        }
    }

public static void main(String[] args) throws InterruptedException {
        LockExample example = new LockExample();
        Thread producerThread = new Thread(example::producer);
        Thread consumerThread = new Thread(example::consumer);

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

producerThread.join(); // 等待生产者结束
        consumerThread.join(); // 等待消费者结束

System.out.println("All threads done, exiting the program.");
    }
}
```

这个例子中，`LockExample`类创建了锁对象，并通过方法暴露给其他线程使用。生产者和消费者线程分别在获取锁后进行相应的操作。最后通过join方法等待所有线程结束。