千家信息网

怎么进行Lock总结

发表于:2025-01-27 作者:千家信息网编辑
千家信息网最后更新 2025年01月27日,今天就跟大家聊聊有关怎么进行Lock总结,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。Lock在我们日常研发中经常会使用到,比如ReenTra
千家信息网最后更新 2025年01月27日怎么进行Lock总结

今天就跟大家聊聊有关怎么进行Lock总结,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。

Lock在我们日常研发中经常会使用到,比如ReenTrantLock,ReentrantReadWriteLock,StampedLock (JDK1.8新增),下面就详细介绍一下它们的使用方法。

  • ReenTrantLock

    ReenTrantLock支持公平锁和非公平锁,也是独占锁,下面来说一下ReenTrantLock下的方法和使用。

    1. lock: 获取阻塞锁。

      // 默认是费公平锁,可自定,在参数中增加 true-公平 false-非公平ReenTrantLock lockObjcet = new ReenTrantLock();try {  // 获取锁 ,如果获取不到则阻塞线程  lockObjcet.lock();  // 同步代码块} catch (Exception e) {} finally {  // 释放锁  lockObjcet.unLock();}


    2. **tryLock:**获取非阻塞锁,如果无法获取到锁,返回false,获取到了返回true。

      ReenTrantLock lock = new ReenTrantLock();if (lock.tryLock()) {  // 获取到了锁} else {  // 没有获取到锁}


    3. **tryLock(time):**获取非阻塞超时锁,在time时间内如果获取到了锁,返回true,获取不到锁返回false。

      ReenTrantLock lock = new ReenTrantLock();// 获取锁,如果在指定时间内还未获得,则返回falseif (lock.tryLock(100)) {  // 获取到了锁} else {  // 没有获取到锁}


    4. lockInterruptibly(): 获取可中断锁,和lock区别就是在获取锁的过程中可以中断线程。

    5. unlock(): 解锁

    6. boolean isHeldByCurrentThread(): 判断锁是否是当前线程持有,是返回true,不是返回false。

    7. boolean isLocked(): 判断锁是否被获取或占用。

    8. boolean isFair(): 是否是公平锁,是 返回true, 不是返回false。

    9. Thread getOwner(): 获取当前锁的拥有者, 如果有拥有者则返回拥有者,如果没有返回null。

    10. boolean hasQueuedThreads(): 判断是否有等待线程,如果有则返回true,反之false。

    11. boolean hasQueuedThread(Thread thread): 判断入参的线程是否存在于等待队列中,如果存在则返回true,反之false。

    12. int getQueueLength(): 获取等待队列中线程总数。

    13. Collection getQueuedThreads(): 获取等待队列中的所有线程。

    14. boolean hasWaiters(Condition condition): 否有线程在与此锁关联的给定条件上等待,有返回true 反之 false。

    15. int getWaitQueueLength(Condition condition): 获取被参数 条件等待的线程总数。

    16. Collection getWaitingThreads(Condition condition): 获取当前锁的条件等待的所有线程.

  • ReentrantReadWriteLock

    读写锁: 读锁可以多线程一起获取,写锁只有一个线程可以获取,读写锁支持公平锁和非公平锁,支持重入锁。

    读锁: 可以被多个线程共同获取锁,同时进入代码块。

    写锁: 只允许一个线程获取,如果当前线程获取到写锁后,发现有线程获取了读锁,并且不是当前线程,这时当前线程就进入等待状态。

    代码示例:

    // 读写锁private  ReadWriteLock rw = new ReentrantReadWriteLock();// 读锁 共享锁private  Lock r = rw.readLock();// 写锁 排它锁private  Lock w = rw.writeLock();
    • WriteLock

    • ReadLock

    1. lock(): 加锁。

    2. unlock(): 解锁。

    1. lock(): 写锁为独占锁,当线程A获取到了写锁时任何线程都不能获取到读锁和写锁,如果线程A获取到了写锁,但是读锁已经被线程B获取并且未释放,这时就需要将线程A状态改为等待,等待线程B释放了写锁再继续执行。

    2. unlock(): 解锁。

  • StampedLock (JDK1.8新增)

    StampedLock: 读写锁,但是StampedLockReenTrantReadWriteLock更块,但是StampedLock 用于 乐观读锁,悲观读 锁,和 写锁,StampedLock不支持重入锁,StampedLock 的悲观读锁、写锁都不支持条件变量

    代码示例:

    /** * @Auther: lantao * @Date: 2019-05-05 17:55 * @Company: 随行付支付有限公司 * @maill: lan_tao@suixingpay.com * @Description: TODO */public class StampedLockTest {    static StampedLock s =new StampedLock();    public static void main(String[] args) {        // 悲观读        long l = s.readLock();        // 释放悲观读        s.unlockRead(l);        // 悲观写        long l1 = s.writeLock();        // 释放悲观写        s.unlockWrite(l1);        // 乐观读 升级 悲观读        long l2 = s.tryOptimisticRead();        //验证是否被修改 如果返回false 会释放 l2,所以后续直接释放l3即可        if (!s.validate(l2)){            // 升级悲观读            long l3 = s.readLock();            s.unlockRead(l3);        }    }}


    1. tryOptimisticRead: 乐观读。

    2. readLock: 悲观读。

    3. writeLock: 悲观写。

  • Conditionn

    Condition: Lock 的条件 ,其实初始化的是ConditionObject, ConditionObject是Condition的实现,singal和signlAll的时候需要在获取锁后。**

    代码示例:

    /** * @Auther: lantao * @Date: 2019-04-15 14:49 * @Company: 随行付支付有限公司 * @maill: lan_tao@suixingpay.com * @Description: Condition 条件 有 singal signalAll 和 await 方法 和Object 的 notify notifyAll 和 wait 是一个意思同样会释放锁  执行singal和notify的时候也需要在等待获取锁 */public class LockCondition {    public static ReentrantLock lock = new ReentrantLock();    public static Condition a = lock.newCondition();    public static Condition b = lock.newCondition();    public static void main(String[] args) throws InterruptedException {        Runnable runnable = () -> {            try {                lock.lock();                System.out.println(Thread.currentThread().getName());                a.await();                System.out.println(Thread.currentThread().getName() +  " 的 a conndition 被唤醒了");                b.await();                System.out.println(Thread.currentThread().getName() +  " 的 b conndition 被唤醒了");            } catch (InterruptedException e) {                e.printStackTrace();            }finally {                lock.unlock();            }        };        Runnable runnable1 = () -> {            try {                lock.lock();                System.out.println("线程" +Thread.currentThread().getName() + " 开始执行a condition sinalAll");                a.signalAll();            } catch (Exception e) {                e.printStackTrace();            }finally {                lock.unlock();            }        };        Runnable runnable2 = () -> {            try {                lock.lock();                System.out.println("线程" +Thread.currentThread().getName() + " 开始执行b condition sinalAll");                b.signalAll();            } catch (Exception e) {                e.printStackTrace();            }finally {                lock.unlock();            }        };        new Thread(runnable,"Thread1").start();        new Thread(runnable,"Thread2").start();        Thread.sleep(100);        new Thread(runnable1,"Thread3").start();        Thread.sleep(100);        new Thread(runnable2,"Thread4").start();    }}// 执行结果Thread1Thread2线程Thread3 开始执行a condition sinalAllThread1 的 a conndition 被唤醒了Thread2 的 a conndition 被唤醒了线程Thread4 开始执行b condition sinalAllThread1 的 b conndition 被唤醒了Thread2 的 b conndition 被唤醒了

看完上述内容,你们对怎么进行Lock总结有进一步的了解吗?如果还想了解更多知识或者相关内容,请关注行业资讯频道,感谢大家的支持。

0