public interface Lock {

 void lock() //获取锁。

 void lockInterruptibly() //如果当前线程未被中断，则获取锁。

 Condition newCondition() // 返回绑定到此 Lock 实例的新 Condition 实例。

 boolean tryLock()  //仅在调用时锁为空闲状态才获取该锁。

 boolean tryLock(long time, TimeUnit unit)  //如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。

 void unlock()  //释放锁。

 }

 Lock lock = ...;

 lock.lock();

 try{

     //处理任务

 }catch(Exception ex){

 }finally{

     lock.unlock();   //释放锁

 }

 Lock lock = ...;

 if(lock.tryLock()) {

      try{

          //处理任务

      }catch(Exception ex){

      }finally{

          lock.unlock();   //释放锁

      }

 }else {

     //如果不能获取锁，则直接做其他事情

 }

 public void method() throws InterruptedException {

     lock.lockInterruptibly();

     try {

      //.....

     }

     finally {

         lock.unlock();

     }

 }

 /**

  * lock() 的正确使用方法

  * @ClassName: Test

  * @author xingle

  * @date 2015-1-7 下午8:04:18

  */

 public class Test {

     private ArrayList<Integer> arrayList = new ArrayList<Integer>();

     public static void main(String[] args){

         final Test test = new Test();

         new Thread(){

             public void run(){

                 test.insert(Thread.currentThread());

             }

         }.start();

         new Thread(){

             public void run(){

                 test.insert(Thread.currentThread());

             }

         }.start();

     }

     public void insert(Thread currentThread) {

         Lock lock = new ReentrantLock(); //注意这个地方

         lock.lock();

         try{

             System.out.println(currentThread.getName()+"得到了锁");

             for(int i=0;i<5;i++) {

                 arrayList.add(i);

             }

         }catch(Exception ex){

         }finally{

             System.out.println(currentThread.getName()+"释放了锁");

             lock.unlock();

         }

     }

 }

 public class Test {

     private ArrayList<Integer> arrayList = new ArrayList<Integer>();

     Lock lock = new ReentrantLock(); //注意这个地方

     public static void main(String[] args){

         final Test test = new Test();

         new Thread(){

             public void run(){

                 test.insert(Thread.currentThread());

             }

         }.start();

         new Thread(){

             public void run(){

                 test.insert(Thread.currentThread());

             }

         }.start();

     }

     public void insert(Thread currentThread) {

         lock.lock();

         try{

             System.out.println(currentThread.getName()+"得到了锁");

             for(int i=0;i<5;i++) {

                 arrayList.add(i);

             }

         }catch(Exception ex){

         }finally{

             System.out.println(currentThread.getName()+"释放了锁");

             lock.unlock();

         }

     }

 }

 /**

  * tryLock()的使用

  * @ClassName: tryLock

  * @author xingle

  * @date 2015-1-7 下午8:29:35

  */

 public class tryLock {

     private ArrayList<Integer> arrayList = new ArrayList<Integer>();

     private Lock lock = new ReentrantLock();    //注意这个地方

     public static void main(String[] args)  {

         final tryLock test = new tryLock();

         new Thread(){

             public void run() {

                 test.insert(Thread.currentThread());

             };

         }.start();

         new Thread(){

             public void run() {

                 test.insert(Thread.currentThread());

             };

         }.start();

     }

     public void insert(Thread currentThread) {

         if(lock.tryLock()){

             try{

                 System.out.println(currentThread.getName()+"得到了锁");

                 for(int i=0;i<5;i++) {

                     arrayList.add(i);

                 }

             }catch(Exception ex){

                 // TODO: handle exception

             }finally{

                 System.out.println(currentThread.getName()+"释放了锁");

                 lock.unlock();

             }

         } else {

             System.out.println(currentThread.getName()+"获取锁失败");

         }

     }  

 }

 /**

  * lockInterruptibly()使用

  * @ClassName: lockInterruptiblyTest

  * @author xingle

  * @date 2015-1-7 下午8:39:30

  */

 public class lockInterruptiblyTest {

     private Lock lock = new ReentrantLock();

     public static void main(String[] args){

         lockInterruptiblyTest test = new lockInterruptiblyTest();

         MyThread thread1 = new MyThread(test);

         MyThread thread2 = new MyThread(test);

         thread1.start();

         thread2.start();

         try {

             Thread.sleep(200);

         } catch (InterruptedException e) {

             e.printStackTrace();

         }

         thread2.interrupt();

     }

     public void insert(Thread thread) throws InterruptedException

     {

         lock.lockInterruptibly();//注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出

         try{

             System.out.println(thread.getName()+"得到了锁");

             long startTime = System.currentTimeMillis();

             for(;;) {

                 if(System.currentTimeMillis() - startTime >= 20000)

                     break;

                 //插入数据

             }

         }finally{

             System.out.println(Thread.currentThread().getName()+"执行finally");

             lock.unlock();

             System.out.println(thread.getName()+"释放了锁");

         }

     }

 }

 class MyThread extends Thread{

     private lockInterruptiblyTest test = null;

     public MyThread(lockInterruptiblyTest test){

         this.test = test;

     }

     public void run(){

         try {

             test.insert(Thread.currentThread());

         } catch (InterruptedException e) {

             System.out.println(Thread.currentThread().getName()+"被中断");

         }

     }

 }

public interface ReadWriteLock {

    /**

     * Returns the lock used for reading.

     *

     * @return the lock used for reading.

     */

    Lock readLock();

    /**

     * Returns the lock used for writing.

     *

     * @return the lock used for writing.

     */

    Lock writeLock();

}

 public class test1 {

     public static void main(String[] args){

         final test1 test = new test1();

         new Thread(){

             public void run(){

                 test.get(Thread.currentThread());

             }

         }.start();

         new Thread(){

             public void run(){

                 test.get(Thread.currentThread());

             }

         }.start();

     }

     public synchronized  void get(Thread currentThread) {

         long start = System.currentTimeMillis();

         while(System.currentTimeMillis() - start <=1){

             System.out.println(currentThread.getName()+"正在进行读操作");

         }

         System.out.println(currentThread.getName()+"读操作完毕");

     }

 }

 public class test1 {

     private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

     public static void main(String[] args){

         final test1 test = new test1();

         new Thread(){

             public void run(){

                 test.get(Thread.currentThread());

             }

         }.start();

         new Thread(){

             public void run(){

                 test.get(Thread.currentThread());

             }

         }.start();

     }

     public void get(Thread currentThread) {

         rwl.readLock().lock();

         try{

             long start = System.currentTimeMillis();

             while(System.currentTimeMillis() - start <=1){

                 System.out.println(currentThread.getName()+"正在进行读操作");

             }

             System.out.println(currentThread.getName()+"读操作完毕");

         }finally {

             rwl.readLock().unlock();

         }

     }

 }

class MyClass {

    public synchronized void method1() {

        method2();

    }

    public synchronized void method2() {

    }

}

　　上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。

而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

 static final class NonfairSync extends Sync {

         private static final long serialVersionUID = 7316153563782823691L;

         /**

          * Performs lock.  Try immediate barge, backing up to normal

          * acquire on failure.

          */

         final void lock() {

             if (compareAndSetState(0, 1))

                 setExclusiveOwnerThread(Thread.currentThread());

             else

                 acquire(1);

         }

         protected final boolean tryAcquire(int acquires) {

             return nonfairTryAcquire(acquires);

         }

     }

     /**

      * Sync object for fair locks

      */

     static final class FairSync extends Sync {

         private static final long serialVersionUID = -3000897897090466540L;

         final void lock() {

             acquire(1);

         }

         /**

          * Fair version of tryAcquire.  Don't grant access unless

          * recursive call or no waiters or is first.

          */

         protected final boolean tryAcquire(int acquires) {

             final Thread current = Thread.currentThread();

             int c = getState();

             if (c == 0) {

                 if (!hasQueuedPredecessors() &&

                     compareAndSetState(0, acquires)) {

                     setExclusiveOwnerThread(current);

                     return true;

                 }

             }

             else if (current == getExclusiveOwnerThread()) {

                 int nextc = c + acquires;

                 if (nextc < 0)

                     throw new Error("Maximum lock count exceeded");

                 setState(nextc);

                 return true;

             }

             return false;

         }

     }

 ReentrantLock lock = new ReentrantLock(true);

 /**

      * Creates an instance of {@code ReentrantLock}.

      * This is equivalent to using {@code ReentrantLock(false)}.

      */

     public ReentrantLock() {

         sync = new NonfairSync();

     }

     /**

      * Creates an instance of {@code ReentrantLock} with the

      * given fairness policy.

      *

      * @param fair {@code true} if this lock should use a fair ordering policy

      */

     public ReentrantLock(boolean fair) {

         sync = fair ? new FairSync() : new NonfairSync();

     }

读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

　　正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

　　ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

　　可以通过readLock()获取读锁，通过writeLock()获取写锁。

　　上面已经演示过了读写锁的使用方法，在此不再赘述。