在线程同步中，在一个线程的finally语句块中用lock.unlock()手工释放锁，该锁就一定能释放吗？？还是说仍然可能没有释放，继续占有呢？如果真是一定释放的话，下面这段程序运行结果却不能证明这个说法。
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();
                }               
            }            
        }
        
    }
}

finally里面的代码是一定会执行的

finally里面的代码作用是释放资源的，锁就是一个他们的关键资源，是必须会执行的，只有一种不会执行那就是在此语句之前有System.exit(0);所以此锁一定会释放的。

finally里面的代码很重要，它是用来释放资源的，无论是否出现异常，它都要必须运行
毕竟资源是很重要的