Java多线程同步问题：基于Lock的解决方案实例

原创分手后的思念是犯贱 2024-10-15 11:45 66阅读 0赞

在Java中，Lock接口提供了比synchronized关键字更多的控制。以下是一个基于Lock的解决方案实例，我们以一个简单的生产者消费者模型为例：

1. 创建一个共享资源（如队列）：
```java
import java.util.LinkedList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SharedResource {
    private LinkedList<Integer> queue = new LinkedList<>();

// 获取锁，允许线程操作共享资源
    public Lock getLock() {
        return new ReentrantLock();
    }

// 从队列中移除元素
    public void removeAndReturn(int value) {
        lock.getLock().lock();
        try {
            queue.remove(value);
            return value;
        } finally {
            lock.getLock().unlock();
        }
    }
}
```

2. 生产者和消费者代码：
```java
public class ProducerConsumer {
    private SharedResource sharedResource;

public ProducerConsumer(SharedResource sharedResource) {
        this.sharedResource = sharedResource;
    }

// 生产者
    public void produce() {
        for (int i = 0; i < 10; i++) {
            int valueToProduce = i + 1;
            if (!sharedResource.queue.contains(valueToProduce))) {
                sharedResource.removeAndReturn(valueToProduce);
                System.out.println("Produced: " + valueToProduce);
            }
        }
    }

// 消费者
    public void consume() {
        for (int i = 0; i < 10; i++) {
            int consumedValue = i;
            if (sharedResource.queue.contains(consumedValue))) {
                sharedResource.removeAndReturn(consumedValue);
                System.out.println("Consumed: " + consumedValue);
            }
        }
    }

public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        ProducerConsumer producerConsumer = new ProducerConsumer(resource);

Thread producerThread = new Thread(producerConsumer::produce));
        Thread consumerThread = new Thread(producerConsumer::consume));

producerThread.start();
        consumerThread.start();

// 等待线程结束
        producerThread.join();
        consumerThread.join();
    }
}
```

这个例子中，我们创建了一个共享资源（队列），然后使用Lock来管理对共享资源的访问。生产者和消费者分别通过不同的线程执行任务，实现了多线程同步。