java多线程-消费者和生产者模式

/*
* 多线程-消费者和生产者模式
* 在实现消费者生产者模式的时候必须要具备两个前提，一是，必须访问的是一个共享资源，二是必须要有线程锁，且锁的是同一个对象
* */

 /*资源类中定义了name（名字）：用来区分消费者还是生产者
  *         定义了flag标记：用来区分有没有货物（默认生产一个就要消费一个）
  *         定义了count（生产的个数统计）
  *     set方法：用来生产商品
  *     out方法：用来消费商品*/
 class TestSource{
     private String name=null;
     private boolean flag=false;
     private int count=0;
     /*先通过flag标记判断有没有商品，有商品则等待，没有则生产商品，唤醒所有程序，并将flag标记改变*/
     public synchronized void set(String name){
         //判断是否有产品，这里用while循环，避免在多个生产者同时生产时，会出现生产多个产品，却只消费一个
         while(flag){
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         //生产产品并输出
         this.name=name+"编号"+count++;
         System.out.println("生产"+name+"++");
         //改变标记
         flag=true;
         //唤醒所有的线程
         notifyAll();
     }
     public synchronized void out(){
         while(!flag){
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println("消费"+name+"---");
         flag=false;
         notifyAll();
     }
 }
 class Product implements Runnable{
     private TestSource ts=null;
     //初始化线程里用到的资源
     public Product(TestSource ts){
         this.ts=ts;
     }
     //重写线程里run方法
     public void run() {
         while(true){
             ts.set("生产产品");
         }
     }
 }
 class Customer implements Runnable{
     private TestSource ts=null;
     public Customer(TestSource ts){
         this.ts=ts;
     }
     public void run() {
         while(true){
             ts.out();
         }
     }
 }
 public class test {
     public static void main(String[] args) {
         //初始化唯一的资源
         TestSource ts=new TestSource();
         //创建生产者和消费者两个对象，并传入两者共同操作的唯一资源
         Customer cu=new Customer(ts);
         Product pr=new Product(ts);
         //将对象传入线程对象
         Thread t1=new Thread(cu);
         Thread t2=new Thread(pr);
         Thread t3=new Thread(cu);
         Thread t4=new Thread(pr);
         //开启线程
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 }

/*在java1.5版本以后，用lock和unlick代替了synchronized关键字
* 用await()代替了wait()方法
* 用signal()代替了notify()
* 这里的signal可以指定唤醒莫一类的线程，而不是像notifyAll,必须全部唤醒

这里我们对上面的代码进行一定的改写*/

 class TestSource{
     private String name=null;
     private boolean flag=false;
     private int count=0;
     //定义lock,用来代替synchronized关键字
     private Lock lock=new ReentrantLock();
     private Condition condition_pro=lock.newCondition();
     private Condition condition_con=lock.newCondition();
     public void set(String name){
         //对代码段进行上锁
         lock.lock();
         try {
             while(flag){
                 try {
                     //wait();
                     //调用生产者控制方法
                     condition_pro.await();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             this.name=name+"编号"+count++;
             System.out.println("生产"+name+"++");
             flag=true;
             //notifyAll();
             //唤醒消费者线程
             condition_con.signal();
         } finally{
             //解锁，让其他进程进入访问
             lock.unlock();
         }

     }
     public void out(){
         lock.lock();
         try{
             while(!flag){
                 try {
                     //wait();
                     condition_con.await();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             System.out.println("消费"+name+"---");
             flag=false;
             //notifyAll();
             condition_pro.signal();
         }finally{
             lock.unlock();
         }

     }
 }