多线程开发案例之生产者消费者问题

1. 生产者负责信息内容的生产
2. 生产者生产完成一项完整的信息之后消费者要从这里面取走信息。
3. 若生产者还没有生产完成着消费者等它生产完成，反之若消费者还没有对信息进行消费，则生产者应该等待消费完成后再继续生产。

生产者消费者定义为两个独立的线程类对象，那么两个线程之间就需要一个数据的保存到集中点，单独定义一个Message类。

案例：

public class ThreadDemo {	
	public static void main(String[] args) throws Exception{
		Message msg=new Message();
		new Thread(new Producter(msg)).start();//启动生产者线程
		new Thread(new Consumer(msg)).start();//启动消费者线程
	}
}

class Producter implements Runnable{//生产者
	private Message msg;
	public Producter(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int x=0;x<100;x++){
			if(x%2==0){
				this.msg.setTitle("UZI");
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				this.msg.setContent("乌兹，永远滴神");
			}else{
				this.msg.setTitle("Faker");
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				this.msg.setContent("大魔王，吨吨吨");
			}
		}
	}
}
class  Consumer implements Runnable{//消费者
	private Message msg;
	public Consumer(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int x=0;x<100;x++){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(this.msg.getTitle()+" - "+this.msg.getContent());//输出格式
		}
	}
}


class Message {
	private String title;
	private String content;
	public void setContent(String content){
		this.content=content;
	}
	public void setTitle(String title){
		this.title=title;
	}
	public String getContent(){
		return content;
	}
	public String getTitle(){
		return title;
	}
}

部分连续输出的结果

UZI - 大魔王，吨吨吨
Faker - 乌兹，永远滴神
UZI - 大魔王，吨吨吨
Faker - 乌兹，永远滴神
UZI - 大魔王，吨吨吨
Faker - 乌兹，永远滴神
Faker - 大魔王，吨吨吨

问题：
1.可以看出来数据不同步了，乌兹替Faker吨吨吨去了，李哥当神去了。
2.有重复生产与重复取出的问题。连续出现两个Faker

解决这一问题首先解决的就是数据同步的处理问题，解决数据同步使用Synchronized的同步代码块或同步方法，于是对同步的处理就可以在Message类中完成。

import javax.xml.ws.handler.MessageContext;


class Message {
	private String title;
	private String content;
	public synchronized	void set(String title,String content){
		this.title=title;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.content=content;
	}
	public synchronized S+tring get(){
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return this.title+" - "+this.content;
	}
}

public class ThreadDemo +{	
	public static void main(String[] args) throws Exception{
		Message msg=new Message();
		new Thread(new Producter(msg)).start();//启动生产者线程
		new Thread(new Consumer(msg)).start();//启动消费者线程
	}
}

class Producter implements Runnable{
	private Message msg;
	public Producter(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int x=0;x<100;x++){
			if(x%2==0){
				this.msg.set("UZI","乌兹，永远滴神");
			}else{
				this.msg.set("Faker","大魔王，吨吨吨");
			}
		}
	}
}
class  Consumer implements Runnable{
	private Message msg;
	public Consumer(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int x=0;x<100;x++){
				
			System.out.println(this.msg.get()+" - "+this.msg.get());
		}
	}
}

Faker - 大魔王，吨吨吨 - Faker - 大魔王，吨吨吨
UZI - 乌兹，永远滴神 - Faker - 大魔王，吨吨吨
UZI - 乌兹，永远滴神 - UZI - 乌兹，永远滴神 
Faker - 大魔王，吨吨吨 - Faker - 大魔王，吨吨吨
Faker - 大魔王，吨吨吨 - Faker - 大魔王，吨吨吨

没有解决重复执行的问题。

要解决生产者与消费者问题，最好的解决方案就是使用等待与唤醒，主要依靠的是Object类中通过的方法：
等待机制：
-死等：public final void wait() throws InterruptedException;
-设置等待时间：public final void wait(long timeout) throws InterruptedException;
-设置等待时间：public final void wait(long timeout，int nanos) throws InterruptedException;

唤醒第一个等待线程：public void final nitify();
唤醒全部的等待线程：public void final nitifyAll();
多线程最原始的实现方案。

import javax.xml.ws.handler.MessageContext;


class Message {
	private String title;
	private String content;
	private boolean flag=true;//表示生产或消费的形式
	//flag=true允许生产不允许消费
	//flag=false允许消费不允许消费
	public synchronized	void set(String title,String content){
		
		if(!this.flag){//无法生产等待消费 
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.title=title;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.content=content;
		this.flag=false; //已经生产过了
		super.notify();//唤醒等待的线程
	}
	public synchronized String get(){
		if(this.flag==true){//还未生产需要等待
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try{
		return this.title+" - "+this.content;
		}finally{//无论如何都要执行
			this.flag =true ;//继续生产
			super.notify();//唤醒等待线程
		}
	}
}

public class ThreadDemo {	
	public static void main(String[] args) throws Exception{
		Message msg=new Message();
		new Thread(new Producter(msg)).start();//启动生产者线程
		new Thread(new Consumer(msg)).start();//启动消费者线程
	}
}

class Producter implements Runnable{
	private Message msg;
	public Producter(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int x=0;x<100;x++){
			if(x%2==0){
				this.msg.set("UZI","乌兹，永远滴神");
			}else{
				this.msg.set("Faker","大魔王，吨吨吨");
			}
		}
	}
}
class  Consumer implements Runnable{
	private Message msg;
	public Consumer(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int x=0;x<100;x++){
				
			System.out.println(this.msg.get()+" - "+this.msg.get());
		}
	}
}

有点迷，记录下