Java Lock 锁的特性和使用（ReentrantLock ReentrantReadWriteLock Condition 可重入锁、读写锁 是什么 使用场景 与Synchronized的区别）

最新推荐文章于 2024-08-29 11:24:17 发布
最新推荐文章于 2024-08-29 11:24:17 发布
阅读量1.1k 收藏 4
点赞数 1
分类专栏： 并发编程 文章标签： 队列 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013546788/article/details/106369278
版权

Lock入门

跟同步关键字有同样的内存语义。

与Synchronized的比较

对比

与 synchronized 相比，ReentrantLock 更灵活。

  • 他支持阻塞等待/可中断的等待/非阻塞的获取/超时等待 等
    • 阻塞期间不会响应中断
  • 支持更细粒度的可重入锁

 

代码示例

// ************************** Synchronized **************************
// 1.用于代码块
synchronized (this) {}
// 2.用于对象
synchronized (object) {}
// 3.用于方法
public synchronized void test () {}
// 4.可重入
for (int i = 0; i < 100; i++) {
    synchronized (this) {}
}

// ************************** ReentrantLock **************************
public void testLock() throw Exception {
    // 1.初始化选择公平锁、非公平锁
    ReentrantLock lock = new ReentrantLock(true);
    // 2.可用于代码块
    lock.lock();
    try {
        try {
            // 3.支持多种加锁方式，比较灵活; 具有可重入特性
            if(lock.tryLock(100, TimeUnit.MILLISECONDS)){ }
        } finally {
            // 4.手动释放锁
            lock.unlock()
            }
    } finally {
        lock.unlock();
    }
}

ReentrantLock

API

方法描述
lock

获取锁的方法，若锁被其他线程获取，则等待(阻塞)

lockinterruptibly

在锁的获取过程中可以中断当前线程

tryLock

尝试非阻塞地获取锁，立即返回

unlock

释放锁

Tips：

根据Lock接口的源码注释，Lock接口的实现， 具备和同步关键字同样的内存语义。

 

实例

可重入

  • 可重入的定义：一个 Lock 对象可以被同一线程加锁多次
  • 注意一点：一定要在 finally 中进行解锁，避免死锁
public class ReentrantDemo1 {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        lock.lock();  // block until condition holds
        try {
            System.out.println("第一次获取锁");
            System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
            lock.lock();
            System.out.println("第二次获取锁了");
            System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
        } finally {
            lock.unlock();
            lock.unlock();
        }
        System.out.println("当前线程获取锁的次数" + lock.getHoldCount());

        // 如果不释放，此时其他线程是拿不到锁的
        new Thread(() -> {
            System.out.println(Thread.currentThread() + " 期望抢到锁");
            lock.lock();
            System.out.println(Thread.currentThread() + " 线程拿到了锁");
        }).start();
    }
}

 

可响应中断

中断只是标记线程应该被中断，但不是马上停止

  • lockInterruptibly 可在等待的过程响应中断
// 可响应中断
public class LockInterruptiblyDemo1 {
    private Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        LockInterruptiblyDemo1 demo1 = new LockInterruptiblyDemo1();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    demo1.test(Thread.currentThread());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        Thread.sleep(500); // 等待0.5秒，让thread1先执行

        thread2.start();
        Thread.sleep(2000); // 两秒后，中断thread2

        thread2.interrupt();
    }

    public void test(Thread thread) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "， 想获取锁");
        lock.lockInterruptibly();   //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
        try {
            System.out.println(thread.getName() + "得到了锁");
            Thread.sleep(10000); // 抢到锁，10秒不释放
        } finally {
            System.out.println(Thread.currentThread().getName() + "执行finally");
            lock.unlock();
            System.out.println(thread.getName() + "释放了锁");
        }
    }
}

 

lockInterruptibly()/lock() 区别

  • lockInterruptibly 可以响应中断
    • 即，阻塞时被中断，可以 throw exception
  • lock() 不响应中断
    • 被 interrupt 后不会立即中断，而是继续等待

ReentrantReadWriteLock 读写锁

读写锁定义

  • 维护一对关联锁，一个用于只读操作，一个用于写入。
  • 读锁可以由多个读线程同时持有，写锁是排他的。
    • 写锁的时候可以读。
    • 读锁的时候不可写。
  • 适合读取线程比写入线程多的场景，改进互斥锁的性能。
    • 示例场景：缓存组件、集合的并发线程安全性改造。

锁降级定义

  • 锁降级指的是写锁降级成为读锁。
    • 当前线程拥有的写锁的同时，再获取到读锁，随后释放写锁的过程。
  • 写锁是线程独占，读锁是共享，所以写->读是升级。(读->写， 是不能实现的)

 

使用读写锁防止缓存雪崩（锁降级实例）

  • 问题：
    • 当没有读写锁时，大量请求在没有命中缓存的情况下，全部打到 db 上。
    • 有可能出现数据不一致的情况。
  • 锁降级：写锁 -> 读锁
    • 释放了读锁，才可以加写锁
    • 不会造成死锁！！
  • 缓存雪崩
    • 在没有命中缓存的情况下，释放读锁，加写锁。防止多个线程同时读 db，导致雪崩
  • Park/Unpark底层实现是用的 Unsafe 机制
// 缓存示例
public class CacheDataDemo {
    // 创建一个map用于缓存
    private Map<String, Object> map = new HashMap<>();
    private static ReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        // 1 读取缓存里面的数据
        // cache.query()
        // 2 如果换成没数据,则取数据库里面查询  database.query()
        // 3 查询完成之后,数据塞到塞到缓存里面 cache.put(data)
    }

    public Object get(String id) {
        Object value = null;
        // 首先开启读锁，从缓存中去取（防止数据不一致，要释放了读锁才会加写锁）
        rwl.readLock().lock();
        try {
            value = map.get(id);
            if (value == null) {
                // TODO database.query();  全部查询数据库 ,缓存雪崩
                // 必须释放读锁，否则无法加写锁
                rwl.readLock().unlock();
                // 如果缓存中没有释放读锁，上写锁。防止多个相同的查询请求同时查询数据库
                rwl.writeLock().lock(); // 所有线程在此处等待  1000  1  999 (在同步代码里面再次检查是否缓存)
                try {
                    value = map.get(id);
                    // 双重检查。如果已经写了缓存，则其他线程直接获取
                    if (mvalue == null) {
                        // TODO value = ...如果缓存没有，就去数据库里面读取
                    }
                    // 写锁降级读锁，保证了之前读取操作的数据一致性。（在释放读锁前，其他线程无法修改缓存的值）
                    rwl.readLock().lock(); 
                } finally {
                    rwl.writeLock().unlock(); // 释放写锁@
                }
            }
            
        /* 在这里又进行了一系列操作，在操作过程中，有可能数据改变导致缓存内容改变
           此时，要在写锁中加入读锁，防止类似于 幻读，脏读 等的产生
        */
           
        } finally {
            rwl.readLock().unlock();
        }
        return value;
    }
}

 

Condition

概念

可以更细粒度的的控制等待，与 ReentrantLock 配合使用

  • 与 synchronized 中 wait()/notify()/notifyAll()对比
    • 用于替代 wait()/notify()
    • 粒度更细
      • Condition 则提供了多个等待集合，可以指定具体操作的集合，粒度更细。
      • wait()/notify() 只有一个等待集合，notify 只能唤醒 waiters 中的一个或多个，没办法指定具体唤醒线程
    • 是否释放锁：都会释放已持有的锁（不释放会死锁）
  • 底层：park/unpark

使用场景

JDK 中队列的实现

  • 多线程读写队列，写入数据后，唤醒读取线程继续执行；读取数据后，通知写入队列继续执行

image.png

// condition 实现队列线程安全。
public class QueueDemo {
    final Lock lock = new ReentrantLock();
    // 指定条件的等待 - 等待有空位
    final Condition notFull = lock.newCondition();
    // 指定条件的等待 - 等待不为空
    final Condition notEmpty = lock.newCondition();

    // 定义数组存储数据
    final Object[] items = new Object[100];
    int putptr, takeptr, count;

    // 写入数据的线程,写入进来
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) // 数据写满了
                notFull.await(); // 写入数据的线程,进入阻塞
            items[putptr] = x;
            if (++putptr == items.length) putptr = 0;
            ++count;
            notEmpty.signal(); // 唤醒指定的读取线程
        } finally {
            lock.unlock();
        }
    }
    // 读取数据的线程,调用take
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await(); // 线程阻塞在这里,等待被唤醒
            Object x = items[takeptr];
            if (++takeptr == items.length) takeptr = 0;
            --count;
            notFull.signal(); // 通知写入数据的线程,告诉他们取走了数据,继续写入
            return x;
        } finally {
            lock.unlock();
        }
    }
}

实例

HashMap 的线程安全改造

HashTable 是如何实现线程安全的

  • get/put 操作都是通过 synchronized 关键字保证线程安全，导致每次只能有一个线程 get/put
    • synchronized 修饰方法时锁定的是调用该方法的对象

 

使用读写锁改造HashMap

  • 将 HashMap 改造为线程安全的类（这里只是简单的改造 get/put 方法）
  • 使用场景：读多写少，可以多个线程同时读；但只有一个线程可写（全部读完后才开始写操作）。
public class ThreadSafeMap<K, V> extends HashMap<K, V> {
    //使用读写锁保证线程安全
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    @Override
    public V get(Object key) {
        V value;
        try {
            readLock.lock();
            return super.get(key);
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public V put(K key, V value) {
        V ret;
        try {
            writeLock.lock();
            return super.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
}

自实现 ReentrantLock

  • 提示：
    • 要使用 pack/unpack 实现同步
    • wait()/notify() 必须要在同步代码块（monitor object）
  • 注意：
    • 一定要在 unlock() 成功以后在进行 uppark
    • 非公平的，有可能在 unlock 的 CAS 执行成功后，unpark waiter 之前，有新的线程进行了 lock
/**
 * 自己手动实现的一个 reentrantLock
 *
 */
public class GzyLock  implements Lock {

    //需要 CAS 自旋的方式去实现
    //模仿 monitor obj 的重量级锁 有一个 owner
    private static AtomicReference<Thread> owner = new AtomicReference<>();

    private static LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();

    @Override
    public void lock() {
        boolean addQueue = true;
        while (!tryLock()){
            //第一次进来会放到queue
            if(addQueue) {
                //如果没有获取到锁，就先存到 queue
                waiters.offer(Thread.currentThread());
                addQueue = false;
            }else {
                //park 等待被唤醒。这里不能用 wait/notify 因为需要在同步代码块用
                LockSupport.park();
            }
            //唤醒后尝试争抢，没抢到继续等
        }
        //抢到锁，移除掉
        waiters.remove(Thread.currentThread());
    }
    @Override
    public boolean tryLock() {
        //适用当前线程尝试加锁
        return owner.compareAndSet(null, Thread.currentThread());
    }

    @Override
    public void unlock() {
        //unlock 的时候，要唤醒等待线程
        //如果释放锁成功了，才会唤起
        //这里用 if 是因为，一定不会出现 循环
        if (owner.compareAndSet(Thread.currentThread(), null)) {
            //一次唤醒所有在等待队列的
            for (Thread waiter : waiters) {
                //唤起等待队列的线程
                LockSupport.unpark(waiter);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Adder adder = new Adder();
        for (int j = 0; j < 10; j++) {
            Thread addThread = new Thread(() -> {
                for (int i = 0; i < 1000; i++) {
                    adder.add();
                }
            });
            addThread.start();;
        }
        Thread.sleep(1000L);
        System.out.println(adder.i);
    }

    static class Adder{

        Lock lock = new GzyLock();
        int i = 0;
        public void add(){
            lock.lock();
            try {
                i++;
            }finally {
                lock.unlock();
            }
        }
    }
}

 

Isaac_Gao
关注
专栏目录
Java可重入锁的实现原理与应用场景
08-26
今天小编就为大家分享一篇关于Java可重入锁的实现原理与应用场景，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
ReentrantLock可重入锁的使用场景
vincent
04-11 5031
场景1：如果发现该操作已经在执行中则不再执行（有状态执行）a、用在定时任务时，如果任务执行时间可能超过下次计划执行时间，确保该有状态任务只有一个正在执行，忽略重复触发。b、用在界面交互时点击执行较长时间请求操作时，防止多次点击导致后台重复执行（忽略重复触发）。以上两种情况多用于进行非重要任务防止重复执行，（如：清除无用临时文件，检查某些资源的可用性，数据备份操作等）private Reentran...
ReentrantReadWriteLock锁降级的使用场合和代码示例
最新发布
weixin_45873353的博客
08-29 961
比如 缓存更新与读取: 在缓存系统中，一个线程可能需要更新缓存内容（需要写锁保护以防止数据不一致）。此时，如果支持锁降级，线程可以降级为读锁，允许其他线程也进行读取，提高缓存的访问效率。等待Writer-Reader Thread锁降级之后Reader Thread就能获得读锁了。当发生降级后, Writer-Reader Thread的写锁降级为读锁, 这时候。的场景，它可以减少不必要的独占锁时间，提高系统的并发性能。取消注释, 运行主程序后, 结果是。取消注释, 运行主程序后, 结果是。
可重入锁的概念及使用场景
weixin_64229691的博客
12-11 3546
可重入锁的概念及使用场景
ReentrantLock锁
weixin_46121031的博客
05-14 7174
1. 简介 ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它可以等同于 synchronized 的使用，但是 ReentrantLock 提供了比 synchronized 更强大、灵活的锁机制，可以减少死锁发生的概率
ReentrantLock介绍及使用(超详细)
热门推荐
Mr.绵羊的知识星球
02-17 1万+
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
Java并发编程之重入锁与读写锁
08-29
在 Java 中，内置锁（synchronized）和 Lock（ReentrantLock）都是可重入的。synchronized 实例可以在方法或代码块上使用，以便 thread-safe，而 ReentrantLock 则需要手动加锁和解锁。例如： ```java public class...
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
9. **可读写的锁**：虽然ReentrantLock主要关注互斥锁，但Java并发包中还有ReentrantReadWriteLock，它提供了读写锁，允许多个读取线程同时访问资源，而写入操作仍然保持互斥。 总结来说，ReentrantLock提供了比...
Java对象锁和类锁全面解析（多线程synchronize
11-22
为了提高效率，Java提供了更高级的锁机制，如读写锁（ReentrantReadWriteLock）、显式锁（java.util.concurrent.locks.Lock接口的实现，如ReentrantLock）、条件变量（Condition）等。这些高级锁允许更细粒度的控制...
基于JDK源码解析Java领域中的并发锁之设计与实现.pdf
09-17
典型的Lock实现如ReentrantLock，它支持公平锁和非公平锁，以及可重入和可中断的特性。 五、ReadWriteLock接口的设计与实现 ReadWriteLock接口代表读写锁，它允许多个读取者同时访问资源，但在写入时确保互斥。典型...
java-syn.zip_Java syn_Java syn锁_java同步锁syn_java锁 syn_syn同步事务锁
09-14
- **显式锁**：如`java.util.concurrent.locks.Lock`接口及其实现，如`ReentrantLock`，提供了更复杂的锁操作，如可中断锁等待、公平锁等。 - **读写锁**：`ReentrantReadWriteLock`允许多个读取者同时访问，但...
【Interview】深入理解ReentrantLock锁
u010391342的博客
03-20 424
什么是ReentrantLock ReentrantLock是一个可重入的互斥锁锁， 实现Lock接口。具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义。ReentrantLock是显示的获取或释放锁，并且有锁超时，锁中断等功能。 内部维户了一个Sync的内部类，继承AQS队列同步器。 ReentrantLock 将由最近成功获得锁，并且还没...
JUC-ReentrantLock锁基础篇
zqj1172102457的博客
06-25 479
ReentrantLock是一种可重入的独占锁(互斥锁)。 独占锁: 一个线程获取()了这把锁，其他的线程则不能获取。 可重入：指的是线程A获取了这把锁，在线程A释放锁之前，线程A本身可以继续来获取这把锁。比如线程A调了了lock()方法获取了这把锁，在线程A调用unlock()方法之前，线程A本身继续调用lock()方法并不会阻塞住。重入锁的设计目的是为了解决死锁的问题。 ReentrantLock常常与Synchronized做对比，它们之间的对比如下:ReentrantLock提供的一些常用的方法有：
[Java多线程-基础] 避免线程死锁问题(ReentrantLock的使用)
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
04-30 1254
ReentrantLock 的设计初衷是为了提供一种比 synchronized 更加灵活和可控的锁机制。与 synchronized 相比，ReentrantLock 提供了更多的功能，如可重入性、公平锁和中断锁等，使得它在某些场景下更适用。具体来说，ReentrantLock 可以通过以下方式提供更好的控制和灵活性：1. 可重入性：允许线程多次获得同一个锁，避免死锁情况的发生。2. 公平锁：可以实现公平的锁分配机制，避免某些线程长期无法获取到锁而产生的饥饿问题。
多线程学习笔记-ReentrantLock
相信明天的博客
09-01 149
ReentrantLock的几个重要方法： lock()：获得锁，如果锁被占用则等待。 lockInterruptibly()：获得锁，但优先响应中断。 tryLock()：尝试获得锁，如果成功，则返回true；失败返回false。此方法不等待，立即返回。 unlock()：释放锁。 private final static Lock lock = new ReentrantLock(); public static void main(String[] args) throws Interr
ReentrantLock详解
weixin_44906791的博客
04-29 1391
ReentrantLock是一种可重入的独占锁，它允许同一个线程多次获取同一个锁而不会被阻塞。它的功能类似于synchronized是一种互斥锁，可以保证线程安全。可中断可以设置超时时间可以设置为公平锁支持多个条件变量与 synchronized 一样，都支持可重入它的主要应用场景是在多线程环境下对共享资源进行独占式访问，以保证数据的一致性和安全性。示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
2019.11.14学习总结
qq_41641761的博客
11-15 365
Java开发中几种常见的锁 1.公平锁 是指多个线程按照申请锁的顺序来获取资源，类似于队列，先进先出（FIFO）。 2.非公平锁 是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程先获得锁。在高并发的情况下，有可能造成优先级反转或饥饿现象。 源码： public ReentrantLock(boolean fair) { sync = fair ? new F...
Java并发编程（六）——Java中的并发工具类
weixin_43985675的博客
10-12 146
等待多线程完成的CountDownLatch CountDownLatch允许一个或多个线程等待其他线程完成操作。 join用于让当前执行线程等待join线程执行结束。其实现原理是不停检查join线程是否存活，如果join线程存活则让当前线程永远等待。 直到join线程中止后，线程的this.notifyAll()方法会被调用，调用notidyAll（）方法是在JVM里实现的。 同步屏障CyclicBarrier 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，
重入锁ReentrantLock详解
贾欣晓的博客
08-07 1271
重入锁ReentrantLock，顾名思义，就是支持重进入的锁，。除此之外，该锁的还支持获取锁时的公平和非公平性选择。在AQS实现中，当一个线程调用Mutex的lock()方法获取锁之后，如果再次调用lock()方法，则该线程将会被自己所阻塞，原因是Mutex在实现tryAcquire(int acquires)方法时没有考虑占有锁的线程再次获取锁的场景，。简单的说，Mutex是一个不支持重进入的锁。......
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值