Java多线程之线程协作

常见的线程协作方式是：生产者/消费者。

一个线程作为生产者，生产要处理数据，比如拿一个线程来生产Order，用户每下一单，此线程就生产一个Order对象。

设置一个仓库，来存放生产出来的Order对象。

一个线程作为消费者，消费|处理仓库中的Order对象（打印订单、拣货、发货）。

demo 订单处理流程

1、用一个类来封装要处理的数据

1public class Order {
2    private int id;
3    //...
4
5    public Order(int id) {
6        this.id = id;
7    }
8
9    public int getId() {
10        return id;
11    }
12
13    //......
14}

2、仓库

1import java.util.concurrent.BlockingQueue;
2import java.util.concurrent.LinkedBlockingQueue;
3
4public class OrderStorage {
5    //使用阻塞队列作为仓库
6    private BlockingQueue<Order> queues;
7
8    //默认仓库容量为50
9    public OrderStorage() {
10        this.queues = new LinkedBlockingQueue<>(50);
11    }
12
13    //初始化仓库容量
14    public OrderStorage(int capacity) {
15        this.queues = new LinkedBlockingQueue<>(capacity);
16    }
17
18    //入库
19    public void push(Order order) throws InterruptedException {
20        queues.put(order);
21    }
22
23    //出库
24    public Order pop() throws InterruptedException {
25        return queues.take();  //仓库中没元素时，会阻塞当前线程，直到有元素可弹出。要不怎么叫BlockingQueue
26    }
27}

java.util.concurrent包下有很多并发要使用的类，我们使用的阻塞队列就是这个包下的。concurrent 并发

队列是先进先出的，先生产的先放到仓库中，先处理。

3、生产者

1public class ProducerThread extends Thread{
2    public static OrderStorage orderStorage = new OrderStorage(100); //仓库容量为100
3
4    @Override
5    public void run() {
6        int i=1;
7        while (true){
8            Order order = new Order(i);
9            try {
10                orderStorage.push(order); //放到仓库中
11                System.out.println("已生产编号为"+i+"的订单");
12                Thread.sleep(1000); //降低速度，方便看效果
13            } catch (InterruptedException e) {
14                e.printStackTrace();
15            }
16            i++;
17        }
18    }
19
20}

容量为100，不是说只能生成50个Order，生产的同时消费者也在消费仓库中的Order。

4、消费者

1public class ConsumerThread extends Thread {
2    private OrderStorage orderStorage=ProducerThread.orderStorage; //消费者和生产者使用的要是同一个仓库
3
4    @Override
5    public void run() {
6        while (true){
7            try {
8                Order order = orderStorage.pop(); //如果仓库中没有Order，会阻塞当前线程，直到有Order可以弹出
9                System.out.println("已消费|处理编号为"+order.getId()+"的订单");
10                Thread.sleep(1000); //降低速度，方便看效果
11            } catch (InterruptedException e) {
12                e.printStackTrace();
13            }
14        }
15    }
16
17}

5、测试类

1public class Test {
2    public static void main(String[] args) {
3        ProducerThread producerThread = new ProducerThread();
4        producerThread.start();
5
6        ConsumerThread consumerThread = new ConsumerThread();
7        consumerThread.start();
8
9    }
10}

6、效果

有时候一个订单，会先打印“消费”，再打印“生产”。

一个Order处理顺序一定是：生产、入库 -> 出库、消费，要先放到仓库中才能从仓库中获取到。

只是说生产者、消费者2个线程执行sout时获取到时间片的先后不同。