并发编程挑战：Java多线程同步和互斥问题实例

原创墨蓝 2024-12-05 23:12 0阅读 0赞

在Java多线程编程中，同步和互斥是两个重要的概念。下面我们将通过一个实例来详细解释。

**实例：生产者消费者问题**

1. **生产者（Producer）**：创建产品并将其放入队列。
2. **消费者（Consumer）**：从队列中获取产品进行消费。

在Java中，我们可以使用`synchronized`关键字来实现同步和互斥。

例如，一个简单的生产者消费者场景：

```java
// 创建两个共享资源对象
private class SharedResource {
    private int count;
    private Object lock = new Object();

synchronized void increment() {
        count++;
        notifyAll(); // 一旦计数增加到1，通知所有等待的线程
    }

synchronized int getCount() {
        return count;
    }
}

// 生产者和消费者类实现
public class ProducerConsumerExample {
    private SharedResource sharedResource;

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

// 生产者线程
    public void producerThread() {
        while (true) { // 无限循环
            synchronized (sharedResource.lock) { // 获取锁
                if (sharedResource.getCount() < 10) { // 如果资源足够
                    sharedResource.increment(); // 增加资源
                    System.out.println("Producer added item to the queue.");
                } else {
                    System.out.println("Queue is full. Producer cannot add items.");
                    try {
                        Thread.sleep(2000); // 线程睡眠2秒，模拟处理逻辑的时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

// 消费者线程
    public void consumerThread() {
        while (true) { // 无限循环
            synchronized (sharedResource.lock) { // 获取锁
                if (sharedResource.getCount() > 0) { // 如果资源足够
                    sharedResource.decrement(); // 增加资源
                    System.out.println("Consumer consumed item from the queue.");
                } else {
                    System.out.println("Queue is empty. Consumer cannot consume items.");
                    try {
                        Thread.sleep(2000); // 线程睡眠2秒，模拟处理逻辑的时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

// 创建生产者线程并启动
        Thread producerThread = new Thread(new ProducerConsumerExample(sharedResource)).producerThread());
        producerThread.start();

// 创建消费者线程并启动
        Thread consumerThread = new Thread(new ProducerConsumerExample(sharedResource)).consumerThread());
        consumerThread.start();
    }
}
```

在这个例子中，生产者（Producer）负责增加队列中的资源（这里为计数），而消费者（Consumer）则负责消耗队列中的资源。通过同步锁，保证了线程间的互斥和正确执行。