黑马程序员之java多线程3

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		
		Producer pro=new Producer(r);
		
		Consumer con=new Consumer(r);
		
		Thread t1=new Thread(pro);
		Thread t2=new Thread(pro);
		Thread t3=new Thread(con);
		Thread t4=new Thread(con);
		t1.start(); 
		t2.start();
		t3.start();
		t4.start();
	}
}



class Resource
{
	private String name;
	private int count=1;
	private boolean flag=false;
	
	private Lock lock=new ReentrantLock();
	

	private Condition condition_pro=lock.newCondition();
	private Condition condition_con=lock.newCondition();
	
	public void  set(String name) throws InterruptedException
	{
		lock.lock();
		
		try
		{
		    while(flag)
		  
		    condition_pro.await();
		  
				this.name=name+"--"+count++;
				
				System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
				flag=true;
				condition_con.signal();
		}
		finally
		{
			lock.unlock();
		}
		
		
		
			
	}	
	
	public void out() throws InterruptedException
	{
		
		lock.lock();
		try
		{
			while(!flag)
					condition_con.await();
		   
		  System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
		  flag=false;
		  condition_pro.signal();
		}
		finally
		{
			lock.unlock();	
		}
		
		
		
		
	}
}


class Producer implements Runnable
{
	private Resource res;
	
	Producer(Resource res)
	{
		this.res=res;	
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch(InterruptedException e)
			{
					
			}
		}
  }
	
}


class Consumer implements Runnable
{
	 private Resource res;
	 
	 Consumer(Resource res)
	 {
	 	this.res=res;	
	 }
	 public void run()
	 {
	 	while(true)
	  {
	  	try
			{
				res.out();
			}
			catch(InterruptedException e)
			{
			  
			}
	  }
	 }
}

Lock接口：
解决线程安全问题使用的是同步形式，同步代码块和同步函数，其实最终使用的都是锁机制。


到了后期版本，直接将锁封装成了对象。线程进入同步就具备了锁，执行完，离开同步，就是释放了锁。在后期对锁的分析过程中，发现，获取锁，或者释放
锁的动作应该是锁这个事物更清楚。所以讲这些动作定义在了锁当中，并把锁定义成对象。


所以同步是隐式的锁操作，而Lock是显示的锁操作。它的出现就替代了同步。


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


而现在锁是指定对象lock。所以查找等待唤醒机制方式需要通过lock接口来完成。而lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到
了一个对象中。这个对象就是Condition，将Object类中的三个方法进行单独的封装。并提供了功能一致的方法await()、signal()、signalAll()。

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------