多线程（三）--多线程间通信

一.线程间通信

1.生产者与消费者问题

//多线程经典，卖烤鸭程序--生产者与消费者
//定义一个资源类Resource
class Resource{
	private String name;
	private int count = 1;
	//set()方法给生产者调用
	public void set(String name){
		this.name = name + count;
		//调用set()方法count自增
		count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		
	}
	//out()方法给消费者调用
	public void out(){
		System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
		
	}
}

class Producer implements Runnable{
	private Resource r;
	Producer(Resource r){
		this.r = r;
	}
	public void run(){
		//设置生产者不停地生产
		while(true){
			r.set("烤鸭");
		}
	}
}

class Consumer implements Runnable{
	private Resource r;
	Consumer(Resource r){
		this.r = r;
	}
	public void run(){
		//设置消费者不停地消费
		while(true){
			r.out();
		}
	}
}

class  ProducerConsumerDemo{
	public static void main(String[] args) {
		Resource r = new Resource();
		//创建一个生产者和一个消费者
		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);
		//分别将其加入到两个线程中
		Thread t0 = new Thread(pro);
		Thread t1 = new Thread(con);
		t0.start();
		t1.start();

	}
}


           

运行结果：

问题：消费者消费了生产者没有生产的资源

分析：set( )方法内操作了共享数据count，而且有多条操作语句，出现了多线程安全问题，消费者的线程可能抢在生产者前打印数据（如图烤鸭1638）

解决：使用同步函数解决多线程安全问题

只需更改Resource类，将set( )函数和out( )函数加上synchronized关键字

class Resource{
	private String name;
	private int count = 1;
	
	public synchronized voidset(String name){
		this.name = name + count;
		count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		
	}
	
	public void synchronized out(){
		System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
		
	}
}
           

运行结果：

问题：消费者只能消费最近一次生产的资源

原因：两个方法使用了同一个锁，同一时间只能有一个方法执行，而set( )方法执行时count不断自增，out( )方法执行时count值则一直不变

显然仅仅加一个锁是不能达到我们的预期的，这时就要考虑其他解决办法。即线程间通信

2.线程间通信的概念

多个线程在操作同一个资源，但是操作的动作却不一样

实现方式：

1：将资源封装成对象

2：将线程执行的任务(任务其实就是run方法。)也封装成对象

3.等待唤醒机制：

涉及到的方法：

wait( )

将同步中的线程处于冻结状态，释放了执行权和执行资格，同时将线程对象存储到线程池中

notify( )

唤醒线程池中某一个等待线程

notifyAll( )

唤醒线程池中的所有线程

使用前提：

1，这些方法都需要定义在同步中，不使用同步则这些方法没有意义

2，这些方法必须要标示所属的锁。

A锁上的线程被wait了,那这个线程就会被冻结然后保存到A锁的线程池中，只能A锁的notify唤醒

这三个方法都定义在Object类中，因为这三个方法在使用过程中必须要标识所属的锁对象，而锁对象可以是任意对象，所以这些可以被任意对象调用的方法一定定义在Object类中

//使用等待唤醒机制解决生产者和消费者问题
class Resource{
	private String name;
	private int count = 1;
	private boolean flag = false;
	public synchronized void set(String name){
		//如果flag=true，则生产者进入等待状态
		while(flag)
			try{this.wait();}catch(InterruptedException e){}
		this.name = name + count;
		count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		flag = true;
		//执行完后唤醒消费者
		this.notify();
		
	}
	public synchronized void out(){
		//如果flag=false，则消费者进入等待状态
		while(!flag)
			try{this.wait();}catch(InterruptedException e){}
		System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
		flag = false;
		//执行完后唤醒生产者
		this.notify();
	}
}

class Producer implements Runnable{
	private Resource r;
	Producer(Resource r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.set("烤鸭");
		}
	}
}

class Consumer implements Runnable{
	private Resource r;
	Consumer(Resource r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.out();
		}
	}
}

class  ProducerConsumerDemo{
	public static void main(String[] args){
		Resource r = new Resource();
		
		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);
		
		Thread t0 = new Thread(pro);
		Thread t1 = new Thread(con);
		t0.start();
		t1.start();

	}
}

           

执行结果

wait和sleep区别：

1.唤醒方式不同

wait：可以指定时间也可以不指定时间，不指定时间则只能由对应的notify或者notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

2.线程持有的锁的释放

wait：线程会释放执行权，而且线程会释放锁。

Sleep：线程会释放执行权，但是不释放锁。

4.多生产多消费

public class ProducerConsumerDemo {


    public static void main(String[] args){
        Resource r = new Resource();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
		//分别定义两个生产者和两个消费者
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();

    }
}
           

定义多个生产者和消费者

运行结果：

现象：程序停止不动，不在继续向下执行，但是却不是死锁，因为程序中没有同步的嵌套

分析：set( )和get( )方法中唤醒线程使用的是notify( )方法，只能唤醒一个线程。所以可能出现一个生产者线程唤醒了另一个生产者线程，而flag值是true，被唤醒的这个生产者线程经过while判断后也进入了wait等待状态，然后程序中就没有可以执行的线程了，程序停止。

解决：使用notifyAll( )方法，将所有线程都唤醒

class Resource{
	private String name;
	private int count = 1;
	private boolean flag = false;
	public synchronized void set(String name){
		while(flag)
			try{this.wait();}catch(InterruptedException e){}
		this.name = name + count;
		count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		flag = true;
		//只需将notify更改为notifyAll
		this.notifyAll();
		
	}
	public synchronized void out(){
		while(!flag)
			try{this.wait();}catch(InterruptedException e){}
		System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
		flag = false;
		this.notifyAll();
	}
}
           

二.线程的停止

1.使用stop方法（已过时）

2.结束run( )方法

run方法里一般会定义循环，所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

三.Lock接口和Condition接口

解决线程安全问题使用同步的形式(同步代码块和同步函数)，其实最终使用的都是锁机制。线程进入同步就是具备了锁，执行完毕离开同步，就是释放了锁。获取锁，释放锁的动作是锁对象的内容。在面向对象思想的指导下，将锁单独定义为对象并封装对锁的操作。Java的设计者专门开发了一个Lock接口，将获取锁，释放锁等操作都定义到了这个接口中

同步是隐示的锁操作，而Lock接口是显示的锁操作，Lock接口的出现就替代了同步。

在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了Condition接口中。

Condition接口将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await( )、signal( )、signalAll( )

使用Lock接口实现多生产多消费

import java.util.concurrent.locks.*;

class Resource{
	private String name;
	private int count = 1;
	private boolean flag = false;
	//创建一个Lock接口的实现类ReentrantLock的对象
	Lock lock = new ReentrantLock();
	//通过lock锁创建两个监听器，分别监听生产者和消费者
	Condition producer_con = lock.newCondition();
	Condition consumer_con = lock.newCondition();

	public void set(String name){
		//获取锁（相当于加同步）
		lock.lock();
		try{
			while(flag)
			//监听器调用await()方法使线程进入等待状态
			try{producer_con.await();}catch(InterruptedException e){}
			this.name = name + count;
			count++;
			System.out.println(Thread.currentThread().getName()+"...生产者5.0..."+this.name);
			flag = true;
			//唤醒消费者的线程
			consumer_con.signal();
		}
		finally{
			//操作执行完毕，释放锁
			lock.unlock();
		}
		
	}

	public void out(){
		lock.lock();
		try{
			while(!flag)
			try{cousumer_con.await();}catch(InterruptedException e){}	
			System.out.println(Thread.currentThread().getName()+"...消费者.5.0......."+this.name);
			flag = false;
			producer_con.signal();
		}
		finally{
			lock.unlock();
		}
		
	}
}

class Producer implements Runnable{
	private Resource r;
	Producer(Resource r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.set("烤鸭");
		}
	}
}

class Consumer implements Runnable{
	private Resource r;
	Consumer(Resource r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.out();
		}
	}
}



class  ProducerConsumerDemo2{
	public static void main(String[] args) {
		Resource r = new Resource();
		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t0 = new Thread(pro);
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(con);
		Thread t3 = new Thread(con);
		t0.start();
		t1.start();
		t2.start();
		t3.start();

	}
}