import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest {

     /**

      * @param args

      */

     

     private int j;

     private Lock lock = new ReentrantLock();

     public static void main(String[] args) {

          // TODO Auto-generated method stub

          ThreadTest tt = new ThreadTest();

          for(int i=0;i<2;i++)

          {

              new Thread(tt.new Adder()).start();

              new Thread(tt.new Subtractor()).start();

          }

     }

     private class Subtractor implements Runnable

     {

          @Override

          public void run() {

              // TODO Auto-generated method stub

              while(true)

              {

                   /*synchronized (ThreadTest.this) {              

                        System.out.println("j--=" + j--);

                        //这里抛异常了，锁能释放吗？

                   }*/

                   lock.lock();

                   try

                   {

                        System.out.println("j--=" + j--);

                   }finally

                   {

                        lock.unlock();

                   }

              }

          }

         

     }

     

     private class Adder implements Runnable

     {

          @Override

          public void run() {

              // TODO Auto-generated method stub

              while(true)

              {

                   /*synchronized (ThreadTest.this) {

                   System.out.println("j++=" + j++);

                   }*/

                   lock.lock();

                   try

                   {

                        System.out.println("j++=" + j++);

                   }finally

                   {

                        lock.unlock();

                   }                  

              }            

          }

         

     }

}

看了毕老师的视频，Lock锁比synchronized 锁更方便准确，但是对于Lock替换synchronized 还是有点不解，请哪位帮我仔细讲解一下，谢谢

老师在讲synchronized时也一直说锁，但那个隐式的，你看不到，而Lock其实就是把锁显式，你可以看到。另外那个 lock.unlock();要放在finally里就是说一定要执行，也是为了防止如果你放在执行代码下面的话，如果执行过程抛出异常功能结束后，就执行不到lock.unlock();但线程依然持有锁不放，那别的线程就进不来，所以lock.unlock();是必须要执行的，释放资源也就是锁

  
public void run() {//这个地方应该抛出一个InterruptedException，应该改为public void run() throws InterruptedException
              // TODO Auto-generated method stub
              while(true)
              {
                   /*synchronized (ThreadTest.this) {              
                        System.out.println("j--=" + j--);
                        //这里抛异常了，锁能释放吗？使用synchronized()进行同步时，当synchronized()的代码执行完锁就会自动释放了
                   }*/
                   lock.lock();
                   try//把需要检查异常的代码放在这里面
                   {
                        System.out.println("j--=" + j--);
                   }finally
                   {
                        lock.unlock();//释放锁一定要执行，要不会留下安全隐患，因此放在这里
                   }//上面的代码从 lock.lock();到 lock.unlock();，相当于
                  synchronized (ThreadTest.this) {              
                        System.out.println("j--=" + j--);  
                   }
              }
          }
         
     }
     使用lock来代替synchronized可以自行控制锁释放的时间，lock 必须在 finally 块中释放，否则，如果受保护的代码将抛出异常，锁就有可能永远得不到释放；而使用synchronized同步时，锁就会自动释放。但是synchronized同步时无法中断一个正在等候获得锁的线程。