Java并发编程之ReentrantLock和ReentrantReadWriteLock

最新推荐文章于 2024-06-19 03:41:32 发布
最新推荐文章于 2024-06-19 03:41:32 发布
阅读量694 收藏 1
点赞数 1
分类专栏： java.concurrent 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nlznlz/article/details/82917183
版权

在Java多线程编程中，除了可以使用synchronized关键字实现线程同步外，从JDK1.5开始，新增了ReentrantLock、ReentrantReadWriteLock等类，同样能实现同步效果，而且在使用上更加方便。

ReentrantLock

ReentrantLock是可重入互斥锁，调用它的lock()方法获取锁，unlock()方法释放锁。

lock()和unlock()的逻辑

当一个线程调用ReentrantLock的lock()方法时，如果这个锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为1；如果当前线程已经保持了该锁，则把保持计数加1，并且该方法立即返回；如果这个锁被另一个线程保持，则在获得锁之前，该线程将一直处于休眠状态，此时锁的保持计数被设置为1。

当一个线程调用ReentrantLock的unlock()方法时，如果当前线程是此锁的拥有者，则将保持计数减1，如果保持计数变成了0，则释放该锁。如果当前线程不是该锁的持有者，则抛出IlletalMonitorStateException。

Condition

Condition概要

ReentrantLock实现了Lock接口，与Lock类相关的一个类是Condition，借助Condition可以实现线程间的等待/通知。Condition也是Java5中出现的技术，它具有比object.wait()和object.notify()更好的灵活性，比如实现多路通知功能，即一个Lock可以创建多个Condition(即对象监视器)实例，线程对象可以注册在指定的Condition中，从而有选择性地进行线程通知，在调度线程上更加灵活。

使用Condition实现等待/通知的样例代码如下：

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

class MyService {

    private Lock lock = new ReentrantLock();
    public Condition condition = lock.newCondition();

    public void await() {
        try {
            lock.lock();
            System.out.println("await时间为" + System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        try {
            lock.lock();
            System.out.println("signal时间为" + System.currentTimeMillis());
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread {

    private MyService service;

    ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.await();
    }
}

public class Main {

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

        MyService service = new MyService();

        ThreadA a = new ThreadA(service);
        a.start();

        Thread.sleep(3000);

        service.signal();
    }

}

await时间为1538418609554
signal时间为1538418612513

使用多个Condition实现通知部分线程：

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

class MyService {

    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();

    void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionA.await();
            System.out.println("end awaitA时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionB.await();
            System.out.println("end awaitB时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    void signalAll_A() {
        try {
            lock.lock();
            System.out.println("signalAll_A时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void signalAll_B() {
        try {
            lock.lock();
            System.out.println("signalAll_B时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionB.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread {

    private MyService service;

    ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitA();
    }
}

class ThreadB extends Thread {

    private MyService service;

    ThreadB(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitB();
    }
}

public class Main {

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

        MyService service = new MyService();

        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();

        Thread.sleep(3000);

        service.signalAll_A();
    }

}

begin awaitA时间为1538418670871 ThreadName=A
begin awaitB时间为1538418670871 ThreadName=B
signalAll_A时间为1538418673871 ThreadName=main
end awaitA时间为1538418673871 ThreadName=A

condition.await()的典型调用方式

通常一个线程是在某个条件c下需要被阻塞，这时我们让该线程在条件c对应的条件对象condition下等待。另一个线程使条件c被解除，同时它调用条件对象condition的signalAll()方法，唤醒所有等待线程，告诉它们可以继续执行了。

这时所有在此条件对象上等待的线程从等待集中移出，它们再次成为可运行的，调度器将再次激活它们。一旦锁成为可用的，它们中的某个将从await调用返回，获得该锁并从被阻塞的地方继续执行。由于其执行，条件c可能又被满足，导致其他的原来被阻塞的线程在执行的时候仍然需要被阻塞，这便是“虚假唤醒”。因此，条件c需要循环进行判断。

condition.await()的典型调用方式如下：

while(!okToProceed){
    condition.await();
}

关于此可以看下我的https://blog.csdn.net/nlznlz/article/details/89042809这篇文章中对阻塞队列ArrayBlockingQueue的源码分析，其中便体现了这个道理。

公平锁和非公平锁

锁Lock分为公平锁和非公平锁，公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即FIFO的顺序。非公平锁则是一种获取锁的抢占机制，是随机获得锁的，先来的不一定先得到锁，这个方式可能造成某些线程一直得不到锁。

下面的图形象化展示了公平锁和非公平锁的区别：

公平锁与非公平锁的一个重要区别就在于上图中的2、6、10那个步骤，对应源码如下：

//非公平锁
final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        } else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

//公平锁
protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        } else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

分析以上代码，我们可以看到公平锁就是在获取锁之前会先判断等待队列是否为空或者自己是否位于队列头部，该条件通过才能继续获取锁。

再结合兔子喝水的图分析，非公平锁获取所得顺序基本决定在9、10、11这三个事件发生的先后顺序：

  1. 若在释放锁的时候总是没有新的兔子来打扰，则非公平锁等于公平锁；
  2. 若释放锁的时候，正好一个兔子来喝水，而此时位于队列头的兔子还没有被唤醒（因为线程上下文切换是需要不少开销的），此时后来的兔子则优先获得锁，成功打破公平，成为非公平锁；

其实对于非公平锁，只要线程进入了等待队列，队列里面依然是FIFO的原则，跟公平锁的顺序是一样的。因为公平锁与非公平锁的release()部分代码是共用AQS的代码：

private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

由于非公平锁减少了线程挂起的几率，后来的线程有一定几率逃离被挂起，因此非公平锁的效率要高于公平锁。

ReentrantLock的其他方法

ReentrantLock的其他方法如下：

  • getHoldCount()，查询当前线程保持此锁的个数，如果此锁未被当前线程保持过，则返回0；
  • getQueueLength()，返回正等待获取此锁的线程估计数；
  • getWaitQueueLength(Condition)，返回等待此Condition的线程估计数；
  • hasQueuedThread(Thread)，查询指定的线程是否正在等待获取此锁定；
  • hasQueuedThreads()，查询是否有线程正在等待获取此锁定；
  • hasWaiters(Condition)，查询是否有线程正在等待此Condition；
  • isFair()，判断此锁是不是公平锁；
  • isHeldByCurrentThread()，查询当前线程是否保持此锁；
  • isLocked()，查询此锁是否由任意线程保持；
  • tryLock()，如果调用时锁未被另一个线程保持，则获取该锁，并返回true，否则返回false。

ReentrantReadWriteLock

ReentrantLock是完全互斥排他的锁，这样虽然保证了线程安全，但效率却是非常低下的，对此，JDK提供了一种读写锁ReentrantReadWriteLock，使用它可以加快运行效率。

读写锁表示有两个锁，一个是读锁，也叫共享锁；一个是写锁，也叫排他锁。多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。

读读共享

这段代码展示了读锁的共享性质：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    public static void main(String[] args) {
        Service s = new Service();
        Thread ta = new MyThread("threadA", s);
        ta.start();
        Thread tb = new MyThread("threadB", s);
        tb.start();
    }

    public static class MyThread extends Thread {
        Service s;

        public MyThread(String name, Service s) {
            super(name);
            this.s = s;
        }

        public void run() {
            s.service();
        }
    }

    public static class Service {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

        public void service() {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "获得了读锁，当前时间: " + System.currentTimeMillis());
            lock.readLock().unlock();
        }
    }
}

threadA获得了读锁，当前时间: 1538414809755
threadB获得了读锁，当前时间: 1538414809756

可以看到，两个线程都能顺利走到lock()方法后面的代码中，即读锁是共享的，不同的线程可以同时持有。

写写互斥

这段代码展示了写锁的排他性质：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    public static void main(String[] args) {
        Service s = new Service();
        Thread ta = new MyThread("threadA", s);
        ta.start();
        Thread tb = new MyThread("threadB", s);
        tb.start();
    }

    public static class MyThread extends Thread {
        Service s;

        public MyThread(String name, Service s) {
            super(name);
            this.s = s;
        }

        public void run() {
            s.service();
        }
    }

    public static class Service {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

        public void service() {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "获得了写锁，当前时间: " + System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            lock.writeLock().unlock();
        }
    }
}

threadA获得了写锁，当前时间: 1538415074339
threadB获得了写锁，当前时间: 1538415084340

可以看到，在大约10秒钟后另一个线程才进入到lock()方法后的代码，即写锁是排他的。

读写互斥

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    public static void main(String[] args) {
        Service s = new Service();
        Thread ta = new MyThread("threadA", s);
        ta.start();
        Thread tb = new MyThread("threadB", s);
        tb.start();
    }

    public static class MyThread extends Thread {
        Service s;

        public MyThread(String name, Service s) {
            super(name);
            this.s = s;
        }

        public void run() {
            if ("threadA".equals(getName())) {
                s.read();
            } else if ("threadB".equals(getName())) {
                s.write();
            }
        }
    }

    public static class Service {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

        public void read() {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + "获得了读锁，当前时间: " + System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            lock.readLock().unlock();
        }

        public void write() {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + "获得了写锁，当前时间: " + System.currentTimeMillis());
            try {
                Thread.sleep(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            lock.writeLock().unlock();
        }
    }
}

threadA获得了读锁，当前时间: 1538415518663
threadB获得了写锁，当前时间: 1538415528663

 

nju.拈花
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程——ReentrantLock
wait2023的博客
05-23 174
1 类图结构 ReentrantLock是JUC包下的一个独占锁，类图结构如下： 可以看到，其实现了Lock接口，并且底层是通过AQS抽象同步队列来实现的，我们直到AQS中有一个state状态变量，在ReentrantLock，state = 0时表示该锁还未被任何线程持有，大于1时则表示该锁已经被线程所持有，并且表示了该锁的重入次数。其中Sync是该类的一个内部类，NonfairSync和FaiSync分别对应获取锁的非公平与公平策略。对于这个锁，我们常用的就是lock与unlock方法，再就是C
JAVA中的ReentrantLock和ReentrantReadWriteLock锁简单使用
madman
01-20 7181
ReentrantLock的作用和synchronize是一样的，都是实现锁的功能，但是ReentrantLock需要手写代码对锁进行获取和释放(一定要在finally里面释放)，要不然就永远死锁了，ReentrantLock也可以用来做线程之间的挂起和通知，synchronize一般是使用object的wait和notify来实现，ReentrantLock使用Condition来实现线程之间的...
通俗易懂读写锁ReentrantReadWriteLock的使用
m0_71777195的博客
10-17 5227
ReentrantReadWriteLock不知道大家熟悉吗？其实在实际的项目中用的比较少，反正我所在的项目没有用到过。ReentrantReadWriteLock称为读写锁，它提供一个读锁，支持多个线程共享同一把锁。它也提供了一把写锁，是独占锁，和其他读锁或者写锁互斥，表明只有一个线程能持有锁资源。通过两把锁的协同工作，能够最大化的提高读写的性能，特别是读多写少的场景，而往往大部分的场景都是读多写少的。本文主要讲解ReentrantReadWriteLock的使用和应用场景。
读写锁ReentrantReadWriteLock详解
CodePanda@GPF的博客
04-10 3557
读写锁、ReentrantReadWriteLock
并发编程：浅析重入锁ReentrantLock与读写锁ReadWriteLock
最新发布
2401_85763997的博客
06-19 733
使用还有：当多个线程读写文件时，读操作与读操作之间不会发生冲突。但采用synchronized关键字实现同步时，还是只能一个线程进行读操作，其他读线程只能等待锁的释放而无法进行读操作。因此，需要一种机制来保证多线程都只是进行读操作时，线程之间不会发生冲突(解决方案：ReentrantReadWriteLock)。synchronized无法得知线程是否成功获取到锁 (解决方案：ReentrantLock)。… …
ReentrantReadWriteLock读写锁
m0_56054652的博客
11-04 2114
一、前言 ReentrantReadWriteLock中包含三种锁：读写锁、可重入锁、公平/非公平锁 1、读写锁 2、可重入锁： 又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。 对于Java ReetrantLock而言，从名字就可以看出是一个重入锁，其名字是Re entrant Lock 重新进入锁。 对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。 syn...
并发编程之ReentrantReadWriteLock详解
尽力而为！
01-13 1430
ReentrantReadWriteLock是Java中的一个读写锁实现，它允许多个线程同时读取共享资源（读读可以并发），但在写入时只允许一个线程独占（读写，写读，写写互斥）。这个锁支持重入，即同一个线程可以多次获取相同类型的锁。这种锁可以提高读操作的并发性，同时保证写操作的独占性。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。线程进入读锁的前提条件没有其他线程的写锁没有写请求或者有写请求，但调用线程和持有锁的线程是同一个。
ReentrantReadWriteLock原理详解
m0_53127809的博客
12-02 3275
当读操作远远高于写操作时,这时候使用读写锁让读——读可以并发,提高性能。 类似于数据库中的select.,from..lockinsharemode 提供一个数据容器类内部分别使用读锁保护数据的read()方法,写锁保护数据的write()方法 简单来说，就是读锁可以共享，但是写锁必须独占 一、ReentrantReadWriteLock JUC为我们提供了一个可用于读和写的读写锁。 简单看下使用方法： ReentrantReadWriteLo...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一...以上就是Java并发编程中的关键知识点，掌握这些内容对于理解和编写高效的并发程序至关重要。理解并熟练运用这些工具和机制，可以有效地提升多线程环境下的程序性能和稳定性。
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
java并发编程实践pdf笔记
12-15
Java并发编程实践是Java...通过这些笔记，我们可以了解到Java并发编程中的关键概念和实践，对于理解和编写高效的并发代码具有极大的帮助。在实际开发中，需要根据具体需求灵活应用这些知识，以保证程序的稳定性和性能。
java并发源码分析之实战编程
11-17
首先，Java并发库（java.util.concurrent）是Java并发编程的核心，提供了多种高级并发结构，如Executor框架、Future、Callable接口等。Executor框架通过将任务与执行分离，简化了多线程编程。ThreadPoolExecutor是其...
Java并发编程全景图.pdf
02-09
Java并发编程是Java语言中最为复杂且重要的部分之一，它涉及了多线程编程、内存模型、同步机制等多个领域。为了深入理解Java并发编程，有必要了解其核心技术点和相关实现原理，以下将详细介绍文件中提及的关键知识点...
一文搞懂“ReentrantReadWriteLock——读写锁”
lvhao123456789的博客
03-19 1557
一文搞懂“ReentrantReadWriteLock——读写锁”
ReentrantReadWriteLock详解
weixin_41951205的博客
02-28 801
一、简介 1. 什么是读写锁 前面我们介绍了ReentrantLock类，知道它的功能类似synchronized关键字，属于排它锁，同一时刻仅有一个线程可以进行访问。但是在大部分的场景下，读操作往往远大于写操作，其中读操作之前不存在数竞争关系，而写操作与其余的读写操作互斥。因此JDK为我们提供了读写锁——ReentrantReadWriteLock。 读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时
【并发编程学习篇】ReentrantReadWriteLock详解
热门推荐
一个勤勤恳恳的程序猿
11-23 2万+
现实中有这样一种场景对共享资源有读和写的操作，且写操作没有读操作那么频繁（读多写少）在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源（读读可以并发）但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写操作了（读写，写读，写写互斥）在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。
Java并发包中的读写锁及其实现分析
极北三少
11-02 580
1. 前言 在Java并发包中常用的锁（如：ReentrantLock），基本上都是排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。 除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁
2019.11.14学习总结
qq_41641761的博客
11-15 330
Java开发中几种常见的锁 1.公平锁 是指多个线程按照申请锁的顺序来获取资源，类似于队列，先进先出（FIFO）。 2.非公平锁 是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程先获得锁。在高并发的情况下，有可能造成优先级反转或饥饿现象。 源码： public ReentrantLock(boolean fair) { sync = fair ? new F...
Java并发编程：ReentrantReadWriteLock深度解析
在Java并发编程中，ReentrantReadWriteLock（可重入读写锁）是一个重要的工具，用于控制对共享资源的访问。它是Java并发包（java.util.concurrent.locks）的一部分，提供比synchronized更细粒度的锁控制，允许多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值