Lock锁＜二＞ _ 重入锁/读写锁

最新推荐文章于 2022-09-04 17:46:47 发布
最新推荐文章于 2022-09-04 17:46:47 发布
阅读量635 收藏
点赞数
分类专栏： 并发处理 文章标签： java 多线程 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37543627/article/details/124048941
版权

目录

一、重入锁ReentrantLock

1. 实现锁重进入

2. 获取公平锁与非公平锁的区别

二、读写锁ReentrantReadWriteLock

1. ReentrantReadWriteLock的API

2. 读写状态设计

3. 写锁的获取与释放

4. 读锁的获取与释放

5. 写锁降级

三、参考资料

一、重入锁ReentrantLock

        重入锁指线程获得锁后能够再次获取该锁而线程不被阻塞。synchronized关键字隐式的支持重进入。java.util.concurrent.locks.ReentrantLock类是重入锁，实现Lock接口。ReentrantLock不仅支持锁的重入，而且还支持获取锁的公平和非公平选择。

        公平的获取锁是指等待时间最长的线程最先获取锁，即：锁按FIFO顺序获取。ReentrantLock默认是非公平锁，原因：公平锁虽然保证锁的获取按照FIFO原则，而代价是进行大量的线程切换；非公平性锁虽然可能造成线程“饥饿”，但极少的线程切换，保证其更大的吞吐量。

1. 实现锁重进入

        以下代码是非公平锁的获取和释放，需要注意问题：

  • 线程再次获取锁：已获取锁的线程是否是当前线程，若是则再次成功获取锁；
  • 锁的最终释放：成功获取锁，state都要+1，即：state值表示当前被重复获取的次数，而释放锁时，则state自减，最后等于0时表示锁已经成功释放。
/**
 * 非公平性获取锁
 */
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // state == 0，表示没有任何线程获得锁
    if (c == 0) {
        // 尝试获取锁
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // state != 0，说明已有线程获取锁
    // 判断当前线程 == 已获取锁的线程，则再次加锁，计数器+1
    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 tryRelease(int releases) {
    // 每次释放，state自减
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // state == 0时，表示锁成功释放
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

2. 获取公平锁与非公平锁的区别

        公平锁按照FIFO队列的顺序获取锁，在非公平锁的基础上增加hasQueuedPredecessors()条件判定，即：同步队列的当前节点是否有前节点，若有返回true。

  • 非公平锁的获取：compareAndSetState(0, acquires)
  • 公平锁的获取：!hasQueuedPredecessors() && compareAndSetState(0, acquires)
/**
 * 公平锁的获取
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // state == 0，表示没有任何线程获得锁
    if (c == 0) {
        // 尝试获取锁
        // 公平获取锁 = 是否有前节点 + 非公平获取锁
        if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // state != 0，说明已有线程获取锁
    // 判断当前线程 == 已获取锁的线程，则再次加锁，计数器+1
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

二、读写锁ReentrantReadWriteLock

        读写锁是指同一时刻允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一个读锁（共享锁）和一个写锁（排他锁）。同时读写锁也支持公平或非公平锁、锁重入、写锁降级。

        java.util.concurrent.locks.ReentrantReadWriteLock读写锁实现ReadWriteLock接口，维护了一个读锁、一个写锁。注意读写锁的性能比排他锁的性能好，大多数场景下读多于写，这样多线程读提高了并发量和吞吐量。

1. ReentrantReadWriteLock的API

        注意：getReadLockCount()，获取当前读锁被获取的次数（共享读次数 + 重入锁次数）；getReadHoldCount()，获取当前线程获取读锁的次数（一个线程的重入锁次数），存储在每个线程的ThreadLocal下。

2. 读写状态设计

        同步器AQS维护一个int型的state变量，即：同步状态（private volatile int state） 。如下图所示，这个state同步状态“按位切割”：高16位，表示读锁；低16位，表示写锁。

        根据state值划分能得出一个推论：state不等于0时，当写状态（state & 0x0000FFFF）等于0时，则读状态（state >>> 16）大于0，即读锁已被获取。

3. 写锁的获取与释放

        如以下代码是java.util.concurrent.locks.ReentrantReadWriteLock.Sync类中方法，定义了写锁的获取，也支持写锁重进入。当前线程已获取写锁，则增加写状态；如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者当前线程不是已获取写锁的线程，则当前线程进入等待状态。

/**
 * ReentrantReadWriteLock写锁的获取
 * 该方法在java.util.concurrent.locks.ReentrantReadWriteLock.Sync继承了AQS
 */
protected final boolean tryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    // 获取state值
    int c = getState();
    // 获取写状态
    int w = exclusiveCount(c);
    // state值 != 0
    if (c != 0) {
        /*
         * state值 != 0 且 写状态 == 0：表示已获取读锁
         *    或
         * 别的线程已获取写锁
         */
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // 重入写锁
        setState(c + acquires);
        return true;
    }
    if (writerShouldBlock() ||
            !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}

        写锁的释放与ReentrantLock的释放过程基本类似，每次释放均减少写状态，当写状态为0
时表示写锁已被释放。

4. 读锁的获取与释放

        如以下代码是java.util.concurrent.locks.ReentrantReadWriteLock.Sync类中方法，定义了读锁的获取，也支持读锁重进入。如果其他线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态；如果当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全，依靠CAS保证）增加读状态，成功获取读锁。

        注意：其他线程没有持有写锁，但是当前线程已有写锁，那么读锁也可以成功获取，因为存在写锁降级的过程，详见下小节《写锁降级》。

        注意：读状态是所有线程获取读锁次数的总和，由getReadLockCount()获取；而每个线程各自获取读锁的次数只能选择保存在ThreadLocal中，由getReadHoldCount()获取。

/**
 * ReentrantReadWriteLock读锁的获取
 * 该方法在java.util.concurrent.locks.ReentrantReadWriteLock.Sync继承了AQS
 */
protected final int tryAcquireShared(int unused) {
    Thread current = Thread.currentThread();
    int c = getState();
    if (exclusiveCount(c) != 0 &&
            getExclusiveOwnerThread() != current)
        return -1;
    int r = sharedCount(c);
    if (!readerShouldBlock() &&
            r < MAX_COUNT &&
            compareAndSetState(c, c + SHARED_UNIT)) {
        if (r == 0) {
            firstReader = current;
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
            firstReaderHoldCount++;
        } else {
            ReentrantReadWriteLock.Sync.HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0)
                readHolds.set(rh);
            rh.count++;
        }
        return 1;
    }
    return fullTryAcquireShared(current);
}

        读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减少读状态，减少的
值是（1<<16）。

5. 写锁降级

        写锁降级指的是写锁降级成为读锁。锁降级是指当前线程已拥有写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。但是当前线程拥有写锁，然后将其释放，最后再获取读锁，这种分段完成的过程不能称锁降级。同时不支持锁升级。下面是写锁降级的代码实例。

// 创建读写锁
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

// 获取写锁
Lock writeLock = readWriteLock.writeLock();
// 获取读锁
Lock readLock = readWriteLock.readLock();

@Test
public void writeLockTest(){
    // 写锁降级从写锁获取开始
    writeLock.lock();
    try {
        // 再次获取读锁
        readLock.lock();
    } finally {
        // 释放写锁
        writeLock.unlock();
    }
    // 写锁降级完成，降级为读锁
}

        锁降级中读锁的获取是否必要呢？ 答案是必要的。主要是为了保证数据的可见性。如果当前线程不获取读锁而是直接释放写锁，假设此刻另一个线程T获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新。

三、参考资料

Lock锁＜一＞ _ 基础_爱我所爱0505的博客-CSDN博客

通俗易懂的ReentrantLock

ReentrantLock基础知识_米兰的小铁匠z的博客-CSDN博客_reentrantlock

ReentrantReadWriteLock读写锁详解 - 平凡希 - 博客园

Java并发编程--ReentrantReadWriteLock - 在周末 - 博客园

爱我所爱0505
关注
专栏目录
C++/Qt/QtQuick高级应用系列(2)_boost实现多线程/进程文件读写锁
zhengtianzuo的博客
12-31 543
总目录传送门 Boost的简介:     Boost是为C++语言标准库提供扩展的一些C++程序库的总称。Boost库是一个可移植、提供源代码的C++库，作为标准库的后备，是C++标准化进程的开发引擎之一，是为C++语言标准库提供扩展的一些C++程序库的总称。 Boost库由C++标准委员会库工作组成员发起，其中有些内容有望成为下一代C++标准库内容。在C++社区中影响甚大，是不折不扣的“准”标准库。     Boost由于其对
线程锁(Lock)、读写锁(ReadWriteLock)及条件阻塞Condition
Anna4的博客
04-29 1519
一、线程锁（Lock） Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。 示例代码： public class LockTest { public static void main(String[] args) { new LockTes...
读写锁 ReentrantReadWriteLock
qq_40577921的博客
09-18 186
package com.itjava.interview; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantReadWriteLock; //读写锁 ReentrantReadWr...
lock 读写锁
zengshaotao的专栏
05-09 155
package function.thread;   import java.util.Random; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock;   public class LockTest {   pub...
ReadAndWriteLock(读写锁)
liu_qi_jun的博客
03-16 1069
读写锁：就是读者和写者问题， 原则：写者与写者互斥 读者与写者互斥 读者和读者可以并发 public class ReaderAndWriter { public static void main(String[] args){ ReadAndWriteLockDemo readAndWriteLockDemo = new ReadAndWriteLockDemo()...
Lock重入锁
田培融的博客
05-06 480
前言 在并发编程中有两个核心问题， 一个是互斥另一个是同步。在java sdk并发包中，lock就是解决互斥问题，conditon就是解决同步问题。 Lock lock有三个重要的特性： 能够响应中断： 线程在没有获取锁的时候，进入阻塞状态。我们能够给进入阻塞状态的线程发送信号，重新唤醒它。 支持超时： 在无法获取锁的时候，就等待一定的时间。超时就自动返回。 非阻塞的获取锁：如果无法获取锁就马上...
linux源码之自旋锁(spinlock)/读写自旋锁分析
jkzzxQQQ的博客
11-16 808
本文kernel代码分析基于以下 1.linux-4.14.159 2.64bit代码处理逻辑 我们知道linux内核中存在进程、中断、软中断等相互之间的同步问题，在SMP下这些使用场景会变的尤为复杂，因此linux内核提供了semaphore、spinlock、mutex，rcu、atomic等锁机制来解决这些问题。然而每种锁机制都有不同的实现原理以使用场景，在性能方面也是会存在一定差异，因此对于不同场景下的问题我们能选择最适用的机制才是最好的。 此篇我们重点看下semaphore以及rw_semapho
内核同步机制 - 读写锁 read_lock()/write_lock
墨点梧桐的专栏
03-31 8657
读写锁的基本原理类似自旋锁，它区分读取和写入场景，允许多个读线程同时访问共享数据，而保持读-写和写-写互斥，适用频繁读取数据，而修改相对较少的场景；
Java并发编程之重入锁与读写锁
08-29
Java并发编程之重入锁与读写锁 在 Java 并发编程中，重入锁和读写锁是两个非常重要的概念。重入锁是指支持重进入的锁，也就是说，一个线程可以多次获取同一个锁，而不会被阻塞。读写锁则是维护了一对相关的锁，一...
linux下实现高性能读写锁（read/write lock）
07-07
在Linux内核中，`<pthread_rwlock_t>`结构代表了一个读写锁，提供了`pthread_rwlock_init()`、`pthread_rwlock_destroy()`、`pthread_rwlock_rdlock()`、`pthread_rwlock_wrlock()`和`pthread_rwlock_unlock()`等...
synchronized、Lock、ReadWriteLock（读写锁例子 CacheDemo）
weixin_34253539的博客
06-16 206
2019独角兽企业重金招聘Python工程师标准>>> ...
Lock应用之 读写锁
weixin_34194359的博客
09-24 108
不管是内部锁还是Lock都是独占锁，或者称之排他锁，即读写互斥、写写互斥、读读互斥；与排他锁相对的另一种锁是共享锁，Java的ReadWriteLock是一种共享锁，提供读读共享，但读写和写写仍然互斥。ReadWriteLock最大的特性就是读读共享，比如A线程读锁正在进行读取操作，此时如果B线程请求读锁，那么B线程可以马上顺利获得读锁而无需等待，但此时如果C线程请求写锁，那...
重入锁
E_K_in的博客
01-10 369
只要线程已经获得某个对象的锁或者是获得了某个ReentrantLock锁，那么这个线程在未释放这个锁之前可以多次请求获取并能获得这个锁，因为锁有一个持有计数来跟踪获得锁的次数。比如，某个线程已经获得了一个锁(无论是对象锁还是ReentrantLock锁)，那么他就可以继续请求并能获取到这个锁，其获得X次锁，则这个锁的持有计数就为X,每获取一次锁，持有计数加1，每释放一次锁持有计数减1直到持有计数变
重入锁和读写锁
北辰
09-04 247
一、重入锁和读写锁的引入在Java多线程中，我们知道可以使用synchronized关键字来实现线程间的同步互斥工作，那么其实还有一个更优秀的机制去完成这个“同步互斥”工作，它就是Lock对象，我们主要学习两种锁，重入锁和读写锁。它们具有比synchronized更为强大的功能，并且有嗅探锁定、多路分支等功能。重入锁(重入锁在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，不然会造成锁永远无法释放，其它线程永远进不来的结果。
Lock读写锁实现
weixin_39312465的博客
04-18 496
转载：https://www.jianshu.com/p/9f98299a17a5
谈谈显示锁Lock和Synchronized
qq_32445069的博客
08-06 236
Lock接口和synchronized的比较 Lock是一个接口，而synchronized是java的一个关键字。 Lock适用于以下场景：获取锁可以被中断interrupt，超时获取锁，尝试获取锁trylock，读多写少用读写锁。而synchronized就不是可中断锁。 synchronized和ReentrantLock都是可重入锁。 Lock一定要将同步代码块用try catch包起来...
重入锁Lock 基本用法
qq_44620773的博客
03-16 579
ReentrantLock是一个类可以实现类似synchronized的功能（jvm实现），但更加灵活。 常用方法 可以看到，lock实现了Lock接口，而接口中有这几个方法 lock()方法:上锁 unlock()方法：释放锁 newCondition()：获得Conditon一个监视器 await() 类似Object wait使当前线程进入等待状态 signal() 类似notifay 唤醒进入等待状态的线程 可以选择模式 公平锁和非公平锁 ReentrantRea.
简单说说重入锁与读写锁
weixin_33859231的博客
11-14 217
为什么80%的码农都做不了架构师？>>> ...
Java锁lock源码分析（三）读写锁
mayongzhan_csdn的专栏
06-19 1470
Java锁lock源码分析（三）读写锁 前文Java锁Lock源码分析（一）提过在java的Lock中获取锁就表示AQS的volatile int state =1表示获取到了独占锁，state&amp;amp;amp;amp;amp;gt;1表示当前线程重入锁（获取锁了再次获取到了锁）即大于0就表示获取到了独占锁。 独占就意味着排队，失败，系统吞吐量下降，用户体验下降等等。有些情况不要独占，比如说读与读不互斥,读与写互斥，写与写互...
优化这段代码 #include <iostream> #include <thread> #include <chrono> #include <mutex> #include <semaphore.h> using namespace std; // shared data resource int shared_data = 0; // semaphores for synchronization sem_t mutex, rw_mutex; // number of readers int num_readers = 0; // reader function void reader(int id) { while (true) { // acquire mutex to update the number of readers sem_wait(&mutex); num_readers++; if (num_readers == 1) { // if this is the first reader, acquire the rw_mutex sem_wait(&rw_mutex); } sem_post(&mutex); // read the shared data cout << "Reader " << id << " read shared data: " << shared_data << endl; // release mutex sem_wait(&mutex); num_readers--; if (num_readers == 0) { // if this is the last reader, release the rw_mutex sem_post(&rw_mutex); } sem_post(&mutex); // sleep for a random amount of time this_thread::sleep_for(chrono::milliseconds(rand() % 1000)); } } // writer function void writer(int id) { while (true) { // acquire the rw_mutex sem_wait(&rw_mutex); // write to the shared data shared_data++; cout << "Writer " << id << " wrote to shared data: " << shared_data << endl; // release the rw_mutex sem_post(&rw_mutex); // sleep for a random amount of time this_thread::sleep_for(chrono::milliseconds(rand() % 1000)); } } int main() { // initialize semaphores sem_init(&mutex, 0, 1); sem_init(&rw_mutex, 0, 1); // create reader threads thread readers[8]; for (int i = 0; i < 8; i++) { readers[i] = thread(reader, i); } // create writer threads thread writers[2]; for (int i = 0; i < 2; i++) { writers[i] = thread(writer, i); } // join threads for (int i = 0; i < 8; i++) { readers[i].join(); } for (int i = 0; i < 2; i++) { writers[i].join(); } // destroy semaphores sem_destroy(&mutex); sem_destroy(&rw_mutex); return 0; }
最新发布
05-25
这段代码是使用信号量实现读写锁的示例，但是存在一些需要优化的地方： 1. 不支持优先级反转：在这个实现中，读者和写者都使用了同一个互斥信号量(mutex)来保证对num_readers的互斥访问。但是，如果一个写者在等待互斥信号量(mutex)时，一个读者持续地获取并释放互斥信号量(mutex)，那么这个写者可能会一直等待下去，从而导致优先级反转的问题。为了避免这个问题，可以使用两个互斥锁，一个用于读者，一个用于写者。 2. 读者数量计数器(num_readers)不需要互斥访问：在这个实现中，num_readers是一个全局变量，需要使用互斥信号量(mutex)来保证互斥访问。但是，实际上，这个变量只需要在读者线程中使用，因此不需要使用互斥信号量(mutex)来保护它。 3. 读者线程可能会饿死：在这个实现中，如果有一个写者在等待互斥信号量(rw_mutex)，那么所有的读者都不能访问共享数据，这可能会导致读者线程饿死。为了避免这个问题，可以使用条件变量来实现读者线程的优先级。 下面是优化后的代码： ``` #include <iostream> #include <thread> #include <chrono> #include <mutex> #include <condition_variable> #include <atomic> #include <vector> using namespace std; // shared data resource atomic<int> shared_data(0); // mutexes for synchronization mutex read_mutex, write_mutex; // condition variables for synchronization condition_variable read_cond, write_cond; // number of readers int num_readers = 0; // reader function void reader(int id) { while (true) { // acquire the read_mutex to update the number of readers unique_lock<mutex> lock(read_mutex); num_readers++; if (num_readers == 1) { // if this is the first reader, acquire the write_mutex write_mutex.lock(); } lock.unlock(); // read the shared data cout << "Reader " << id << " read shared data: " << shared_data << endl; // acquire the read_mutex to update the number of readers lock.lock(); num_readers--; if (num_readers == 0) { // if this is the last reader, release the write_mutex write_mutex.unlock(); } lock.unlock(); // sleep for a random amount of time this_thread::sleep_for(chrono::milliseconds(rand() % 1000)); } } // writer function void writer(int id) { while (true) { // acquire the write_mutex write_mutex.lock(); // write to the shared data shared_data++; cout << "Writer " << id << " wrote to shared data: " << shared_data << endl; // release the write_mutex write_mutex.unlock(); // sleep for a random amount of time this_thread::sleep_for(chrono::milliseconds(rand() % 1000)); } } int main() { // create reader threads vector<thread> readers(8); for (int i = 0; i < 8; i++) { readers[i] = thread(reader, i); } // create writer threads vector<thread> writers(2); for (int i = 0; i < 2; i++) { writers[i] = thread(writer, i); } // join threads for (int i = 0; i < 8; i++) { readers[i].join(); } for (int i = 0; i < 2; i++) { writers[i].join(); } return 0; } ``` 在这个优化后的代码中，我们使用了两个互斥锁和两个条件变量来实现读写锁。其中，read_mutex和read_cond用于保护和唤醒读者线程，write_mutex和write_cond用于保护和唤醒写者线程。通过这种方式，我们避免了优先级反转和读者线程饿死的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值