线程中消费者生产者的实例代码(使用Lock类)

http://www.cnblogs.com/DreamDrive/p/6192685.html 这个是用synchronized关键字实现的.

Lock可以替换synchronized.

上面用来做为锁对象的SaleWindow.class没有别的操作,而且获取锁和释放锁都是在内部隐藏完成的.

Java的思想是万物皆对象,我们把这种锁也描述成为一个对象,就是Lock.....

Lock中的lock和unlock显式的打开和关闭(可视化)更直观.

Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作.

此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的Condition对象.

Lock可以替换synchronized.

使用synchronized

synchronized(SaleWindow.class) {

}

SaleWindow.class 这个锁对象没有别的操作,而且这个锁对象获取锁和释放锁的操作都是在内部隐藏的完成的,而Java的思想是万物皆对象.

我们把这种锁也描述成了一个对象,这个对象就是Lock.

Lock中获取锁和释放锁都提供了对应的方法,这两种操作都是一种显式的操作,更直观的表示了这个问题.

如果仅仅把之间的synchronized替换成Lock运行是会报错的.

原因就是锁替换了synchronized 但是wait只能在同步中调用.

我们应该把wait 和 notify 等待唤醒机制都替换掉.

上面说的Condition是将Object监视器方法(wait,notify和notifyAll)分解成截然不同的对象,以便通过这些对象与任意Lock实现组合使用,为每个对象提供多个等待...其中Lock替代了synchronized方法和语句的使用,Condition替代了Object监视器方法的使用.

Condition中有await()  signal()  和 signalAll().....

SaleWindow.java

 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 
 public class SaleWindow implements Runnable {
 
     private List<Food> foods;
 
     public List<Food> getFoods() {
         return foods;
     }
 
     public void setFoods(List<Food> foods) {
         this.foods = foods;
     }
 
     public SaleWindow(List<Food> foods) {
         this.foods = foods;
     }
 
     public SaleWindow() {
     }
 
     public void sale() {
         while (true) {
             // 加锁
             Lock lock = MyLock.LOCK;
             Condition cook_con =  MyLock.COOK_CON;
             Condition sale_con =  MyLock.SALE_CON;
             lock.lock();
             if (foods.size() > 0) {
                 try {
                     Food food = foods.get(0);
                     System.out.println(Thread.currentThread().getName()
                             + ": 卖出了 " + food.getId() + " 号饭...");
                     Random ran = new Random();
                     int i = ran.nextInt(300);
 
                     TimeUnit.MILLISECONDS.sleep(i);
                     foods.remove(0);
                     // SaleWindow.class.notify();//随机唤醒一条等待的线程
                     cook_con.signal();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             } else {
                 System.out.println(Thread.currentThread().getName()
                         + ":饭买完了。厨师赶紧做，我休息了。。。");
                 try {
                     sale_con.await();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
 
             }
             // 释放锁
             lock.unlock();
         }
     }
 
     @Override
     public void run() {
         sale();
     }
 
 }

Cook.java

 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 
 public class Cook implements Runnable {
 
     private List<Food> foods;
     private static int num = 1;
     private static final int MAXSIZE = 1;
 
     public List<Food> getFoods() {
         return foods;
     }
 
     public void setFoods(List<Food> foods) {
         this.foods = foods;
     }
 
     public Cook(List<Food> foods) {
         this.foods = foods;
     }
 
     public Cook() {
     }
 
     public void produce() {
         while (true) {
             Lock lock = MyLock.LOCK;
             Condition cook_con =  MyLock.COOK_CON;
             Condition sale_con =  MyLock.SALE_CON;
             lock.lock();
             if (foods.size() < MAXSIZE) {
                 Food food = new Food((num++) + "");
                 foods.add(food);
                 System.out.println(Thread.currentThread().getName() + " ：做好 "
                         + food.getId() + " 号饭了");
                 Random ran = new Random();
                 int i = ran.nextInt(300);
                 try {
                     TimeUnit.MILLISECONDS.sleep(i);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
 
                 // SaleWindow.class.notify();
 
                 sale_con.signal();//唤醒等待中的一条线程
             } else {
                 System.out.println(Thread.currentThread().getName()
                         + " :桌子放满了。窗口赶紧卖，我休息了。。。");
 
                 try {
                     cook_con.await();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             lock.unlock();
         }
 
     }
 
     @Override
     public void run() {
         produce();
     }
 }

Food.java

 public class Food {
 
     private String id;
 
     public Food(String id) {
         this.id = id;
     }
 
     public String getId() {
         return id;
     }
 
     public void setId(String id) {
         this.id = id;
     }
 
 }

MyLock.java

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
     //把锁抽取出来.
 public class MyLock {
 
     public static final Lock LOCK = new ReentrantLock(true);//公平模式
     public static final Condition COOK_CON = LOCK.newCondition();//监视Cook的监视器
     public static final Condition SALE_CON = LOCK.newCondition();//监视Sale的监视器
     //两个监视器之间可以相互通知 本方唤醒对方的等待中的一条线程.
 
     //构造方法私有 单例  饿汉式
     private MyLock(){}
 }

Test.java

 import java.util.ArrayList;
 import java.util.List;
 
 public class Test {
 
     public static void main(String[] args) {
 
         /*List<Food> foods = new ArrayList<Food>();
         for (int i = 0; i < 10; i++) {
             foods.add(new Food((i+1)+""));
         }
         Restaurant r = new Restaurant(foods);
         for (int i = 0; i < 3; i++) {
             new Thread(r).start();
         }*/
         List<Food> foods = new ArrayList<Food>();
         for (int i = 0; i < 4; i++) {
             new Thread(new Cook(foods),"Cook"+(i+1)).start();
         }
         for (int i = 0; i < 3; i++) {
             new Thread(new SaleWindow(foods),"sale"+(i+1)).start();
         }
     }
 }