Java多线程同步问题：实战案例

原创不念不忘少年蓝@ 2024-12-11 04:09 8阅读 0赞

在Java中，多线程的同步问题主要通过synchronized关键字、Lock接口和wait/notify机制来解决。

以下是一个简单的多线程同步案例，我们将创建一个生产者和消费者类，通过共享资源实现同步：

1. 生产者类（Producer.java）：

```java
public class Producer {
    private final Object lock = new Object();
    private int counter;

public synchronized void produce() {
        if (counter < 5) {
            System.out.println("Producer produced: " + counter);
            counter++;
            notifyAll(); // notify waiting consumers
        } else {
            System.out.println("Producer reached limit, no more produced.");
        }
    }
}
```

2. 消费者类（Consumer.java）：

```java
public class Consumer {
    private final Object lock = new Object();
    private int counter;

public synchronized void consume() {
        while (counter < 5) { // wait until produced
            try {
                wait(lock); // wait on the lock
            } catch (InterruptedException e) {
                System.out.println("Consumer interrupted while waiting.");
                Thread.currentThread().interrupt(); // restore interrupted state
                e.printStackTrace();
            }
        }

System.out.println("Consumer consumed: " + counter);
        counter--;
        notifyAll(); // notify waiting producers
    }
}
```

3. 主程序（Main.java）：

```java
public class Main {
    public static void main(String[] args) {
        Producer producer = new Producer();
        Consumer consumer = new Consumer();

// 创建生产者和消费者线程
        Thread producerThread = new Thread(producer, "Producer"));
        Thread consumerThread = new Thread(consumer, "Consumer"));

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

// 等待所有线程完成执行
        try {
            producerThread.join();
            consumerThread.join();
        } catch (InterruptedException e) {
            System.out.println("Interrupted while waiting for thread completion.");
            Thread.currentThread().interrupt(); // restore interrupted state
            e.printStackTrace();
        }
    }
}
```

通过上述代码，我们创建了一个多线程同步的生产者-消费者模型。在这个例子中，锁（synchronized关键字）用于保证同一时刻只有一个线程执行特定操作，实现了多线程间的同步。