Java多线程并发问题：实战示例

原创快来打我* 2024-11-02 00:00 30阅读 0赞

Java多线程并发问题是一个复杂的话题，涉及到线程安全、同步、死锁等多个方面。下面我将通过一个简单的示例来展示如何使用Java的多线程来解决并发问题。

### 示例：生产者-消费者问题生产者-消费者问题是并发编程中的经典问题，它涉及到两个线程：生产者线程负责生产数据，消费者线程负责消费数据。我们的目标是确保生产者不会在消费者消费数据之前生产过多的数据，同时消费者也不会在没有数据可消费时尝试消费。

####1.定义共享资源首先，我们需要定义一个共享资源，这里我们使用一个固定大小的队列来模拟。

```javaimport java.util.LinkedList;
import java.util.Queue;

public class SharedResource {
 private Queue<Integer> queue = new LinkedList<>();
 private int maxSize =10; //队列的最大容量 public synchronized void produce(int value) throws InterruptedException {
 while (queue.size() == maxSize) {
 wait(); // 如果队列满了，生产者线程等待 }
queue.add(value);
 System.out.println("Produced: " + value);
 notify(); //唤醒等待的消费者线程 }

public synchronized int consume() throws InterruptedException {
 while (queue.isEmpty()) {
 wait(); // 如果队列为空，消费者线程等待 }
int value = queue.remove();
 System.out.println("Consumed: " + value);
 notify(); //唤醒等待的生产者线程 return value;
 }
}
```####2. 创建生产者和消费者线程接下来，我们创建生产者和消费者线程，它们将共享上面定义的资源。

```javapublic class Producer extends Thread {
 private SharedResource sharedResource;

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

@Override public void run() {
 for (int i =0; i <20; i++) {
 try {
 sharedResource.produce(i);
Thread.sleep(100); //模拟生产时间} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
}

public class Consumer extends Thread {
 private SharedResource sharedResource;

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

@Override public void run() {
 for (int i =0; i <20; i++) {
 try {
int value = sharedResource.consume();
Thread.sleep(100); //模拟消费时间} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
}
```####3.启动线程最后，我们创建并启动生产者和消费者线程。

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

Producer producer = new Producer(sharedResource);
 Consumer consumer = new Consumer(sharedResource);

producer.start();
 consumer.start();
 }
}
```这个示例展示了如何使用`synchronized`关键字和`wait()`/`notify()`方法来确保线程安全和协调生产者和消费者线程。在实际应用中，你可能需要使用更高级的并发工具，如`ReentrantLock`、`Semaphore`、`BlockingQueue`等，以提供更灵活和高效的并发控制。