线程中消费者生产者的实例代码(使用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();
        }
    }
}