多线程同步问题：Java互斥锁与条件变量实例

原创た入场券 2024-09-16 06:04 85阅读 0赞

在Java中，互斥锁和条件变量是多线程同步的两种主要手段。下面我将分别提供这两种工具的使用实例。

1. 互斥锁（Synchronized Lock）

```java
public class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
    }

public synchronized int decrementIfZero() {
        if (count == 0) {
            count--;
            return count; // Decrement and return
        } else {
            count--; // Decrement without returning
            return count; // Update count for potential future return
        }
    }

public synchronized boolean isEmpty() {
        return count == 0;
    }

public int getCount() {
        return count;
    }
}
```
这段代码定义了一个`Counter`类，其中包含互斥锁的同步方法。例如，`increment()`会锁定计数器并递增。

2. 条件变量（Conditional Variable）

```java
public class ProducerConsumerExample {
    private final Object lock = new Object();
    private final Condition notEmpty = new Conditional(lock, "count"));
    private int count = 0;

public void produce() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            // 生产逻辑，这里只是模拟
            System.out.println("Producer produced: " + i);
            notEmpty.signal(); // 唤醒等待的消费者
            // 等待下一次生产
            synchronized (lock) {
                lock.wait();
            }
        }
    }

public void consume() throws InterruptedException {
        while (true) {
            // 消费逻辑，这里只是模拟
            System.out.println("Consumer consumed: " + count);
            if (notEmpty.await(100, TimeUnit.MILLISECONDS))) { // 如果计数不为空，则继续消费
                count++;
            }
            // 等待下一次消费
            synchronized (lock) {
                lock.wait();
            }
        }
    }

public static void main(String[] args) throws InterruptedException {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producerThread = new Thread(example::produce);
        Thread consumerThread = new Thread(example::consume);

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

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

System.out.println("Final count: " + example.count);
    }
}
```
这段代码定义了一个多线程的生产消费模型。生产者通过`produce()`方法向共享资源（这里是一个条件变量）中添加元素。消费者通过`consume()`方法从资源中获取并消费元素。

注意，这个例子中的计数器使用了互斥锁来保证其在多线程环境下的正确性。