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)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻，等待时间到达前可以被其他线程提前唤醒