多线程初探之生产者消费者

前言

对于java开者而言，多线程开发是不可避免的，多线程程序相对于单线程程序稳定性更强，一个线程挂了不会影响整个程序的正常运行。在多cup的机器上，多线程更加具有效率上的优势。但是多线程也会导致一些问题，集中出现在数据方面。当多个线程操作同一个数据源的时候就会出现读脏的问题，如何在多线程下保证数据的原子性和可见性，就显得格外的重要。下面就为大家来解析生产者消费者模式。

创建管理类

Manager 类负责生产和消费者两种动作。在product方法中，当num的值大于100时，结束循环，最后一次执行完毕后任务结束。c代表生产多少后开始wait然后唤醒当前锁线程池中等待的其他线程去争夺当前锁。如果未达到生产要求则继续执行，不会释放锁。其他线程任然是等待，这里不需要唤醒其他线程，因为唤醒的话也没用，不会释放锁，因为此代码是在同步快中，线程是同步执行的。

consume方法是消费者的方法，此方法比较简单，就是当当前产品的数量满足自己的消费量时进行消费，并且该线程就结束了。否则会wait，这里要先执行notifyAll()方法，来唤醒等待线程，再wait。

---

package com.yzz.t.Thread;public class Manager {    private int num = 0;    public synchronized void product(int c) throws Exception {            int count = 0;            while (num<100) {                if (count == c) {                    System.out.println("生产者"+Thread.currentThread().getName()+"：生产了" + count + "件，总件数为" + num + "这里暂停");                    // notifa或者notifaAll必须在wait之前调用。                    this.notifyAll();                    count = 0;                    // 执行wait，立即释放锁，等待再次获得锁，在继续往下执行                    this.wait();                }                Thread.sleep(500);                // 生产出2件后                num++;                count++;                System.out.println("生产者"+Thread.currentThread().getName()+"：生产了" + count + "件，总件数为" + num + "继续生产");            }           }    public synchronized void consume(int need) throws Exception {            while (num < need) {                System.out.println("消费者"+Thread.currentThread().getName()+"：需要" + need + "件，总件数为" + num + "不够等待");                this.notifyAll();                this.wait();            }            num -= need;            System.out.println("消费者"+Thread.currentThread().getName()+"：消费" + need + "件，剩余" + num + "消费离开");        }}

生产者和消费者

这里采用的是集成Thread的方式来写线程，其实实现Runable接口和继承Thread类没有本质上的区别，唯一的区别体现在多继承的机况下，就会出现问题了，所有实现Runable接口就体现出优势来了。

package com.yzz.t.Thread;public class Producter extends Thread{    private Manager manager;    private int c;    public Producter(Manager manager,int c,String name) {        super();        this.manager = manager;        setName(name);        this.c = c;    }    @Override    public void run() {        try {            super.run();            manager.product(c);        } catch (Exception e) {            e.printStackTrace();        }    }}

package com.yzz.t.Thread;public class Consumer extends Thread{    private Manager manager;    private int need;    public Consumer(Manager manager, int need,String name) {        super();        this.manager = manager;        this.need = need;        setName(name);    }    @Override    public void run() {        try {            super.run();            manager.consume(need);        } catch (Exception e) {            e.printStackTrace();        }    }}

测试

这里开启了两个线程去充当生产者，六个线程去充当消费者，生产者的生产能力和消费者的消费能力都不一样。

package com.yzz.t.test;import com.yzz.t.Thread.Consumer;import com.yzz.t.Thread.Manager;import com.yzz.t.Thread.Producter;public class Test {    public static void main(String[] args) {        Manager manager = new Manager();        Producter producter1 = new Producter(manager,2,"生产者1");        Producter producter2 = new Producter(manager,1,"生产者2");        Producter producter3 = new Producter(manager,1,"生产者3");        Consumer consumer1 = new Consumer(manager, 12, "消费者1");        Consumer consumer2 = new Consumer(manager, 23, "消费者2");        Consumer consumer3 = new Consumer(manager, 1, "消费者3");        Consumer consumer4 = new Consumer(manager, 3, "消费者4");        Consumer consumer5 = new Consumer(manager, 8, "消费者5");        Consumer consumer6 = new Consumer(manager, 46, "消费者6");        producter1.start();        producter2.start();        producter3.start();        consumer1.start();        consumer2.start();        consumer3.start();        consumer4.start();        consumer5.start();        consumer6.start();    }}

结果

生产者和消费者模式只是一种思想，没有固定的模式，根据具体的业务需求也有不同的形式，但是最终都是通过在同步环境下使用wait和notifaAll来控制的线程间通信。