------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------

  多线程可以让我们同时共享一个资源,但如果在共享这个资源时需要彼此之间的联系怎么做呢?

经典实例:生产者与消费者。

问题描述,生产者每生产一个消费者就要取走一个,同时进行。

首先java为我们提供了一套等待唤醒机制,让线程与线程之间产生了联系。线程是分五个状态的:创建;运行;阻塞;冻结;消亡。java提供了几个针对状态的方法

wait()方法让线程进入冻结状态,让出cpu,让出锁;

notify()方法唤醒进入冻结状态的线程,notifyAll()是唤醒所有的线程。

针对问题,我们可以对生产者设定一个开关,如果资源为0就允许其生产并在生产完之后将开关关上,不会在有生产者生产并唤醒其他线程也就是消费者线程,当然在这之上同样要用到同步,为了保证第一个生产者进去之时,其他生产者会被拒之门外,对于消费者同理。

public static void main(String[] args) {
		// 
		tongbu i=new tongbu();//创建抽取出来的同步方法对象
		hjw j=new hjw(i);//创建实现Runnable接口的对象
		bb k=new bb(i);
		Thread xc1 =new Thread(j);//创建线程
		Thread xc2 =new Thread(k);
		xc1.setName("生产者");
		xc2.setName("消费者");
		xc1.start();
		xc2.start();
	}

}
class tongbu{//将两个同步方法抽取出来
	private String name;
	private int count=1;
	boolean flag=false;//定义一个bool类型来作用等待唤醒机制
	public synchronized void set(String name){//生产者的同步函数
		if(flag){//已存在就睡眠
			try{
				wait();
			}
				
			catch(Exception e){}
			}
		//否则 运作代码
		this.name=name+"---"+count++;
		System.out.println(Thread.currentThread().getName()+this.name);
		flag=true;//改变bool值
		this.notify();//唤醒线程
	}

	public synchronized void get(){
		if(!flag){//进入休眠
			try{
				wait();
			}
				
			catch(Exception e){}
			}
		//被生产者唤醒
		System.out.println(Thread.currentThread().getName()+"---"+this.name);
		flag=false;
		this.notify();//唤醒线程
	}
}
class hjw implements Runnable{
	private tongbu x ;
	hjw(tongbu x){//传回tongbu对象
		this.x=x;
	}
	public void run(){//重写run方法
		
		while(true){
		x.set("饼干");
		}
	}
}
class bb implements Runnable{
	private tongbu x ;
	bb(tongbu x){//传回tongbu对象
		this.x=x;
	}
	public void run(){//重写run方法
		
		while(true){
		x.get();
		}
	}
}

  这只是对于生产者和消费者只有一个线程,如果这边都有多个线程呢?绝不是多创建几个线程那么简单,因为要notify方法是唤醒最先休眠的那个线程,也就是说转到后面会出,生产一个,消费两次,生产多个只消费其中一个。

那么如何避免呢?采用while循环替代if循环,每当线程解冻之后,重新开始循环而非接着向下执行,这样就避免了多次执行,但问题是依据notify()的特性还是会让所有线程都陷入等待,我需要唤醒对方线程,所有这个时候就要用到notifyAll()了,唤醒所有线程。

public static void main(String[] args) {
		// 
		tongbu i=new tongbu();//创建抽取出来的同步方法对象
		hjw j=new hjw(i);//创建实现Runnable接口的对象
		bb k=new bb(i);
		Thread xc1 =new Thread(j);//创建线程
		Thread xc2 =new Thread(k);
		xc1.setName("生产者");
		xc2.setName("消费者");
		xc1.start();
		xc2.start();
	}

}
class tongbu{//将两个同步方法抽取出来
	private String name;
	private int count=1;
	boolean flag=false;//定义一个bool类型来作用等待唤醒机制
	public synchronized void set(String name){//生产者的同步函数
		while(flag){//已存在就睡眠
			try{
				wait();
			}
				
			catch(Exception e){}
			}
		//否则 运作代码
		this.name=name+"---"+count++;
		System.out.println(Thread.currentThread().getName()+this.name);
		flag=true;//改变bool值
		this.notifyAll();//唤醒线程
	}

	public synchronized void get(){
		while(!flag){//进入休眠
			try{
				wait();
			}
				
			catch(Exception e){}
			}
		//被生产者唤醒
		System.out.println(Thread.currentThread().getName()+"---"+this.name);
		flag=false;
		this.notifyAll();//唤醒线程
	}
}
class hjw implements Runnable{
	private tongbu x ;
	hjw(tongbu x){//传回tongbu对象
		this.x=x;
	}
	public void run(){//重写run方法
		
		while(true){
		x.set("饼干");
		}
	}
}
class bb implements Runnable{
	private tongbu x ;
	bb(tongbu x){//传回tongbu对象
		this.x=x;
	}
	public void run(){//重写run方法
		
		while(true){
		x.get();
		}
	}
}

  事实上,java5.0版本提供更完善的解决方案,针对如何唤醒指定线程。在java.lang.util.concurrent.locks中,提供了方法将锁显示化用以取代同步synchronized,lock()开锁,unlock()关锁,关锁这一特点犹如关闭资源就是无论怎样都要执行,因为前面有异常需要处理,所以关锁这一操作放在了finally{}中;而对于Object中wait()方法和notify(),notifyAll()方法分别用condition的await(),signal()和signalAll()取代,在lock中有一个new condition的方法,所以可以通过创建多个condition类,实现对指定线程的操作。