ReentrantLock的三种获取锁Lock，tryLock，lockInterruptibly的区别

最新推荐文章于 2024-05-16 17:22:30 发布

thetimelyrain

最新推荐文章于 2024-05-16 17:22:30 发布

阅读量4.3k

点赞数 1

分类专栏：多线程

本文链接：https://blog.csdn.net/thetimelyrain/article/details/107164092

版权

多线程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

重入锁有三种获取锁的方式,本文就是来说明三种方式的异同点的.

lock

public void lock()

获得锁。

如果锁没有被另一个线程占用并且立即返回，则将锁定计数设置为1。
如果当前线程已经保持锁定，则保持计数增加1，该方法立即返回。
如果锁被另一个线程保持，则当前线程将被禁用以进行线程调度，并且在锁定已被获取之前处于休眠状态，此时锁定保持计数被设置为1。

tryLock

boolean tryLock();

当获取锁时，只有当该锁资源没有被其他线程持有才可以获取到，并且返回true，同时设置持有count为1。
当获取锁时，当前线程已持有该锁，那么锁可用时，返回true，同时设置持有count加1。
当获取锁时，如果其他线程持有该锁，无可用锁资源，直接返回false，这时候线程不用阻塞等待，可以先去做其他事情。
即使该锁是公平锁fairLock，使用tryLock()的方式获取锁也会是非公平的方式，只要获取锁时该锁可用那么就会直接获取并返回true。这种直接插入的特性在一些特定场景是很有用的。但是如果就是想使用公平的方式的话，可以试一试tryLock(0,TimeUnit.SECONDS)，几乎跟公平锁没区别，只是会监测中断事件

使用标准模板:

Lock lock = ...;
if (lock.tryLock()) {
   try {
    // manipulate protected state
    } finally {
       lock.unlock();
    }
 } else {
   // perform alternative actions
 }

tryLock的重载方法:

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

获取锁成功或者超时之后返回。而且在公平锁和非公平锁的场景下都可以使用，只是会增加对中断事件的监测。
当获取锁时，锁资源在超时时间之内变为可用，并且在等待时没有被中断，那么当前线程成功获取锁，返回true，同时当前线程持有锁的count设置为1.
当获取锁时，在超时时间之内没有锁资源可用，那么当前线程获取失败，不再继续等待，返回false.
当获取锁时，在超时等待时间之内，被中断了，那么抛出InterruptedException，不再继续等待.
当获取锁时，在超时时间之内锁可用，并且当前线程之前已持有该锁，那么成功获取锁，同时持有count加1.

lockInterruptibly

void lockInterruptibly() throws InterruptedException;

当获取锁时，锁资源可用，那么当前线程成功获得锁，同时持有count设置为1，返回true.
当获取锁时，锁资源可用，当前线程已持有该锁，它成功获取该锁，同时持有count增加1，返回true.
当获取锁时，锁资源不可用，那么该线程开始阻塞休眠等待，但是等待过程中如果有中断事件，那么会停止等待，立即返回.
当获取锁时，锁资源不可用，线程开始阻塞休眠等待，如果等待过程中锁资源变为可用，那么当前线程成功获得锁，同时持有count设置为1，返回true.

lockInterruptibly()获取锁是以排他的模式获取，一旦被中断就放弃等待获取。在等待开始时首先检测中断状态，然后至少调用一次tryAcquire，成功获取就返回true。否则当前线程就开始排队，并且不断的被blocking、unblocking、invoking tryAcquire 直到获取成功或者被中断为止。

下面使用代码进行演示:

package com.springcloud.server.springserver.thread;

import java.util.concurrent.locks.ReentrantLock;

public class TestLockAndTryLock {
    private ReentrantLock rlock = new ReentrantLock();

    private void lockTest(){
        long currentTime = System.currentTimeMillis();
        try {
            rlock.lock();

            while (System.currentTimeMillis() - currentTime <= 1000){
                //assume do something
            }
            System.out.println("lockTest----current thread get the lock: " + Thread.currentThread().getName());
        }finally {
            rlock.unlock();
            System.out.println("lockTest----current thread release the lock:  " + Thread.currentThread().getName());
        }
    }

    private void tryLockTest(){
        long currentTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - currentTime <= 100){
            //assume do something
        }
        if (rlock.tryLock()){
            try {
                System.out.println("tryLockTest----current thread get the lock: " + Thread.currentThread().getName());
            }finally {
                rlock.unlock();
                System.out.println("tryLockTest----current thread release the lock: " + Thread.currentThread().getName());
            }
        }else {
            System.out.println("tryLockTest----current thread CAN NOT get the lock: " + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args){

        TestLockAndTryLock lockAndTryLock = new TestLockAndTryLock();

        Thread lockThread = new Thread(
                () -> lockAndTryLock.lockTest(), "Lock-Thread" );

        Thread tryLockThread = new Thread(
                () -> lockAndTryLock.tryLockTest(), "TryLock-Thread" );



        tryLockThread.start();
        lockThread.start();

    }

}

输出结果:

lock()方法先获取锁,然后在执行任务的时候阻塞,tryLock()会在尝试加锁失败的时候返回false.

package com.springcloud.server.springserver.thread;

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

public class TestLockAndTryLock1 {
    private ReentrantLock rlock = new ReentrantLock();

    private void lockTest(){
        long currentTime = System.currentTimeMillis();
        try {
            rlock.lock();
            System.out.println("lockTest----current thread get the lock: " + Thread.currentThread().getName());
            while (System.currentTimeMillis() - currentTime <= 5000){
                //assume do something
            }
        }finally {
            rlock.unlock();
            System.out.println("lockTest----current thread release the lock:  " + Thread.currentThread().getName());
        }
    }

    private void tryLockInterruptTest(){
        long currentTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - currentTime <= 100){
            //assume do something
        }
        try {
            System.out.println("Begin time: " + System.currentTimeMillis());
            if (rlock.tryLock(1, TimeUnit.SECONDS)){
                try {
                    System.out.println("tryLockInterruptTest----current thread get the lock: " + Thread.currentThread().getName());
                }finally {
                    rlock.unlock();
                    System.out.println("tryLockInterruptTest----current thread release the lock: " + Thread.currentThread().getName());
                }
            }else {
                System.out.println("End time: " + System.currentTimeMillis());
                System.out.println("tryLockInterruptTest----current thread CAN NOT get the lock: " + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args){

        TestLockAndTryLock1 lockAndTryLock = new TestLockAndTryLock1();

        Thread lockThread = new Thread(
                () -> lockAndTryLock.lockTest(), "Lock-Thread" );

        Thread tryLockInterruptThread = new Thread(
                () -> lockAndTryLock.tryLockInterruptTest(), "TryLockInterrupt-Thread"
        );

        tryLockInterruptThread.start();
        lockThread.start();

    }

}

输出结果:

lock()方法先获取锁,然后执行任务5秒,tryLock()方法先直接获取锁,获取不到就在1秒的时间内持续获取锁,超过时间还获取不到就返回false.

package com.springcloud.server.springserver.thread;

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

public class TestLockAndTryLock2 {
    private ReentrantLock rlock = new ReentrantLock();

    private void lockTest(){
        long currentTime = System.currentTimeMillis();
        try {
            rlock.lock();
            System.out.println("lockTest----current thread get the lock: " + Thread.currentThread().getName());
            while (System.currentTimeMillis() - currentTime <= 5000){
                //assume do something
            }
        }finally {
            rlock.unlock();
            System.out.println("lockTest----current thread release the lock:  " + Thread.currentThread().getName());
        }
    }
    private void tryLockInterruptTest(){
        long currentTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - currentTime <= 100){
            //assume do something
        }
        try {
            System.out.println("Begin time: " + System.currentTimeMillis());
            if (rlock.tryLock(3, TimeUnit.SECONDS)){
                try {
                    System.out.println("tryLockInterruptTest----current thread get the lock: " + Thread.currentThread().getName());
                }finally {
                    rlock.unlock();
                    System.out.println("tryLockInterruptTest----current thread release the lock: " + Thread.currentThread().getName());
                }
            }else {
                System.out.println("End time: " + System.currentTimeMillis());
                System.out.println("tryLockInterruptTest----current thread CAN NOT get the lock: " + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            System.out.println("tryLockInterruptTest Interrupt----current thread is interrupted: " + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args){
        TestLockAndTryLock2 lockAndTryLock = new TestLockAndTryLock2();
        Thread lockThread = new Thread(
                () -> lockAndTryLock.lockTest(), "Lock-Thread" );
        Thread tryLockInterruptThread = new Thread(
                () -> lockAndTryLock.tryLockInterruptTest(), "TryLockInterrupt-Thread"
        );
        tryLockInterruptThread.start();
        lockThread.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + "is interrupted now. ");
        }
        tryLockInterruptThread.interrupt();
    }

}

lock()方法先获取锁,然后执行任务5秒,tryLock()方法先直接获取锁,获取不到就在1秒的时间内持续获取锁,在获取锁的过程中,主线程(main)以通知的方式中断tryLockInterruptThread线程,tryLock()方法可以响应中断.

package com.springcloud.server.springserver.thread;

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


public class TestLockInterruptibly {

    final Lock lock = new ReentrantLock();

    public static void main(String[] args) throws Exception {
        TestLockInterruptibly testLockInterruptibly = new TestLockInterruptibly();
        Thread lockThread = new Thread(
                () -> testLockInterruptibly.lock()
        );
        Thread interruptiblyThread = new Thread(
                () -> testLockInterruptibly.lockInterruptibly()
        );
        lockThread.start();
        interruptiblyThread.start();

        TimeUnit.SECONDS.sleep(2);
//        interruptiblyThread.interrupt();
    }

    public void lockInterruptibly()  {
        long currentTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - currentTime <= 500){
            //assume do something
        }
        try {
            lock.lockInterruptibly();
            System.out.println("lockInterruptibly获取Lock锁");
        } catch (InterruptedException e) {
            System.out.println("lockInterruptibly捕捉InterruptedException异常");
        }finally {
            lock.unlock();
            System.out.println("lockInterruptibly释放Lock锁");
        }
    }

    public void lock()  {
        long currentTime = System.currentTimeMillis();
        try {
            lock.lock();
            System.out.println("lock获取Lock锁");
            while (System.currentTimeMillis() - currentTime <= 5000){
                //assume do something
            }
        }finally {
            lock.unlock();
            System.out.println("lock释放Lock锁");
        }
    }

}

一般情况下,lockInterruptibly()会阻塞直到获取lock锁,此时和普通的lock()作用差不多,输出结果:

当我们打开main方法里面的注释,结果就不一样了,输出结果: