Lock和synchronized 都可以实现同步，但是Lock比synchronized 有什么优点呢？在代码中怎么体现出来？有地方说Lock是以非阻塞方式去拿锁，这个怎么体现出来的呢？

1. class Subtractor implements Runnable{
   
2. 
   
3.         private Lock lock =new ReentrantLock();
   
4.         
   
5.         private int j=10000;
   
6.         
   
7.         public void run() {
   
8.                
   
9.                  while(true)
   
10.          {
    
11.             lock.lock();
    
12.             try
    
13.             {
    
14.                 System.out.println("j--=" + j--);
    
15.                  if(j<0){
    
16.                     break;
    
17.                 }
    
18.             }finally
    
19.             {        
    
20.                 lock.unlock();
    
21.             }
    
22.          }
    
23.      }
    
24. }
    
25. 
    
26. class Subtractor2 implements Runnable{
    
27.         
    
28.         private int j=10000;
    
29.         
    
30.         public void run() {
    
31.                
    
32.                 while(true)
    
33.                 {
    
34.                                     synchronized (this) {      
    
35.                 System.out.println("j--="+ j--); //这里抛异常了，锁能释放吗？
    
36.                  if(j<0){
    
37.                   break;
    
38.                 }
    
39.             }
    
40.                 }
    
41.         }
    
42. }

复制代码

API上讲的比较复杂，但是毕老师视频中讲的最大区别我觉得就是线程通信时的差别
使用synchronized 关键字时，等待（wait）和唤醒（notify）使用的是继承自Object的方法
唤醒对象时，不能明确的指出该唤醒哪个对象，如消费者和生产者的例子，消费者等待时，要唤醒生产者
而lock可以生产不同的condition对象，

1. final Condition notFull  = lock.newCondition();
   
2.    final Condition notEmpty = lock.newCondition();
   
3. 
   
4.    public void put(Object x) throws InterruptedException {
   
5.      lock.lock();
   
6.      try {
   
7.        while (count == items.length)
   
8.          notFull.await();//本方线程等待
   
9.        items[putptr] = x;
   
10.        if (++putptr == items.length) putptr = 0;
    
11.        ++count;
    
12.        notEmpty.signal();//唤醒对方线程
    
13.      } finally {
    
14.        lock.unlock();
    
15.      }
    
16.    }
    

复制代码