Java多线程中的生产者消费者问题

Java中的线程同步问问题：

// 通过整个代码的执行你会发现此时有两个主要问题
        //问题一：数据不同步了；
        //问题二：生产一个取走一个，但是发现有重复生产和重复取出的问题。
    
    //此时发现数据已经可以正常的保持一致了，但是对于重复操作的问题依然存在。

package cn.pjy.demo;
class Producer10 implements Runnable{		//生产者
	
	private Message10 msg;
	
	//如果说现在要想解决生产者消费者的问题，那么最好的解决方案就是使用等待与唤醒机制。
	//而对于等待与唤醒的操作机制主要依靠的是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 final void notify()	
		//唤醒全部等等待线程：public final void notifyAll()
			//如果此时有多个等待线程，那么notify()表示的是唤醒第一个等待的线程，而其他的线程继续等待。
			//而notifyAll()表示会唤醒所有等待的线程，那个线程的优先级高就有可能先执行。
	
	//对于当前的问题主要的解决应该通过Message类完成处理。
	public Producer10(Message10 msg) {
		this.msg = msg;
	}
	
	@Override
	public void run() {
		for(int x = 0; x < 100; x++) {
			if(x % 2 == 0) {
				this.msg.set("张三", "宇宙大帅哥");
			}else {
				this.msg.set("小高", "猥琐第一人，常态保持");
			}
		}
	}
}

class Consumer10 implements Runnable{		//消费者

	private Message10 msg;
	
	public Consumer10(Message10 msg) {
		this.msg = msg;
	}
	
	@Override
	public void run() {
		for(int x= 0; x < 100; x++) {
			System.out.println(this.msg.get());
		}
	}
	
}

class Message10{
	
	//在进行同步处理的时候肯定需要有一个同步的处理对象，那么此时肯定要将同步操作交由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 == false) { //无法进行生产，应该等待被消费
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		this.title = title;
		this.content = content;
		
		this.flag = false;   //生产完成
		super.notify();		//唤醒等待的线程
	}
	
	public synchronized String get() {
		if(this.flag == true) {		//还未生产，需要等待
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		try {
			return this.title + " - " + this.content;
		}finally {		//不管如何都需要执行
			this.flag = true; //继续生产
			super.notify();   //唤醒等待线程
		}
		
	}
	//这种处理形式就是在进行多线程开发过程中最原始的处理方案，整个的等待、同步、唤醒机制都由开发者自行通过原生代码实现控制
}
public class TheradDemo10 {
	public static void main(String[] args) {
		Message10 msg = new Message10();
		new Thread(new Producer10(msg)).start();			//启动生产者线程
		new Thread(new Consumer10(msg)).start();			//启动消费者线程
	}
	// 通过整个代码的执行你会发现此时有两个主要问题
		//问题一：数据不同步了；
		//问题二：生产一个取走一个，但是发现有重复生产和重复取出的问题。
	
	//此时发现数据已经可以正常的保持一致了，但是对于重复操作的问题依然存在。
}

//这种处理形式就是在进行多线程开发过程中最原始的处理方案，整个的等待、同步、唤醒机制都由开发者自行通过原生代码实现控制