ReentrantLock的相关方法使用

获取锁定

• void lock()：常用获取锁定的方法
• void lockInterruptibly()：如果当前线程未被中断，则获取锁定；如果当前线程被中断，则出现异常
• boolean tryLock()：调用时锁定未被另一个线程持有的情况下，才会获取该锁定
• boolean tryLock(long timeOut,TimeUnit unit)：如果锁定在给定时间内未被另一个线程持有，且当前线程未被中断，则获取该锁定

lock()方法

 public class Run {
     private ReentrantLock lock = new ReentrantLock();

     public void testLock(){
         try {
             lock.lock();

             for (int i = 0; i < 5; i++) {
                 System.out.println("ThreadName = "+Thread.currentThread().getName()+", i = "+(i+1));
             }
             System.out.println(Thread.currentThread().getName()+"线程执行完毕，当前时间："+System.currentTimeMillis());
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
     public static void main(String[] args) {
         Run run = new Run();
         run.testLock();

         Runnable runnable = new Runnable() {
             @Override
             public void run() {
                 run.testLock();
             }
         };
         Thread threadA = new Thread(runnable);
         threadA.setName("A");
         threadA.start();
         Thread threadB = new Thread(runnable);
         threadB.setName("B");
         threadB.start();
     }
 }

----------------------------------------------------console----------------------------------------------------

ThreadName = main, i = 1
ThreadName = main, i = 2
ThreadName = main, i = 3
ThreadName = main, i = 4
ThreadName = main, i = 5
main线程执行完毕，当前时间：1539138509575
ThreadName = A, i = 1
ThreadName = A, i = 2
ThreadName = A, i = 3
ThreadName = A, i = 4
ThreadName = A, i = 5
A线程执行完毕，当前时间：1539138510587
ThreadName = B, i = 1
ThreadName = B, i = 2
ThreadName = B, i = 3
ThreadName = B, i = 4
ThreadName = B, i = 5
B线程执行完毕，当前时间：1539138511587

lockInterruptibly()方法

 public class Run2 {
     private ReentrantLock lock = new ReentrantLock();
     public void testLockInterruptibly(){
         try {
             lock.lockInterruptibly();
             System.out.println("ThreadName = "+Thread.currentThread().getName());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             if(lock.isHeldByCurrentThread()){//查询当前线程是否保持锁定
                 lock.unlock();
             }
         }
     }

     public static void main(String[] args) {
         Run2 run2 = new Run2();
         Runnable runnable = new Runnable() {
             @Override
             public void run() {
                 run2.testLockInterruptibly();
             }
         };
         Thread t1 = new Thread(runnable);
         t1.setName("T1");
         t1.start();

         Thread t2 = new Thread(runnable);
         t2.setName("T2");
         t2.start();
         t2.interrupt();
     }
 }

----------------------------------------------------console----------------------------------------------------

java.lang.InterruptedException
ThreadName = T1
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1220)
    at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
    at com.qf.test12.t.Run2.testLockInterruptibly(Run2.java:13)
    at com.qf.test12.t.Run2$1.run(Run2.java:29)
    at java.lang.Thread.run(Thread.java:748)

tryLock()方法

 public class Run3 {
     private ReentrantLock lock = new ReentrantLock();
     public void testTryLock(){//只获取锁定，不释放锁定
         if(lock.tryLock()){
             System.out.println(Thread.currentThread().getName()+"获得锁");
         }else {
             System.out.println(Thread.currentThread().getName()+"未获得锁");
         }
     }

     public static void main(String[] args) {
         Run3 run3 = new Run3();
         Runnable runnable = new Runnable() {
             @Override
             public void run() {
                 run3.testTryLock();
             }
         };
         Thread threadA = new Thread(runnable);
         threadA.setName("A");
         threadA.start();
         Thread threadB = new Thread(runnable);
         threadB.setName("B");
         threadB.start();
     }
 }

----------------------------------------------------console----------------------------------------------------

A获得锁
B未获得锁

tryLock(long timeOut,TimeUnit unit)方法

 public class Run3 {
     private ReentrantLock lock = new ReentrantLock();
     public void testTryLock(){
         try {
             if(lock.tryLock(3, TimeUnit.SECONDS)){
                 System.out.println(Thread.currentThread().getName()+"获得锁");
                 Thread.sleep(4000);//有一个未获得锁
                 //Thread.sleep(2000);//两个都获得锁
             }else {
                 System.out.println(Thread.currentThread().getName()+"未获得锁");
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             if(lock.isHeldByCurrentThread()){
                 lock.unlock();
             }
         }
     }

     public static void main(String[] args) {
         Run3 run3 = new Run3();
         Runnable runnable = new Runnable() {
             @Override
             public void run() {
                 System.out.println(Thread.currentThread().getName()+"执行，当前时间："+System.currentTimeMillis());
                 run3.testTryLock();
             }
         };
         Thread threadA = new Thread(runnable);
         threadA.setName("A");
         threadA.start();
         Thread threadB = new Thread(runnable);
         threadB.setName("B");
         threadB.start();
     }
 }

----------------------------------------------------console----------------------------------------------------

--------------------Thread.sleep(4000)-------------------
A执行，当前时间：1539141085501
B执行，当前时间：1539141085501
B获得锁
A未获得锁
--------------------Thread.sleep(2000)-------------------
A执行，当前时间：1539141269380
B执行，当前时间：1539141269380
A获得锁
B获得锁

其他常用方法

getXxx方法

• int getHoldCount()方法：查询当前线程保持此锁定的个数，即当前线程调用lock()方法的次数
• int getQueueLength()方法：返回正在等待此锁定的线程估计数
• int getWaitQueueLength(Condition condition)方法：返回等待与此锁定相关的给定条件的线程估计数

hasXxx方法

• boolean hasQueuedThread(Thread thread)方法：查询指定线程是否正在等待获取此锁定
• boolean hasQueuedThreads()方法：查询是否有线程正在等待此锁定
• boolean hasWaiters(Condition condition)方法：查询是否有线程正在等待与此锁定有关的condition条件

isXxx方法

• boolean isFair()方法：判断是不是公平锁
• boolean isHeldByCurrentThread()方法：查询当前线程是否保持此锁定
• boolean isLocked()方法：判断此锁定是否由任意线程保持

Condition的几个方法

• awaitUninterruptibly()方法：调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。调用该方法后，结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断，该方法仍然会继续等待，同时保留该线程的中断状态。
• awaitNanos(long nanosTimeout) 方法：调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。nanosTimeout指定该方法等待信号的的最大时间（单位为纳秒）。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间；若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数
• awaitUntil(Date deadline) 方法：适用条件与行为与awaitNanos(long nanosTimeout)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻，等待时间到达前可以被其他线程提前唤醒