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

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_22271479/article/details/78495042

前言

对于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来控制的线程间通信。