【多生产者多消费者实现】1.Runnable用于实现线程任务 2.BlockingQueue用于线程数据交换

1)产品

package juc.blockingqueue;

public class Product {
    public Product() {

    }

    @Override
    public String toString() {
        return "Product$" + this.hashCode();
    }
}

2)生产者

package juc.blockingqueue;

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {
    private BlockingQueue<Product> queue;

    public Producer(BlockingQueue<Product> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        Product prod = null;
        String tName = Thread.currentThread().getName();
        while (!Thread.interrupted()) {
            prod = new Product();
            System.out.printf("[%s] produce %s \n", tName, prod);

            try {
                queue.put(prod);
                Thread.sleep(250);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

3)消费者

package juc.blockingqueue;

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {
    private BlockingQueue<Product> queue;

    public Consumer(BlockingQueue<Product> queue) {
        this.queue = queue;
    }


    @Override
    public void run() {
        Product prod = null;

        String tName = Thread.currentThread().getName();

        while (!Thread.interrupted()) {
            try {
                prod = queue.take();
                System.out.printf("[%s] consume %s \n", tName, prod);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

4)测试类

package juc.blockingqueue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueTest {
    public static void main(String[] args) {
        BlockingQueue<Product> queue = new LinkedBlockingQueue<>(10);

        Thread p1 = new Thread(new Producer(queue), "Producer-1");
        Thread p2 = new Thread(new Producer(queue), "Producer-2");
        Thread p3 = new Thread(new Producer(queue), "Producer-3");


        Thread c1 = new Thread(new Consumer(queue), "Consumer-1");
        Thread c2 = new Thread(new Consumer(queue), "Consumer-2");
        Thread c3 = new Thread(new Consumer(queue), "Consumer-3");

        p1.start();
        p2.start();
        p3.start();

        c1.start();
        c2.start();
        c3.start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        p1.interrupt();
        p2.interrupt();
        p3.interrupt();

        c1.interrupt();
        c2.interrupt();
        c3.interrupt();

    }
}

[Producer-1] produce Product$1017826111 
[Producer-3] produce Product$388481805 
[Producer-2] produce Product$733316467 
[Consumer-2] consume Product$388481805 
[Consumer-1] consume Product$1017826111 
[Consumer-3] consume Product$733316467 
[Producer-1] produce Product$725109067 
[Producer-3] produce Product$434122649 
[Producer-2] produce Product$628256373 
[Consumer-2] consume Product$725109067 
[Consumer-3] consume Product$628256373 
[Consumer-1] consume Product$434122649 
[Producer-2] produce Product$558755331 
[Producer-3] produce Product$501196925 
[Producer-1] produce Product$361717370 
[Consumer-3] consume Product$501196925 
[Consumer-2] consume Product$558755331 
[Consumer-1] consume Product$361717370 
[Producer-2] produce Product$1682924622 
[Producer-1] produce Product$1349900923 
[Producer-3] produce Product$1490888098 
[Consumer-3] consume Product$1682924622 
[Consumer-3] consume Product$1490888098 
[Consumer-2] consume Product$1349900923 

总结:

所有线程共享一个BlockingQueue，多个生产者往里面提交消息，相当于消息总线。

而多个消费者不断从里面取消息,从而进行多线程消费。