Java多线程，消费者和生产者，随机匹配两个消费者

欢迎关注微信公众号：数据科学与艺术 作者WX:superhe199

背景

在Java多线程中，生产者和消费者模式是一种常见的并发编程模式。它基于生产者生产数据，并交给消费者进行处理的概念。在本文中，我将详细介绍如何实现一个随机匹配的生产者和两个消费者的多线程程序。

一、共享数据队列

需要定义一个共享的数据队列，用于生产者和消费者之间进行数据交换。在Java中，我们可以使用阻塞队列来实现这个功能。阻塞队列是一个线程安全的队列，它提供了阻塞的入队和出队操作，适合用于多线程环境。

接下来，我们定义一个生产者类。生产者类负责生成数据，并将数据放入共享队列中。在这个例子中，我们简单地生成一个随机数，并添加到队列中。生产者类的代码如下所示：

import java.util.Random;
import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {
    private BlockingQueue<Integer> queue;
    
    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    
    @Override
    public void run() {
        Random random = new Random();
        
        try {
            while (true) {
                int data = random.nextInt(100);
                queue.put(data);
                System.out.println("Producer produced: " + data);
                Thread.sleep(1000); // 每隔一秒产生一个数据
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二、 消费者

我们定义一个消费者类。消费者类负责从队列中取出数据，并进行相应的处理。在这个例子中，我们简单地将数据打印到控制台上。消费者类的代码如下所示：

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {
    private BlockingQueue<Integer> queue;
    
    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    
    @Override
    public void run() {
        try {
            while (true) {
                int data = queue.take();
                System.out.println("Consumer consumed: " + data);
                Thread.sleep(1000); // 每隔一秒消费一个数据
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

三、运行

我们需要创建多个生产者和消费者的实例，并将它们放入不同的线程中运行。在这个例子中，我们创建了一个阻塞队列并传递给生产者和消费者。然后，我们使用线程池来管理线程的运行。代码如下所示：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        
        Producer producer = new Producer(queue);
        Consumer consumer1 = new Consumer(queue);
        Consumer consumer2 = new Consumer(queue);
        
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        
        executorService.execute(producer);
        executorService.execute(consumer1);
        executorService.execute(consumer2);
        
        executorService.shutdown();
    }
}

代码将创建一个大小为10的阻塞队列，并将其传递给生产者和消费者。然后，我们使用线程池来执行生产者和消费者的任务。生产者和消费者将不断地生产和消费数据，并打印相关信息。

四、具体代码实现

以下是一个简单的Java多线程生产者消费者模型的实现，其中包括两个消费者和一个生产者，消费者消费完之后继续给另外一个消费者。

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private Queue<Integer> buffer = new LinkedList<>();
    private int capacity = 5;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public void produce() throws InterruptedException {
        Random random = new Random();
        while (true) {
            lock.lock();
            try {
                while (buffer.size() == capacity) { // 缓冲区已满，等待消费者消费
                    notFull.await();
                }
                int data = random.nextInt(100);
                buffer.add(data);
                System.out.println("生产者生产了：" + data);
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    public void consume1() throws InterruptedException {
        while (true) {
            lock.lock();
            try {
                while (buffer.size() == 0) { // 缓冲区为空，等待生产者生产
                    notEmpty.await();
                }
                int data = buffer.poll();
                System.out.println("消费者1消费了：" + data);
                notFull.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    public void consume2() throws InterruptedException {
        while (true) {
            lock.lock();
            try {
                while (buffer.size() == 0) { // 缓冲区为空，等待生产者生产
                    notEmpty.await();
                }
                int data = buffer.poll();
                System.out.println("消费者2消费了：" + data);
                notFull.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        Thread producerThread = new Thread(() -> {
            try {
                pc.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer1Thread = new Thread(() -> {
            try {
                pc.consume1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer2Thread = new Thread(() -> {
            try {
                pc.consume2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumer1Thread.start();
        consumer2Thread.start();
    }
}

生产者线程通过produce()方法不断产生随机数，并将其添加到缓冲区中。消费者线程通过consume1()和consume2()方法不断从缓冲区中取出数据进行消费。当缓冲区已满时，生产者线程进入等待状态，直到有空余空间；当缓冲区为空时，消费者线程进入等待状态，直到有数据可供消费。生产者和消费者线程之间通过Condition来进行线程间通信。

在main()方法中创建了一个ProducerConsumer对象，然后分别创建一个生产者线程、一个消费者1线程和一个消费者2线程，并启动它们。

五、总结

综上所述，我们通过使用Java多线程和阻塞队列成功实现了一个随机匹配的生产者和两个消费者的程序。生产者负责生成数据，消费者负责处理数据，通过共享的阻塞队列实现数据交换。这种设计模式能够提高程序的并发性能，并且保证线程安全。希望本文能够对你理解和实现多线程的生产者-消费者模式有所帮助。