java 多线程的同步与通信

java 多线程的同步与通信，典型应用生产者与消费者模型

当我们使用生产者消费者来进行操作同一资源时

class Resource{
	private int count;
	private String name;
	public void set(String name) {
		this.name = name;
		System.out.println(Thread.currentThread().getName()+"	生产者	"+name);
	}
	public void out()
	{
		System.out.println(Thread.currentThread().getName()+"	生产者	"+name);
	}
}
class Producer implements Runnable{
	Resource resource;
	public Producer(Resource resource) {
		this.resource = resource;
	}
	public void run(){
		while(true)
		{
			resource.set("面包");
		}
	}
}
class Consumer implements Runnable{
	Resource resource;
	public Consumer(Resource resoure)
	{
		this.resource = resource;
	}
	public void run() {
		while(true) {
		resource.out();
		}
	}
}
public class TestDemo {

	public static void main(String[] args) {
		Resource r = new Resource();
		Producer p1 = new Producer(r);
		Consumer c1 = new Consumer(r);
		//创建线程任务
		Thread t1 = new Thread(p1);
		Thread t2 = new Thread(c1);
		//开启多线程
		t1.start();
		t2.start();
	}
}

该方式会出现以下情况

Thread-0	生产者	面包 20207
Thread-0	生产者	面包 20208
Thread-0	生产者	面包 20209
Thread-0	生产者	面包 20210
Thread-0	生产者	面包 20211
Thread-0	生产者	面包 20212
Thread-0	生产者	面包 20213
Thread-0	生产者	面包 20214
Thread-1	消费者	面包 20207
Thread-1	消费者	面包 20215
Thread-1	消费者	面包 20215
Thread-1	消费者	面包 20215
Thread-1	消费者	面包 20215
Thread-1	消费者	面包 20215

说明不同步，生产运行结果数据错误，已经被生产的商品才被消费到，因为，例如当线程由生产者占用时生产了面包1，切换到消费者线程，消费者线程还没来得及输出就切回生产者线程，生产完面包2 3之后，消费者线程从刚刚断开地方执行，消费面包1，出现线程安全问题，加入同步来解决，使用同步函数

线程安全问题

• 1多个线程在操作共享数据
• 2线程任务操作共享数据的代码有多条（运算有多个）

使用同步代码块或同步函数来进行同步时，会使得当一个线程1执行该同步代码块或者同步函数时，拿到锁，若该线程未将同步代码块或同步函数执行完，就切换到另一线程2，则线程2不会执行，因为没有锁。当线程1执行完会释放锁，线程2 拿到锁，然后执行。

class Resource{
	private int count;
	private String name;
	public synchronized void set(String name) {
		this.name = name+" "+count;
		count++;
		System.out.println(Thread.currentThread().getName()+"	生产者	"+this.name);
		
	}
	public synchronized void out()
	{
		System.out.println(Thread.currentThread().getName()+"	消费者	"+this.name);
	}
}
class Producer implements Runnable{
	Resource resource;
	public Producer(Resource resource) {
		this.resource = resource;
	}
	public void run(){
		while(true)
		{
			resource.set("面包");
		}
	}
}
class Consumer implements Runnable{
	Resource resource;
	public Consumer(Resource resource)
	{
		this.resource = resource;
	}
	public void run() {
		while(true) {
		resource.out();
		}
	}
}
public class TestDemo {

	public static void main(String[] args) {
		Resource r = new Resource();
		Producer p1 = new Producer(r);
		Consumer c1 = new Consumer(r);
		//创建线程任务
		Thread t1 = new Thread(p1);
		Thread t2 = new Thread(c1);
		//开启多线程
		t1.start();
		t2.start();
	}
}

发现问题已解决，不会再消费到之前很早期的商品，但是还是会出现连续生产却没有被消费，一个商品被消费多次的情况。

Thread-0	生产者	面包 91301
Thread-0	生产者	面包 91302
Thread-0	生产者	面包 91303
Thread-1	消费者	面包 91303
Thread-1	消费者	面包 91303
Thread-1	消费者	面包 91303
Thread-1	消费者	面包 91303
Thread-1	消费者	面包 91303
Thread-1	消费者	面包 91303

线程间的通信

我们的希望是生产者生产一个面包，消费者就消费掉一个面包，也就是说生产者生产了商品后，应该告诉消费者来消费，这是生产者应该处等待状态
消费者消费了商品后，就应该告诉生产者生产

等待唤醒机制

• wait();让线程处于等待状态，其实就让线程临时存储到了线程池中
• notify();会唤醒线程池中任意一个等待的线程
• notifyAll();唤醒线程池中所有的等待线程
• 记住这些方法必须使用再同步中，因为必须要标识wait notify 等方法所属的锁
• 同一个锁上的notify，只能唤醒该锁上的被wait的线程

class Resoure1
{
	private boolean flag = false;//false的时候标志为空，true的时候标识为非空
	private String name;
	private int count;
	public synchronized void  set(String name)
	{	
		while(flag)
		{ 
			try{wait();}catch(Exception e) {}
		}
		//给成员变量赋值并加上编号
		this.name= name+count;
		count++;
		System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);
		flag = true;
		notify();
	}
	public synchronized void out()
	{

		while(!flag)
		{
			try{wait();}catch(Exception e) {}
		}
		System.out.println(Thread.currentThread().getName()+"..消费者.."+this.name);
		flag = false;
		notify();		
	}
}
//2.描述生产者，具备着自己的任务
class Producer1 implements Runnable
{
	private Resoure1 r;
	public Producer1(Resoure1 r) {
		this.r = r;
	}
	@Override
	public void run() {
		while(true)
		{
			r.set("面包");
		}
		
	}
	
}
//3.描述消费者，具备着自己的任务
class Consumer1 implements Runnable
{
	private Resoure1 r;
	public Consumer1(Resoure1 r) {
		this.r = r;
	}
	@Override
	public void run() {
		while(true)
		{
			r.out();
		}
		
	}
	
}
public class TestDemo4 {

	public static void main(String[] args) {
	
		Resoure1 resoure = new Resoure1();
		
		//创建线程任务
		Producer1 p1 = new Producer1(resoure);
		Consumer1 c1 = new Consumer1(resoure)；
		//创建线程
		Thread t1 =new Thread(p1);
		Thread t2 =new Thread(c1);
		
		//开启线程
		t1.start();
		t2.start();