多线程经典——生产者消费者问题（加锁版）

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
* 生产者，消费者
* Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式锁操作变成现实锁操作，
*        同时更加灵活，可以一个锁上加多组监视器。
*        lock()获取锁
*        unlock()释放锁，通常定义在finally代码块中
* Condition接口：出现替代了Object中的wait notify notifyAll方法
*        将这些监视器方法单独进行了封装，变成Condition监视器对象。可以任意锁进行组合
*      await() signal() signalAll()
*
* */

class Resrouce
{
private String name;
private int count=1;
private boolean flag=false;
//创建一个锁对象
Lock lock=new ReentrantLock();
//通过已有的锁获取该锁上的监视器对象
//  Condition con=lock.newCondition();
//通过已有的梭获取两组监视器，一组监视生产者，一组监视消费者
Condition producer_con=lock.newCondition();
Condition consumer_con=lock.newCondition();
public void set(String name)

{
lock.lock();
try
{
while(flag)
try{producer_con.await();}
catch(InterruptedException e)
{}
this.name=name+count;
count++;
System.out.println(Thread.currentThread().getName()+"..生产者."+this.name);
flag=true;
consumer_con.signal();
}
finally
{
lock.unlock();
}

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

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

public class Demo
{

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

}