锁 Lock、重入锁、写入锁

ReentrantLock 重入锁 类似于synchronize 区别与写法上，在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，
   不然会造成锁永远无法释放，其他线程永远进不来的结果。
eg:

 package com.zym.height.Lock01;

 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 public class UseReentrantLock {

     private Lock lock = new ReentrantLock();

     public void method1(){
         try {
             lock.lock();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
             Thread.sleep();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
             Thread.sleep();
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {

             lock.unlock();
         }
     }

     public void method2(){
         try {
             lock.lock();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
             Thread.sleep();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
             Thread.sleep();
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {

             lock.unlock();
         }
     }

     public static void main(String[] args) {

         final UseReentrantLock ur = new UseReentrantLock();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 ur.method1();
                 ur.method2();
             }
         }, "t1");

         t1.start();
         try {
             Thread.sleep();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         //System.out.println(ur.lock.getQueueLength());
     }

 }

Lock Condition 
公平锁和非公平锁

Lock lock = new ReentrantLock();    
lock用法：
tryLock()：尝试获得锁（在给定的时间内尝试获得锁），获得结果用true/false返回。
isFair():是否是公平锁。
isLocked()：是否锁定。
getHoldCount()：查询当前线程保持此锁的个数，也就是调用lock()次数。
lockInterruptibly()：优先响应中断的锁。
getQueueLength()：返回正在等待获取此锁的线程数。
getWaitQueueLength()：返回等待与锁定相关的给定条件Condition的线程数。
hasQueuedThread(Thread thread)：查询指定的线程是否正在等待此锁。
hasQueuedThreads()：查询是否有线程正在等待此锁。
hasWaiters()：查询是否有线程正在等待与此锁定有关的condition条件。

 package com.zym.height.Lock01;

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 public class UseCondition {

     private Lock lock = new ReentrantLock();
     private Condition condition = lock.newCondition();

     public void method1(){
         try {
             lock.lock();
             System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
             Thread.sleep();
             System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
             condition.await();    // Object wait
             System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void method2(){
         try {
             lock.lock();
             System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
             Thread.sleep();
             System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
             condition.signal();        //Object notify
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public static void main(String[] args) {

         final UseCondition uc = new UseCondition();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 uc.method1();
             }
         }, "t1");
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 uc.method2();
             }
         }, "t2");
         t1.start();

         t2.start();
     }

 }

UseCondition

 package com.zym.height.Lock01;

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;

 public class UseManyCondition {

     private ReentrantLock lock = new ReentrantLock();
     private Condition c1 = lock.newCondition();
     private Condition c2 = lock.newCondition();

     public void m1(){
         try {
             lock.lock();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
             c1.await();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void m2(){
         try {
             lock.lock();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
             c1.await();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void m3(){
         try {
             lock.lock();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
             c2.await();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void m4(){
         try {
             lock.lock();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
             c1.signalAll();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void m5(){
         try {
             lock.lock();
             System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
             c2.signal();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public static void main(String[] args) {

         final UseManyCondition umc = new UseManyCondition();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 umc.m1();
             }
         },"t1");
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 umc.m2();
             }
         },"t2");
         Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 umc.m3();
             }
         },"t3");
         Thread t4 = new Thread(new Runnable() {
             @Override
             public void run() {
                 umc.m4();
             }
         },"t4");
         Thread t5 = new Thread(new Runnable() {
             @Override
             public void run() {
                 umc.m5();
             }
         },"t5");

         t1.start();    // c1
         t2.start();    // c1
         t3.start();    // c2

         try {
             Thread.sleep();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         t4.start();    // c1
         try {
             Thread.sleep();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         t5.start();    // c2

     }

 }

UseManyCondition

 package com.zym.height.Lock01;

 import java.util.concurrent.locks.ReentrantLock;
 /**
  * lock.getHoldCount()方法：只能在当前调用线程内部使用，不能再其他线程中使用
  * 那么我可以在m1方法里去调用m2方法，同时m1方法和m2方法都持有lock锁定即可 测试结果holdCount数递增
  *
  */
 public class TestHoldCount {

     //重入锁
     private ReentrantLock lock = new ReentrantLock();

     public void m1(){
         try {
             lock.lock();
             System.out.println("进入m1方法，holdCount数为：" + lock.getHoldCount());

             //调用m2方法
             m2();

         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void m2(){
         try {
             lock.lock();
             System.out.println("进入m2方法，holdCount数为：" + lock.getHoldCount());
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public static void main(String[] args) {
         TestHoldCount thc = new TestHoldCount();
         thc.m1();
     }
 }

Test HoldCondition

ReentrantReadWriteLock
读写锁  其核心就是实现读写分离的锁，在高并发访问下，尤其是读多写少的情况下，性能要远高于重入锁，在同一时间，只能有一个线程
　　　　　　可以进行访问被锁定的代码，那么读写锁则不同，其本质是分层两个锁，即读锁、写锁。在读锁下，多个线程可以并发的进行访问，
　　　　　　但是在写锁的时候，只能一个一个的顺序访问。
口诀：读读共享，写写互斥，读写互斥。

 package com.zym.height.Lock01;

 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

 public class UseReentrantReadWriteLock {

     private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
     private ReadLock readLock = rwLock.readLock();
     private WriteLock writeLock = rwLock.writeLock();

     public void read(){
         try {
             readLock.lock();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
             Thread.sleep();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             readLock.unlock();
         }
     }

     public void write(){
         try {
             writeLock.lock();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
             Thread.sleep();
             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             writeLock.unlock();
         }
     }

     public static void main(String[] args) {

         final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();

         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 urrw.read();
             }
         }, "t1");
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 urrw.read();
             }
         }, "t2");
         Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 urrw.write();
             }
         }, "t3");
         Thread t4 = new Thread(new Runnable() {
             @Override
             public void run() {
                 urrw.write();
             }
         }, "t4");        

 //        t1.start();
 //        t2.start();

 //        t1.start(); // R
 //        t3.start(); // W

         t3.start();
         t4.start();

     }
 }