java多线程-生产者消费者

前言(快点我–生产者消费者进阶)

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

创建管理类

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

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

解释下notfy和notifyAll

notify和notifyAll都是让处于等待队列中的线程出队，进入争抢锁的队列，从而可以去争抢锁资源。不同的是，notify是从等待queue中选择一个出队进入争抢队列中，而notifyAll将清空等待队列，所有等待的线程都会进入争抢队列中去获取锁。

synchronized下的wait/notify

synchronized下的生产者消费者，必须要使用notifyAll来做唤醒，因为等待queue中的线程分为两类，一类是消费者线程，一类是生产者线程，它们wait条件不一样，因而notify唤醒的线程极可能是同类线程，那么在临界情况下，会导致线程进入 假死锁 状态。所以使用synchronized关键字去做的话，必须notifyAll来保证线程安全。

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 + "这里暂停");
					count = 0;
					// 执行wait，立即释放锁，等待再次获得锁，在继续往下执行
					this.wait();
				}
				Thread.sleep(500);
				// 生产出2件后
				num++;
				count++;
				System.out.println("生产者"+Thread.currentThread().getName()+"：生产了" + count + "件，总件数为" + num + "继续生产");
				this.notifyAll();
			}		
	}

	public synchronized void consume(int need) throws Exception {
			while (num < need) {
				System.out.println("消费者"+Thread.currentThread().getName()+"：需要" + need + "件，总件数为" + num + "不够等待");
				this.wait();
			}
			num -= need;
			System.out.println("消费者"+Thread.currentThread().getName()+"：消费" + need + "件，剩余" + num + "消费离开");
					this.notifyAll();
		}
}

生产者和消费者

这里采用的是集成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来控制的线程间通信。

最新的消费者/生产者文章