【死磕Java并发】-----J.U.C之读写锁:ReentrantReadWriteLock

【rk3566/3568】Android 11移植gms 【rk3566/3568】Android 11移植gms 1、前言 测试功能时,想去Google play store去下个应用测试,发现通过网页搜索总是下载不到正确的谷歌服务框架;于是就不得不去搞一个内置的gms。 2、移植 1、需要下载Android 11对应的gms的包 opengapps 2、看下文件目录 直接移植core里面的文件,GAPPs Optional按需添加 3、在vendor下创建google目录 ... 阅读详情

此篇博客所有源码均来自JDK 1.8

重入锁ReentrantLock是排他锁,排他锁在同一时刻仅有一个线程可以进行访问,但是在大多数场景下,大部分时间都是提供读服务,而写服务占有的时间较少。然而读服务不存在数据竞争问题,如果一个线程在读时禁止其他线程读势必会导致性能降低。所以就提供了读写锁。

读写锁维护着一对锁,一个读锁和一个写锁。通过分离读锁和写锁,使得并发性比一般的排他锁有了较大的提升:在同一时间可以允许多个读线程同时访问,但是在写线程访问时,所有读线程和写线程都会被阻塞。

作者:大明哥 原文地址:http://cmsblogs.com/?p=2213

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【大明哥】搞基嗨皮。

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【大明哥】搞基嗨皮。

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【大明哥】搞基嗨皮。

读写锁的主要特性:

  1. 公平性:支持公平性和非公平性。

  2. 重入性:支持重入。读写锁最多支持65535个递归写入锁和65535个递归读取锁。

  3. 锁降级:遵循获取写锁、获取读锁在释放写锁的次序,写锁能够降级成为读锁

读写锁ReentrantReadWriteLock实现接口ReadWriteLock,该接口维护了一对相关的锁,一个用于只读操作,另一个用于写入操作。只要没有 writer,读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

public interface ReadWriteLock {
   Lock readLock();
   Lock writeLock();
}

ReadWriteLock定义了两个方法。readLock()返回用于读操作的锁,writeLock()返回用于写操作的锁。ReentrantReadWriteLock定义如下:

    /** 内部类  读锁 */
   private final ReentrantReadWriteLock.ReadLock readerLock;
   /** 内部类  写锁 */
   private final ReentrantReadWriteLock.WriteLock writerLock;

   final Sync sync;

   /** 使用默认(非公平)的排序属性创建一个新的 ReentrantReadWriteLock */
   public ReentrantReadWriteLock() {
       this(false);
   }

   /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
   public ReentrantReadWriteLock(boolean fair) {
       sync = fair ? new FairSync() : new NonfairSync();
       readerLock = new ReadLock(this);
       writerLock = new WriteLock(this);
   }

   /** 返回用于写入操作的锁 */
   public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
   /** 返回用于读取操作的锁 */
   public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

   abstract static class Sync extends AbstractQueuedSynchronizer {
       /**
        * 省略其余源代码
        */
   }
   public static class WriteLock implements Lock, java.io.Serializable{
       /**
        * 省略其余源代码
        */
   }

   public static class ReadLock implements Lock, java.io.Serializable {
       /**
        * 省略其余源代码
        */
   }

ReentrantReadWriteLock与ReentrantLock一样,其锁主体依然是Sync,它的读锁、写锁都是依靠Sync来实现的。所以ReentrantReadWriteLock实际上只有一个锁,只是在获取读取锁和写入锁的方式上不一样而已,它的读写锁其实就是两个类:ReadLock、writeLock,这两个类都是lock实现。

在ReentrantLock中使用一个int类型的state来表示同步状态,该值表示锁被一个线程重复获取的次数。但是读写锁ReentrantReadWriteLock内部维护着两个一对锁,需要用一个变量维护多种状态。所以读写锁采用“按位切割使用”的方式来维护这个变量,将其切分为两部分,高16为表示读,低16为表示写。分割之后,读写锁是如何迅速确定读锁和写锁的状态呢?通过为运算。假如当前同步状态为S,那么写状态等于 S & 0x0000FFFF(将高16位全部抹去),读状态等于S >>> 16(无符号补0右移16位)。代码如下:

        static final int SHARED_SHIFT   = 16;
       static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
       static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
       static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

       static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
       static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

写锁

写锁就是一个支持可重入的排他锁。

写锁的获取

写锁的获取最终会调用tryAcquire(int arg),该方法在内部类Sync中实现:

    protected final boolean tryAcquire(int acquires) {
       Thread current = Thread.currentThread();
       //当前锁个数
       int c = getState();
       //写锁
       int w = exclusiveCount(c);
       if (c != 0) {
           //c != 0 && w == 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的tryAcquire(int arg)大致一样,在判断重入时增加了一项条件:读锁是否存在。因为要确保写锁的操作对读锁是可见的,如果在存在读锁的情况下允许获取写锁,那么那些已经获取读锁的其他线程可能就无法感知当前写线程的操作。因此只有等读锁完全释放后,写锁才能够被当前线程所获取,一旦写锁获取了,所有其他读、写线程均会被阻塞。

写锁的释放

获取了写锁用完了则需要释放,WriteLock提供了unlock()方法释放写锁:

    public void unlock() {
       sync.release(1);
   }

   public final boolean release(int arg) {
       if (tryRelease(arg)) {
           Node h = head;
           if (h != null && h.waitStatus != 0)
               unparkSuccessor(h);
           return true;
       }
       return false;
   }

写锁的释放最终还是会调用AQS的模板方法release(int arg)方法,该方法首先调用tryRelease(int arg)方法尝试释放锁,tryRelease(int arg)方法为读写锁内部类Sync中定义了,如下:

    protected final boolean tryRelease(int releases) {
       //释放的线程不为锁的持有者
       if (!isHeldExclusively())
           throw new IllegalMonitorStateException();
       int nextc = getState() - releases;
       //若写锁的新线程数为0,则将锁的持有者设置为null
       boolean free = exclusiveCount(nextc) == 0;
       if (free)
           setExclusiveOwnerThread(null);
       setState(nextc);
       return free;
   }

写锁释放锁的整个过程和独占锁ReentrantLock相似,每次释放均是减少写状态,当写状态为0时表示 写锁已经完全释放了,从而等待的其他线程可以继续访问读写锁,获取同步状态,同时此次写线程的修改对后续的线程可见。

读锁

读锁为一个可重入的共享锁,它能够被多个线程同时持有,在没有其他写线程访问时,读锁总是或获取成功。

读锁的获取

读锁的获取可以通过ReadLock的lock()方法:

        public void lock() {
           sync.acquireShared(1);
       }

Sync的acquireShared(int arg)定义在AQS中:

    public final void acquireShared(int arg) {
       if (tryAcquireShared(arg) < 0)
           doAcquireShared(arg);
   }

tryAcqurireShared(int arg)尝试获取读同步状态,该方法主要用于获取共享式同步状态,获取成功返回 >= 0的返回结果,否则返回 < 0 的返回结果。

    protected final int tryAcquireShared(int unused) {
       //当前线程
       Thread current = Thread.currentThread();
       int c = getState();
       //exclusiveCount(c)计算写锁
       //如果存在写锁,且锁的持有者不是当前线程,直接返回-1
       //存在锁降级问题,后续阐述
       if (exclusiveCount(c) != 0 &&
               getExclusiveOwnerThread() != current)
           return -1;
       //读锁
       int r = sharedCount(c);

       /*
        * readerShouldBlock():读锁是否需要等待(公平锁原则)
        * r < MAX_COUNT:持有线程小于最大数(65535)
        * compareAndSetState(c, c + SHARED_UNIT):设置读取锁状态
        */
       if (!readerShouldBlock() &&
               r < MAX_COUNT &&
               compareAndSetState(c, c + SHARED_UNIT)) {
           /*
            * holdCount部分后面讲解
            */
           if (r == 0) {
               firstReader = current;
               firstReaderHoldCount = 1;
           } else if (firstReader == current) {
               firstReaderHoldCount++;
           } else {
               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. 因为存在锁降级情况,如果存在写锁且锁的持有者不是当前线程则直接返回失败,否则继续

  2. 依据公平性原则,判断读锁是否需要阻塞,读锁持有线程数小于最大值(65535),且设置锁状态成功,执行以下代码(对于HoldCounter下面再阐述),并返回1。如果不满足改条件,执行fullTryAcquireShared()。

    final int fullTryAcquireShared(Thread current) {
       HoldCounter rh = null;
       for (;;) {
           int c = getState();
           //锁降级
           if (exclusiveCount(c) != 0) {
               if (getExclusiveOwnerThread() != current)
                   return -1;
           }
           //读锁需要阻塞
           else if (readerShouldBlock()) {
               //列头为当前线程
               if (firstReader == current) {
               }
               //HoldCounter后面讲解
               else {
                   if (rh == null) {
                       rh = cachedHoldCounter;
                       if (rh == null || rh.tid != getThreadId(current)) {
                           rh = readHolds.get();
                           if (rh.count == 0)
                               readHolds.remove();
                       }
                   }
                   if (rh.count == 0)
                       return -1;
               }
           }
           //读锁超出最大范围
           if (sharedCount(c) == MAX_COUNT)
               throw new Error("Maximum lock count exceeded");
           //CAS设置读锁成功
           if (compareAndSetState(c, c + SHARED_UNIT)) {
               //如果是第1次获取“读取锁”,则更新firstReader和firstReaderHoldCount
               if (sharedCount(c) == 0) {
                   firstReader = current;
                   firstReaderHoldCount = 1;
               }
               //如果想要获取锁的线程(current)是第1个获取锁(firstReader)的线程,则将firstReaderHoldCount+1
               else if (firstReader == current) {
                   firstReaderHoldCount++;
               } else {
                   if (rh == null)
                       rh = cachedHoldCounter;
                   if (rh == null || rh.tid != getThreadId(current))
                       rh = readHolds.get();
                   else if (rh.count == 0)
                       readHolds.set(rh);
                   //更新线程的获取“读取锁”的共享计数
                   rh.count++;
                   cachedHoldCounter = rh; // cache for release
               }
               return 1;
           }
       }
   }

fullTryAcquireShared(Thread current)会根据“是否需要阻塞等待”,“读取锁的共享计数是否超过限制”等等进行处理。如果不需要阻塞等待,并且锁的共享计数没有超过限制,则通过CAS尝试获取锁,并返回1

读锁的释放

与写锁相同,读锁也提供了unlock()释放读锁:

        public void unlock() {
           sync.releaseShared(1);
       }

unlcok()方法内部使用Sync的releaseShared(int arg)方法,该方法定义在AQS中:

    public final boolean releaseShared(int arg) {
       if (tryReleaseShared(arg)) {
           doReleaseShared();
           return true;
       }
       return false;
   }

调用tryReleaseShared(int arg)尝试释放读锁,该方法定义在读写锁的Sync内部类中:

    protected final boolean tryReleaseShared(int unused) {
       Thread current = Thread.currentThread();
       //如果想要释放锁的线程为第一个获取锁的线程
       if (firstReader == current) {
           //仅获取了一次,则需要将firstReader 设置null,否则 firstReaderHoldCount - 1
           if (firstReaderHoldCount == 1)
               firstReader = null;
           else
               firstReaderHoldCount--;
       }
       //获取rh对象,并更新“当前线程获取锁的信息”
       else {
           HoldCounter rh = cachedHoldCounter;
           if (rh == null || rh.tid != getThreadId(current))
               rh = readHolds.get();
           int count = rh.count;
           if (count <= 1) {
               readHolds.remove();
               if (count <= 0)
                   throw unmatchedUnlockException();
           }
           --rh.count;
       }
       //CAS更新同步状态
       for (;;) {
           int c = getState();
           int nextc = c - SHARED_UNIT;
           if (compareAndSetState(c, nextc))
               return nextc == 0;
       }
   }

HoldCounter

在读锁获取锁和释放锁的过程中,我们一直都可以看到一个变量rh (HoldCounter ),该变量在读锁中扮演着非常重要的作用。

我们了解读锁的内在机制其实就是一个共享锁,为了更好理解HoldCounter ,我们暂且认为它不是一个锁的概率,而相当于一个计数器。一次共享锁的操作就相当于在该计数器的操作。获取共享锁,则该计数器 + 1,释放共享锁,该计数器 - 1。只有当线程获取共享锁后才能对共享锁进行释放、重入操作。所以HoldCounter的作用就是当前线程持有共享锁的数量,这个数量必须要与线程绑定在一起,否则操作其他线程锁就会抛出异常。我们先看HoldCounter的定义:

        static final class HoldCounter {
           int count = 0;
           final long tid = getThreadId(Thread.currentThread());
       }

HoldCounter 定义非常简单,就是一个计数器count 和线程 id tid 两个变量。按照这个意思我们看到HoldCounter 是需要和某给线程进行绑定了,我们知道如果要将一个对象和线程绑定仅仅有tid是不够的,而且从上面的代码我们可以看到HoldCounter 仅仅只是记录了tid,根本起不到绑定线程的作用。那么怎么实现呢?答案是ThreadLocal,定义如下:

        static final class ThreadLocalHoldCounter
           extends ThreadLocal<HoldCounter> {
           public HoldCounter initialValue() {
               return new HoldCounter();
           }
       }

通过上面代码HoldCounter就可以与线程进行绑定了。故而,HoldCounter应该就是绑定线程上的一个计数器,而ThradLocalHoldCounter则是线程绑定的ThreadLocal。从上面我们可以看到ThreadLocal将HoldCounter绑定到当前线程上,同时HoldCounter也持有线程Id,这样在释放锁的时候才能知道ReadWriteLock里面缓存的上一个读取线程(cachedHoldCounter)是否是当前线程。这样做的好处是可以减少ThreadLocal.get()的次数,因为这也是一个耗时操作。需要说明的是这样HoldCounter绑定线程id而不绑定线程对象的原因是避免HoldCounter和ThreadLocal互相绑定而GC难以释放它们(尽管GC能够智能的发现这种引用而回收它们,但是这需要一定的代价),所以其实这样做只是为了帮助GC快速回收对象而已。

看到这里我们明白了HoldCounter作用了,我们在看一个获取读锁的代码段:

                else if (firstReader == current) {
                   firstReaderHoldCount++;
               } else {
                   if (rh == null)
                       rh = cachedHoldCounter;
                   if (rh == null || rh.tid != getThreadId(current))
                       rh = readHolds.get();
                   else if (rh.count == 0)
                       readHolds.set(rh);
                   rh.count++;
                   cachedHoldCounter = rh; // cache for release
               }

这段代码涉及了几个变量:firstReader 、firstReaderHoldCount、cachedHoldCounter 。我们先理清楚这几个变量:

private transient Thread firstReader = null;
private transient int firstReaderHoldCount;
private transient HoldCounter cachedHoldCounter;

firstReader 看名字就明白了为第一个获取读锁的线程,firstReaderHoldCount为第一个获取读锁的重入数,cachedHoldCounter为HoldCounter的缓存。

理清楚上面所有的变量了,HoldCounter也明白了,我们就来给上面那段代码标明注释,如下:

    //如果获取读锁的线程为第一次获取读锁的线程,则firstReaderHoldCount重入数 + 1
   else if (firstReader == current) {
       firstReaderHoldCount++;
   } else {
       //非firstReader计数
       if (rh == null)
           rh = cachedHoldCounter;
       //rh == null 或者 rh.tid != current.getId(),需要获取rh
       if (rh == null || rh.tid != getThreadId(current))
           rh = readHolds.get();
           //加入到readHolds中
       else if (rh.count == 0)
           readHolds.set(rh);
       //计数+1
       rh.count++;
       cachedHoldCounter = rh; // cache for release
   }

这里解释下为何要引入firstRead、firstReaderHoldCount。这是为了一个效率问题,firstReader是不会放入到readHolds中的,如果读锁仅有一个的情况下就会避免查找readHolds。

锁降级

上开篇是LZ就阐述了读写锁有一个特性就是锁降级,锁降级就意味着写锁是可以降级为读锁的,但是需要遵循先获取写锁、获取读锁在释放写锁的次序。注意如果当前线程先获取写锁,然后释放写锁,再获取读锁这个过程不能称之为锁降级,锁降级一定要遵循那个次序。

在获取读锁的方法tryAcquireShared(int unused)中,有一段代码就是来判读锁降级的:

        int c = getState();
       //exclusiveCount(c)计算写锁
       //如果存在写锁,且锁的持有者不是当前线程,直接返回-1
       //存在锁降级问题,后续阐述
       if (exclusiveCount(c) != 0 &&
               getExclusiveOwnerThread() != current)
           return -1;
       //读锁
       int r = sharedCount(c);

锁降级中读锁的获取释放为必要?肯定是必要的。试想,假如当前线程A不获取读锁而是直接释放了写锁,这个时候另外一个线程B获取了写锁,那么这个线程B对数据的修改是不会对当前线程A可见的。如果获取了读锁,则线程B在获取写锁过程中判断如果有读锁还没有释放则会被阻塞,只有当前线程A释放读锁后,线程B才会获取写锁成功。

推荐阅读

因为里面很多地方涉及到了AQS部分,推荐阅读如下部分:

  1. 【死磕Java并发】-----J.U.C之AQS:AQS简介

  2. 【死磕Java并发】-----J.U.C之AQS:CLH同步队列

  3. 【死磕Java并发】-----J.U.C之AQS:同步状态的获取与释放

  4. 【死磕Java并发】-----J.U.C之AQS:阻塞和唤醒线程

参考资料

  1. Doug Lea:《Java并发编程实战》

  2. 方腾飞:《Java并发编程的艺术》

  3. 【Java并发编程实战】—–“J.U.C”:ReentrantReadWriteLock

  4. Java多线程(十)之ReentrantReadWriteLock深入分析

逆强化学习:从专家示范中学习策略 逆强化学习(Inverse Reinforcement Learning,简称IRL)是强化学习(Reinforcement Learning,简称RL)的一个子领域,它的目标是从专家的行为中学习策略。在传统的强化学习中,智能体通过与环境交互,根据奖励信号来学习一个策略。而在逆强化学习中,我们没有直接的奖励信号,而是通过观察专家的行为来推断出奖励函数,从而学习到一个与专家类似的策略。逆强化学习作为强化学习的一个重要子领域,在许多实际应用场景中都取得了显著的成功。 阅读详情

相关推荐

深入解析Panfrost驱动:Mali-GPU开源驱动的架构与实现

本文深入解析了Panfrost驱动作为Mali-GPU开源驱动的架构与实现。从诞生背景到硬件架构演进,详细介绍了Panfrost如何突破ARM闭源策略,实现全栈支持。文章还探讨了驱动设计中的关键技术挑战与性能优化策略,为开发者提供了实用的编译部署指南和性能调优方法。

weixin_30790841的博客 554

手写一个读写锁

java中的读写锁实现

lhz121的博客 478

避坑指南:Zephyr RTOS与nRF Connect SDK环境搭建常见错误及解决方案

本文详细解析了Zephyr RTOS与nRF Connect SDK环境搭建过程中的常见错误及解决方案,涵盖网络问题、代理设置、SEGGER Embedded Studio配置、分支切换等关键环节。针对开发者实际遇到的痛点问题,提供了一系列实用技巧和深度排错方法,帮助高效完成NCS开发环境部署。

weixin_28685287的博客 172

高并发学习笔记(七)

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_33908217的博客 313

海天注塑机弘讯控制器Modbus数据采集实战指南

工业设备数据采集是MES系统、设备监控和工艺追溯的基础,其中注塑机联网是车间数字化的关键环节。Modbus协议作为工业通信的事实标准,以简单、开放、低成本的优势,成为海天注塑机弘讯控制器对外提供数据的主要方式。理解控制器型号与通信参数、捋清寄存器点位表与字节序规则,是稳定采集的前提。通过RS485串口或以太网轮询,可以实时获取产量、温度、压力、报警等关键数据,进而支撑OEE统计、质量追溯与异常监控。本文基于实战项目,以海天注塑机弘讯控制器为例,梳理从接线、参数配置到点位验证的完整流程,为现场工程师提供一套可

weixin_28733777的博客 909

弹簧管压力表设计报告

精密机械课程设计 弹簧管压力表设计报告 2020年5月1日 目 录 第一章 设计任务概述... 3 1.1 课程设计目的... 3 1.2 设计任务... 3 1.3 技术指标... 3 第二章 压力表概述... 4 2.1 机械式压力表的组成部分... 4 2.2 工作原理... 4 第三章 压力表设计... 5 3.1 弹簧管参数设计... 5 3.2 曲柄滑块机构设计... ...

weixin_42163746的博客 6453

ReentrantReadWriterLock源码(state设计、读写锁、共享锁、独占锁及锁降级)

ReentrantReadWriterLock 读写锁类图(截图来源https://blog.csdn.net/wangbo199308/article/details/108688148) state的设计 读写锁将变量state切分成两个部分,高16位表示读,低16位表示写 源码中将4字节(32位)的int数据类型state,通过SHARED_SHIFT(16)划分读和写; 每次读锁增加的单元,SHARED_UNIT = (1 << SHARED_SHIFT) 也即0x000100

weixin_43843104的博客 450

FTViewSE利用VB脚本制作简易日报表

罗克韦尔SE用VB做的简单的报表

z0800656的博客 3025

java-锁

java-锁

S1124654的博客 243

通用、可复用的 AI Skill 开发基本流程

-----name:唯一标识符(建议用领域-功能格式):自然语言描述触发条件(AI 依赖此判断是否激活)tags(可选):便于分类和搜索version:支持后续迭代步骤输出物1. 定范围触发场景描述2. 写元数据name3. 填内容结构化 Markdown 文件4. 做验证可运行 + 符合规范5. 去集成放入对应 IDE 目录6. 持续维护跟进框架更新通过这套流程,你不仅可以开发(Hooks 最佳实践)(原生 WebGL 优化)(Pandas/Numpy 高效写法)

lpfasd123的博客 735

使用Qt Creator自带的Qt Designer构造UI界面流程总结

在本文中,我们将总结使用Qt Creator自带的Qt Designer构造UI界面的流程。在对话框中,您可以选择一个控件的信号,然后将其连接到另一个控件的槽。例如,您可以将按钮的点击信号连接到一个槽函数,以响应按钮的点击事件。右键单击窗口设计器中的空白区域,选择适当的布局管理器,如水平布局、垂直布局或网格布局。在Qt Designer中,您可以使用各种预定义的UI控件来设计应用程序的界面。现在,您可以在应用程序的源代码中使用生成的UI界面。在您的源文件中,包含相应的头文件,然后创建一个UI界面的实例。

cl6789的博客 1395

Java面试题(十一) 揭秘Java大陆的神秘家族“锁”之一族(四) 手写读写锁

一. 独占(写)锁与共享(读)锁 独占(写)锁与共享(读)锁也可以叫读写锁 简单理解就是,我写的时候不能被其他线程干扰,需要独占线程资源, 我读的时候可以共享并发进行。 二. 实现读写锁 模拟缓存来实现读写锁 手写一个缓存需要三点: 1.存值 put(key, value) 2.取值 get(key) 3.清空缓存 clear class Mycache { //缓存空间 private volatile Map<String, Object> map = new

w_x_A__l__l的博客 399

2025资源从哪里来!

研究网络通信中的安全问题,如VLAN划分、路由协议(静态、动态如OSPF、BGP)、NAT转换、AAA认证、访问控制列表(ACL)等。‌Wi-Fi安全设置‌、‌密码破解原理‌(仅用于合法测试或教育目的)、‌常见Web安全问题‌如SQL注入、XSS跨站脚本攻击等的防范措施。在这个网站你可以找到你对应的专业-对应的路线-对应的资源-对应的百度网盘里面全是免费的资源------------------惊喜不?‌防火墙配置与策略‌、‌入侵检测与防御系统(IDS/IPS)‌、‌端口扫描与漏洞扫描技术‌等。

qq_56248592的博客 1908

【死磕Java并发】——J.U.C之读写锁ReentrantReadWriteLock

概述 重入锁ReentrantLock是一中排它锁,它是指同一个线程在获取到锁之后还能再次获取这个锁,背后实际增加的是这个锁的同步状态State. 读写锁ReentrantReadWriteLock则是内部维护了一对锁——读锁和写锁。写锁是排他的,读锁是可共享的。通过分离读锁和写锁,使得并发性比一般的排他锁有了较大的提升:在同一时间可以允许多个读线程同时访问,但是在写线程访问时,所有读线程和写

1Q84emo的博客 362

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

死磕Java并发:J.U.C之读写锁:ReentrantReadWriteLock

作者:chenssy来源:http://cmsblogs.com/?p=2213重入锁ReentrantLock是排他锁,排他锁在同一时刻仅有一个线程可以进行访问,但是在...

程序猿DD 652

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

【死磕Java并发】----- 死磕 Java 并发精品合集

【死磕 Java 并发】系列是 LZ 在 2017 年写的第一个死磕系列,一直没有做一个合集,这篇博客则是将整个系列做一个概览。 先来一个总览图: 【高清图,请关注“Java技术驿站”公众号,回复:脑图JUC】 【死磕Java并发】—–深入分析synchronized 的实现原理 synchronized 可以保证方法或者代码块在运行时,同一时刻只有一个方法可以进入到临界区,同...

chenssy 的技术博客 1万+

死磕 Java 并发

作者 :大明哥 博客 :http://cmsblogs.com/?cat=151 目录 : 《【死磕 Java 并发】—– 深入分析 synchronized 的实现原理》 《【死磕 Java 并发】—– 深入分析 volatile 的实现原理》 《【死磕 Java 并发】—– Java 内存模型之 happens-before》 《【死磕 Java 并发】—– Java 内存模...

scofen的博客 787

Java 并发 (8) -- ReentrantReadWriteLock 类

文章目录1. 简介2. 精讲1. 读写锁的概念1. ReentrantReadWriteLock 的特性2. 读写锁的具体实现1. 读锁状态的设计2. 锁的获取1. 写锁的获取2. 读锁的获取3. 总结3. 锁的释放1. 写锁的释放2. 读锁的释放3. 总结3. ReentrantReadWriteLock 中的其他方法1. getOwner()2. getReadLockCount()3. ge...

南京的博客 320

juc-locks锁框架 ReentrantReadWriteLock

explain in detail significant point (重要点) 重入锁 ReentrantLock 是排他锁,排他锁在同一时刻仅有一个线程可以进行访问 是一种读写锁,它是ReadWriteLock接口的直接实现,该类在内部实现了具体独占锁特点的写锁,以及具有共享锁特点的读锁,和ReentrantLock一样,ReentrantReadWriteLock类也是通过定义内部类实现...

chris 174

Java 并发源码合集

【死磕Java并发】—– 深入分析synchronized的实现原理【死磕Java并发】—– 深入分析volatile的实现原理【死磕Java并发】—– Java内存模型之happens-before【死磕Java并发】—– Java内存模型之重排序【死磕Java并发】—– Java内存模型之分析volatile【死磕Java并发】—– Java内存模型之从JMM角度分析DCL【死磕Java并发】

芋道源码 1017

Java 并发精品合集

【死磕Java并发】—–深入分析synchronized 的实现原理 synchronized 可以保证方法或者代码块在运行时,同一时刻只有一个方法可以进入到临界区,同时它还可以保证共享变量的内存可见性。深入分析 synchronized 的内在实现机制,锁优化、锁升级过程。 【死磕Java并发】—–深入分析volatile的实现原理 volatile 可以保证线程可见性且提供了一定的有序性...

ZCC的专栏 436

Java 面试宝典:volatile 的使用场景有哪些?

大家好,我是大明哥,一个专注「」系列创作的硬核程序员。。有全网最优质的系列文章、Java 全栈技术文档以及大厂完整面经。

chenssy 的技术博客 1683

芋道源码的周八(2018.02.04)

1. 推荐文章2. 公众号文章3. 知识星球文章1. 推荐文章笔者在地铁有阅读公众号技术文章的习惯。给时间一点时间,给努力一点努力。《从一次Snowflake异常说起》《深入分析java线程池的实现原理》《努力常态化》《java设计模式【全】》《闲话MySQL备份、安全、SQL规范与系统规划》《10个月时间,CMO如何挽救这家破产的电商巨头?》2. 公众号文章公众号:芋道源码,纯源码解析公众号。《

芋道源码 416

读写锁简要源码分析

读写锁源码简要分析(适合新手简要了解阅读)

qq_39249568的博客 222
上一篇: Re:从零开始的Spring Security OAuth2(二)
下一篇: 分布式事务 TCC-Transaction 源码解析 —— 事务存储器
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值