Java学习之线程通信（多线程（Lock））--生产者消费者

SDK1.5版本以后对synchronized的升级，其思想是：将同步和锁封装成对象，其对象中包含操作锁的动作。

代码：

 //1、导入包
 import java.util.concurrent.locks.*;
 class Resource
 {
     private String name;
     private int count=1;
     private boolean flag=false;

     //创建互斥锁（相当于synchronized）
     Lock lock = new ReentrantLock();
     //创建锁对象（相当于Object对象）
     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 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 p=new Producer(r);
         Consumer c=new Consumer(r);
         //实例化线程，指定线程任务
         Thread t0=new Thread(p);
         Thread t1=new Thread(p);
         Thread t2=new Thread(c);
         Thread t3=new Thread(c);
         //开启线程，执行线程任务中的run方法
         t0.start();
         t1.start();
         t2.start();
         t3.start();
     }
 }

结果：

lock就是对同步的封装那就有关系和区别：