我所理解的多线程之Lock

Lock的作用和synchronized非常相似，不同之处在于Lock对锁进行了细化，能够更细致地对代码进行加锁。下面通过生产者消费者模型来对Lock的用法进行说明。
           

机器类Mathine

public class Mathine {
    private Lock lock;
    private Condition empty;//槽位已满
    private Condition full;//槽位已空
    private static final int THRESHOLD=;//最大容量
    private int now;
    public Mathine(){
        lock=new ReentrantLock();
        empty=lock.newCondition();
        full=lock.newCondition();
    }
    public void produce() throws InterruptedException{
        try{
            lock.lock();
            if(now>=THRESHOLD){
                System.out.println("满了,等待");
                full.await();//满了，等待中（直到full.signal()通知）
            }else{
                now++;
                empty.signal();//有值了，通知empty
            }
            System.out.println("生产"+now);
        }finally{
            lock.unlock();//确保成功释放锁
        }
    }

    public void consume() throws InterruptedException{
        try{
            lock.lock();
            if(now<=){
                System.out.println("空了,等待");
                empty.await();//空了，等待中（直到empty.signal()通知）
            }else{
                now--;
                full.signal();//有值了，通知full
            }
            System.out.println("消费"+now);
        }finally{
            lock.unlock();//确保成功释放锁
        }
    }
} 
           

测试类Test

public class Test { 
      public static void main(String[] args) throws InterruptedException { 
            Mathine m=new Mathine(); 
            Thread a=new Thread(new Runnable(){ 
                  public void run(){ 
                        int i=; 
                        while(i-->){ 
                              try { 
                                    m.produce(); 
                              } catch (InterruptedException e) { 
                                    e.printStackTrace(); 
                              } 
                        } 
                  } 
            }); 
            Thread b=new Thread(new Runnable(){ 
                  public void run(){ 
                        int i=; 
                        while(i-->){ 
                              try { 
                                    m.consume(); 
                              } catch (InterruptedException e) { 
                                    e.printStackTrace(); 
                              } 
                        } 
                  } 
            }); 

            a.start(); 
            b.start(); 
      } 
} 
           

以下是输出结果

空了,等待
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
生产2
生产3
生产4
生产5
生产6
生产7
生产8
生产9
生产10
满了,等待
消费10
消费9
消费8
消费7
消费6
消费5
消费4
消费3
消费2
消费1
消费0
空了,等待
生产0
生产1
消费1