ReentrantReadWriteLock使用场景思考及验证

已于 2022-03-08 10:24:33 修改
阅读量2.5k 收藏 8
点赞数 5
分类专栏： 并发 Spring 性能 文章标签： java 压力测试 spring boot 锁
于 2021-11-21 21:34:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WX10301075WX/article/details/121459894
版权
并发 同时被 3 个专栏收录
18 篇文章 1 订阅
订阅专栏
Spring
8 篇文章 3 订阅
订阅专栏
性能
7 篇文章 0 订阅
订阅专栏

ReentrantReadWriteLock使用场景思考


最近一直在琢磨 ReentrantReadWriteLock的使用场景是什么，后来突然就想明白了，其实就是 读读并发、读写互斥、写写互斥而已。如果一个对象并发读的场景大于并发写的场景，那就可以使用 ReentrantReadWriteLock来达到保证线程安全的前提下提高并发效率。首先，我们先了解一下Doug Lea为我们准备的两个demo。

CachedData

一个缓存对象的使用案例，缓存对象在使用时，一般并发读的场景远远大于并发写的场景，所以缓存对象是非常适合使用ReentrantReadWriteLock来做控制的

class CachedData {
   //被缓存的具体对象
   Object data;
   //当前对象是否可用，使用volatile来保证可见性
   volatile boolean cacheValid;
   //今天的主角，ReentrantReadWriteLock 
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   //业务处理逻辑
   void processCachedData() {
     //要读取数据时，先加读锁，如果加成功，说明此时没有人在并发写
     rwl.readLock().lock();
     //拿到读锁后，判断当前对象是否有效
     if (!cacheValid) {
       // Must release read lock before acquiring write lock
       //这里的处理非常经典，当你持有读锁之后，不能直接获取写锁，
       //因为写锁是独占锁，如果直接获取写锁，那代码就在这里死锁了
       //所以必须要先释放读锁，然后手动获取写锁
       rwl.readLock().unlock();
       rwl.writeLock().lock();
       try {
         // Recheck state because another thread might have
         // acquired write lock and changed state before we did.
         //经典处理之二，在独占锁内部要处理数据时，一定要做二次校验
         //因为可能同时有多个线程全都在获取写锁，
         //当时线程1释放写锁之后，线程2马上获取到写锁，此时如果不做二次校验那可能就导致某些操作做了多次
         if (!cacheValid) {
           data = ...
           //当缓存对象更新成功后，重置标记为true
           cacheValid = true;
         }
         // Downgrade by acquiring read lock before releasing write lock
         //这里有一个非常神奇的锁降级操作，所谓降级是说当你持有写锁后，可以再次获取读锁
         //这里之所以要获取一次写锁是为了防止当前线程释放写锁之后，其他线程马上获取到写锁，改变缓存对象
         //因为读写互斥，所以有了这个读锁之后，在读锁释放之前，别的线程是无法修改缓存对象的
         rwl.readLock().lock();
       } finally {
         rwl.writeLock().unlock(); // Unlock write, still hold read
       }
     }

     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }

RWDictionary

Doug Lea给出的第二个demo，一个并发容器的demo。并发容器我们一般都是直接使用ConcurrentHashMap的，但是我们可以使用非并发安全的容器+ReentrantReadWriteLock来组合出一个并发容器。如果这个并发容器的读的频率>写的频率，那这个效率还是不错的

class RWDictionary {
   //原来非并发安全的容器
   private final Map<String, Data> m = new TreeMap<String, Data>();
   private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
   private final Lock r = rwl.readLock();
   private final Lock w = rwl.writeLock();

   public Data get(String key) {
     //读数据，上读锁
     r.lock();
     try { return m.get(key); }
     finally { r.unlock(); }
   }
   public String[] allKeys() {
     //读数据，上读锁
     r.lock();
     try { return m.keySet().toArray(); }
     finally { r.unlock(); }
   }
   public Data put(String key, Data value) {
     //写数据，上写锁
     w.lock();
     try { return m.put(key, value); }
     finally { w.unlock(); }
   }
   public void clear() {
     //写数据，上写锁
     w.lock();
     try { m.clear(); }
     finally { w.unlock(); }
   }
 }

思考和验证

这两个demo其实在我目前的开发中基本上哪个也用不上，但是我能不能通过ReentrantReadWriteLock手写一个简单的缓存容器呢？缓存容器本质上非常接近RWDictionary 但是需要提供增量缓存的方法。

  1. 我们先定义一个缓存容器的接口：

    /**
 * 缓存容器
 *
 * @param <T>
 * @author wangxing
 */
public interface ICacheContainer<T> {

    /**
     * 获取对象
     *
     * @param key
     * @return
     */
    T get(String key, Function<String, T> mappingFunction);

    /**
     * 移除对象
     *
     * @param key
     * @return
     */
    T remove(String key);
}

  2. 使用ReentrantReadWriteLock+HashMap提供一个实现

    /**
 * 缓存容器
 *
 * @param <T>
 * @author wangxing
 */
public class ReadWriteLockCacheContainer<T> implements ICacheContainer<T> {

    private final HashMap<String, T> cacheMap = new HashMap<>();
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    @Override
    public T get(String key, Function<String, T> mappingFunction) {
        //读之前先上读锁
        readWriteLock.readLock().lock();
        try {
            //判断map中是否已经有了
            boolean has = cacheMap.containsKey(key);
            if (!has) {
                //没有数据，需要写，读锁释放
                readWriteLock.readLock().unlock();
                //加写锁，必须先释放读锁，不然这里直接GG
                readWriteLock.writeLock().lock();
                try {
                    //并发二重校验
                    has = cacheMap.containsKey(key);
                    if (!has) {
                        T data = mappingFunction.apply(key);
                        cacheMap.put(key, data);
                    }
                } finally {
                    //这里要先降级，给自己占一个坑，防止当前线程释放写锁之后，
                    //马上有其他线程获取到写锁，并对对象修改
                    readWriteLock.readLock().lock();
                    //finally里面释放写锁
                    readWriteLock.writeLock().unlock();
                }
            }
            //考虑到并发，这里一定要从HashMap中读，并且一定要加读锁
            return cacheMap.get(key);
        } finally {
            //finally里面释放写锁
            readWriteLock.readLock().unlock();
        }
    }

    @Override
    public T remove(String key) {
        readWriteLock.writeLock().lock();
        try {
            return cacheMap.remove(key);
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
}

  3. 为了比较效率，我还提供了ConcurrentHashMap和synchronized+HashMap的两个实现

    /**
 * 缓存容器
 *
 * @param <T>
 * @author wangxing
 */
public class ConcurrentHashMapCacheContainer<T> implements ICacheContainer<T> {

    private final ConcurrentHashMap<String, T> cacheMap = new ConcurrentHashMap<>();

    @Override
    public T get(String key, Function<String, T> mappingFunction) {
        return cacheMap.computeIfAbsent(key, mappingFunction);
    }

    @Override
    public T remove(String key) {
        return cacheMap.remove(key);
    }
}

    /**
 * 缓存容器
 *
 * @param <T>
 * @author wangxing
 */
public class HashMapCacheContainer<T> implements ICacheContainer<T> {

    private final HashMap<String, T> cacheMap = new HashMap<>();

    @Override
    public synchronized T get(String key, Function<String, T> mappingFunction) {
        return cacheMap.computeIfAbsent(key, mappingFunction);
    }

    @Override
    public synchronized T remove(String key) {
        return cacheMap.remove(key);
    }
}

  4. 附一下StudentService，StudentDAO就展示，就是JdbcTemplate查库而已了

    @Service
public class StudentService {

    private static final Logger logger = LoggerFactory.getLogger(StudentService.class);

    @Autowired
    private ConcurrentHashMapCacheContainer<StudentDO> concurrentHashMapCache;

    @Autowired
    private HashMapCacheContainer<StudentDO> hashMapCache;

    @Autowired
    private ReadWriteLockCacheContainer<StudentDO> readWriteLockCache;

    @Autowired
    private ReadWriteLockCacheContainer2<StudentDO> readWriteLockCache2;

    @Autowired
    private StudentDAO studentDAO;


    public StudentDO getByIdFromConcurrentHashMapCache(String id) {
        Assert.notNull(id, "id is null");
        return concurrentHashMapCache.get(id, studentDAO::getById);
    }

    public StudentDO getByIdFromHashMapCache(String id) {
        Assert.notNull(id, "id is null");
        return hashMapCache.get(id, studentDAO::getById);
    }

    public StudentDO getByIdFromReadWriteLockCache(String id) {
        Assert.notNull(id, "id is null");
        return readWriteLockCache.get(id, studentDAO::getById);
    }

    public StudentDO getByIdFromReadWriteLockCache2(String id) {
        Assert.notNull(id, "id is null");
        return readWriteLockCache2.get(id, studentDAO::getById);
    }
}

  5. 接下来验证一下正确性

  6. 然后我们测试一下效率，使用jmh测试，这样显得更专业，先上测试代码：

    @BenchmarkMode({Mode.AverageTime})
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(time = 1, iterations = 1)
@Measurement(iterations = 3)
@Threads(10)
@Fork(1)
@State(Scope.Benchmark)
public class CacheTest {

    StudentService studentService;
    ConfigurableApplicationContext applicationContext;

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(CacheTest.class.getSimpleName())
                .result("CacheTest.json")
                .resultFormat(ResultFormatType.JSON).build();
        new Runner(opt).run();
    }

    @Setup
    public void init() {
    	//jmh与SpringBoot结合，只需要在@Setup中初始化一下SpringBoot的context以及需要用到的bean就可以了
        applicationContext = SpringApplication.run(Main.class);
        studentService = applicationContext.getBean(StudentService.class);
    }

    @TearDown
    public void down() {
	    //跑完了记得关SpringBoot
        applicationContext.close();
    }

    public String getRandomId() {
        Random random = new Random();
        return String.format("%03d", random.nextInt(9) + 1);
    }

    @Benchmark
    public StudentDO getByIdFromHashMapCache() {
        return studentService.getByIdFromHashMapCache(getRandomId());
    }

    @Benchmark
    public StudentDO getByIdFromConcurrentHashMapCache() {
        return studentService.getByIdFromConcurrentHashMapCache(getRandomId());
    }

    @Benchmark
    public StudentDO getByIdFromReadWriteLockCache() {
        return studentService.getByIdFromReadWriteLockCache(getRandomId());
    }
}

    因为缓存的加载在预热时就跑完了，所以测试的结果是面向缓存数据读取的，结果如下：

    # JMH version: 1.33
# VM version: JDK 1.8.0_261, Java HotSpot(TM) 64-Bit Server VM, 25.261-b12
# VM invoker: C:\Program Files\Java\jdk1.8.0_261\jre\bin\java.exe
# VM options: -javaagent:D:\jetbrains\IntelliJ IDEA 2021.2\lib\idea_rt.jar=62663:D:\jetbrains\IntelliJ IDEA 2021.2\bin -Dfile.encoding=UTF-8
# Blackhole mode: full + dont-inline hint (default, use -Djmh.blackhole.autoDetect=true to auto-detect)
# Warmup: 1 iterations, 1 s each
# Measurement: 3 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 10 threads, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache

# Run progress: 0.00% complete, ETA 00:01:33
# Fork: 1 of 1
# Warmup Iteration   1: 
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.6)

21:18:23.031 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.s.b.SpringApplication - Starting application using Java 1.8.0_261 on DESKTOP-5R7UHQH with PID 14256 (started by w123x in D:\code\myCode)
21:18:23.031 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.s.b.SpringApplication - No active profile set, falling back to default profiles: default
21:18:24.402 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.s.b.w.e.t.TomcatWebServer - Tomcat initialized with port(s): 8080 (http)
21:18:24.402 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.a.c.h.Http11NioProtocol - Initializing ProtocolHandler ["http-nio-8080"]
21:18:24.402 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.a.c.c.StandardService - Starting service [Tomcat]
21:18:24.402 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.a.c.c.StandardEngine - Starting Servlet engine: [Apache Tomcat/9.0.46]
21:18:24.496 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.a.c.c.C.[.[.[/] - Initializing Spring embedded WebApplicationContext
21:18:24.496 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.s.b.w.s.c.ServletWebServerApplicationContext - Root WebApplicationContext: initialization completed in 1387 ms
21:18:24.920 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.a.c.h.Http11NioProtocol - Starting ProtocolHandler ["http-nio-8080"]
21:18:24.936 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.s.b.w.e.t.TomcatWebServer - Tomcat started on port(s): 8080 (http) with context path ''
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  o.s.b.SpringApplication - Started application in 2.467 seconds (JVM running for 3.165)
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-8] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [007]
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-6] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [002]
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-2] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [008]
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-1] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [006]
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-10] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [004]
21:18:24.952 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-9] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [009]
21:18:24.967 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-8] INFO  c.z.h.HikariDataSource - HikariPool-1 - Starting...
21:18:25.123 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-8] INFO  c.z.h.HikariDataSource - HikariPool-1 - Start completed.
21:18:25.139 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-8] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [003]
21:18:25.139 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-4] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [005]
21:18:25.139 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-1] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [001]
4181.528 ±(99.9%) 459.784 ns/op
Iteration   1: 1431.993 ±(99.9%) 32.759 ns/op
Iteration   2: 1419.286 ±(99.9%) 5.837 ns/op
Iteration   3: 21:18:56.344 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-2] INFO  c.z.h.HikariDataSource - HikariPool-1 - Shutdown initiated...
21:18:56.346 [com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache-jmh-worker-2] INFO  c.z.h.HikariDataSource - HikariPool-1 - Shutdown completed.
1392.772 ±(99.9%) 16.996 ns/op


Result "com.example.juc.CacheTest.getByIdFromConcurrentHashMapCache":
  1414.684 ±(99.9%) 365.081 ns/op [Average]
  (min, avg, max) = (1392.772, 1414.684, 1431.993), stdev = 20.011
  CI (99.9%): [1049.603, 1779.764] (assumes normal distribution)


# JMH version: 1.33
# VM version: JDK 1.8.0_261, Java HotSpot(TM) 64-Bit Server VM, 25.261-b12
# VM invoker: C:\Program Files\Java\jdk1.8.0_261\jre\bin\java.exe
# VM options: -javaagent:D:\jetbrains\IntelliJ IDEA 2021.2\lib\idea_rt.jar=62663:D:\jetbrains\IntelliJ IDEA 2021.2\bin -Dfile.encoding=UTF-8
# Blackhole mode: full + dont-inline hint (default, use -Djmh.blackhole.autoDetect=true to auto-detect)
# Warmup: 1 iterations, 1 s each
# Measurement: 3 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 10 threads, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: com.example.juc.CacheTest.getByIdFromHashMapCache

# Run progress: 33.33% complete, ETA 00:01:12
# Fork: 1 of 1
# Warmup Iteration   1: 
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.6)

21:18:58.782 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.s.b.SpringApplication - Starting application using Java 1.8.0_261 on DESKTOP-5R7UHQH with PID 1464 (started by w123x in D:\code\myCode)
21:18:58.782 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.s.b.SpringApplication - No active profile set, falling back to default profiles: default
21:18:59.977 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.s.b.w.e.t.TomcatWebServer - Tomcat initialized with port(s): 8080 (http)
21:18:59.977 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.a.c.h.Http11NioProtocol - Initializing ProtocolHandler ["http-nio-8080"]
21:18:59.977 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.a.c.c.StandardService - Starting service [Tomcat]
21:18:59.977 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.a.c.c.StandardEngine - Starting Servlet engine: [Apache Tomcat/9.0.46]
21:19:00.071 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.a.c.c.C.[.[.[/] - Initializing Spring embedded WebApplicationContext
21:19:00.071 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.s.b.w.s.c.ServletWebServerApplicationContext - Root WebApplicationContext: initialization completed in 1227 ms
21:19:00.496 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.a.c.h.Http11NioProtocol - Starting ProtocolHandler ["http-nio-8080"]
21:19:00.512 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.s.b.w.e.t.TomcatWebServer - Tomcat started on port(s): 8080 (http) with context path ''
21:19:00.512 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  o.s.b.SpringApplication - Started application in 2.181 seconds (JVM running for 2.68)
21:19:00.528 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-8] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [004]
21:19:00.528 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-8] INFO  c.z.h.HikariDataSource - HikariPool-1 - Starting...
21:19:00.684 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-8] INFO  c.z.h.HikariDataSource - HikariPool-1 - Start completed.
21:19:00.700 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-2] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [003]
21:19:00.700 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-10] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [008]
21:19:00.700 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-4] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [001]
21:19:00.715 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-4] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [006]
21:19:00.715 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-6] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [009]
21:19:00.715 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-9] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [002]
21:19:00.715 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-7] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [007]
21:19:00.715 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-9] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [005]
6498.052 ±(99.9%) 695.987 ns/op
Iteration   1: 3199.530 ±(99.9%) 41.182 ns/op
Iteration   2: 3273.503 ±(99.9%) 45.500 ns/op
Iteration   3: 21:19:31.878 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-1] INFO  c.z.h.HikariDataSource - HikariPool-1 - Shutdown initiated...
21:19:31.885 [com.example.juc.CacheTest.getByIdFromHashMapCache-jmh-worker-1] INFO  c.z.h.HikariDataSource - HikariPool-1 - Shutdown completed.
3249.716 ±(99.9%) 48.810 ns/op


Result "com.example.juc.CacheTest.getByIdFromHashMapCache":
  3240.916 ±(99.9%) 688.945 ns/op [Average]
  (min, avg, max) = (3199.530, 3240.916, 3273.503), stdev = 37.763
  CI (99.9%): [2551.972, 3929.861] (assumes normal distribution)


# JMH version: 1.33
# VM version: JDK 1.8.0_261, Java HotSpot(TM) 64-Bit Server VM, 25.261-b12
# VM invoker: C:\Program Files\Java\jdk1.8.0_261\jre\bin\java.exe
# VM options: -javaagent:D:\jetbrains\IntelliJ IDEA 2021.2\lib\idea_rt.jar=62663:D:\jetbrains\IntelliJ IDEA 2021.2\bin -Dfile.encoding=UTF-8
# Blackhole mode: full + dont-inline hint (default, use -Djmh.blackhole.autoDetect=true to auto-detect)
# Warmup: 1 iterations, 1 s each
# Measurement: 3 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 10 threads, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: com.example.juc.CacheTest.getByIdFromReadWriteLockCache

# Run progress: 66.67% complete, ETA 00:00:35
# Fork: 1 of 1
# Warmup Iteration   1: 
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.6)

21:19:34.335 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.s.b.SpringApplication - Starting application using Java 1.8.0_261 on DESKTOP-5R7UHQH with PID 2572 (started by w123x in D:\code\myCode)
21:19:34.335 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.s.b.SpringApplication - No active profile set, falling back to default profiles: default
21:19:35.546 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.s.b.w.e.t.TomcatWebServer - Tomcat initialized with port(s): 8080 (http)
21:19:35.546 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.a.c.h.Http11NioProtocol - Initializing ProtocolHandler ["http-nio-8080"]
21:19:35.546 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.a.c.c.StandardService - Starting service [Tomcat]
21:19:35.546 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.a.c.c.StandardEngine - Starting Servlet engine: [Apache Tomcat/9.0.46]
21:19:35.624 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.a.c.c.C.[.[.[/] - Initializing Spring embedded WebApplicationContext
21:19:35.624 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.s.b.w.s.c.ServletWebServerApplicationContext - Root WebApplicationContext: initialization completed in 1211 ms
21:19:36.081 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.a.c.h.Http11NioProtocol - Starting ProtocolHandler ["http-nio-8080"]
21:19:36.097 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.s.b.w.e.t.TomcatWebServer - Tomcat started on port(s): 8080 (http) with context path ''
21:19:36.112 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-10] INFO  o.s.b.SpringApplication - Started application in 2.224 seconds (JVM running for 2.748)
21:19:36.112 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-2] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [005]
21:19:36.128 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-2] INFO  c.z.h.HikariDataSource - HikariPool-1 - Starting...
21:19:36.268 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-2] INFO  c.z.h.HikariDataSource - HikariPool-1 - Start completed.
21:19:36.284 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-9] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [001]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-1] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [002]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-1] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [003]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-4] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [009]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-7] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [007]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-7] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [004]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-3] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [008]
21:19:36.300 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-3] INFO  c.e.j.c.StudentDAO - execute query [select id,name,mathScore,languageScore,englishScore from student where id=?] [006]
3981.655 ±(99.9%) 588.654 ns/op
Iteration   1: 2042.329 ±(99.9%) 29.002 ns/op
Iteration   2: 2053.372 ±(99.9%) 29.416 ns/op
Iteration   3: 21:20:07.548 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-7] INFO  c.z.h.HikariDataSource - HikariPool-1 - Shutdown initiated...
21:20:07.555 [com.example.juc.CacheTest.getByIdFromReadWriteLockCache-jmh-worker-7] INFO  c.z.h.HikariDataSource - HikariPool-1 - Shutdown completed.
2069.973 ±(99.9%) 25.902 ns/op


Result "com.example.juc.CacheTest.getByIdFromReadWriteLockCache":
  2055.225 ±(99.9%) 253.855 ns/op [Average]
  (min, avg, max) = (2042.329, 2055.225, 2069.973), stdev = 13.915
  CI (99.9%): [1801.370, 2309.079] (assumes normal distribution)


# Run complete. Total time: 00:01:47

REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
experiments, perform baseline and negative tests that provide experimental control, make sure
the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
Do not assume the numbers tell you what you want them to tell.

Benchmark                                    Mode  Cnt     Score     Error  Units
CacheTest.getByIdFromConcurrentHashMapCache  avgt    3  1414.684 ± 365.081  ns/op
CacheTest.getByIdFromHashMapCache            avgt    3  3240.916 ± 688.945  ns/op
CacheTest.getByIdFromReadWriteLockCache      avgt    3  2055.225 ± 253.855  ns/op

    从结果上能看出来，ConcurrentHashMap还是快的，但是我们通过ReentrantReadWriteLock实现的缓存在数据读取上也没慢太多，同时，因为是自己实现的，所以有更高的可扩展性

skyline_wx
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
ReentrantReadWriteLock：深入解析与最佳实践
小阳同学的博客
01-19 1167
在并发编程中，锁是用于控制多个线程对共享资源的访问的一种机制。读写锁是其中一种特殊的锁，它分为读锁和写锁两部分，允许多个线程同时获得读锁，而写锁是互斥锁，不允许多个线程同时获得。Java并发包提供了ReentrantReadWriteLock类作为读写锁的实现。本文将对ReentrantReadWriteLock进行详细分析，并探讨其最佳实践。ReentrantReadWriteLock是一种重要的并发工具，它可以提高多读少写的场景的并发性能。
ReentrantReadWriteLock之读写锁判断
weixin_30332705的博客
09-30 696
一. 读写锁是怎么实现的？ 　　继承AQS，然后通过将AQS中的state转化为二进制，分为高16位和低16位来区分。高16位表示读状态，低16位为写状态。 二. 解析表示方式（高低16位） 　　假设此时state是数值S 　　a.写锁 　　　　在判断写锁时，通过 K=S&0X0000FFFF， 将高位全部抹掉，此时只有低16位，然后判断K是否大于0，K>0，表示...
Java 读写锁 ReadWriteLock 原理与应用场景详解
萌兔兔MMQ！！
09-30 3723
主要是为了保证数据的可见性，如果当前线程不获取读锁而直接释放写锁，假设此刻另一个线程获取的写锁，并修改了数据，那么当前线程就步伐感知到线程T的数据更新，如果当前线程遵循锁降级的步骤，那么线程T将会被阻塞，直到当前线程使数据并释放读锁之后，线程T才能获取写锁进行数据更新。或者锁状态不为零，而写锁的状态也不为0，但是获取写锁的线程不是当前线程，则当前线程不能获取写锁。公平性：读写锁支持非公平和公平的锁获取方式，非公平锁的吞吐量优于公平锁的吞吐量，默认构造的是非公平锁。
ReentrantReadWriteLock 使用示例
小灰灰的博客
09-23 384
ReadWriteLock 使用示例 1.使用场景 前两天同事发给我一个工具类，封装了调用第三方接口的方法。 第三方接口调用需要带上访问凭据accessToken ，需要先调用login接口传入username password获取该token. 他在方法内部，每个业务请求之前都login获取新的accessToken ，我认为这样做不优雅，因为accessToken 不是一次性的，是有有效时间...
python之线程池
weixin_50140040的博客
11-20 278
http://c.biancheng.net/view/2627.html
ReentrantReadWriteLock读写锁的使用
myCoffeeTime
11-26 930
ReentrantReadWriteLock读写锁的使用          ReentrantReadWriteLock里一共有两把锁，一把读锁，一把写锁； 读写锁使用场景：适合读次数多写次数少的场景。 1、线程进入读锁和写锁的前提条件： 线程进入读锁的前提条件：          没有其他写锁； 没有写的请求或者有写的请求，但是和持有锁得线程是同一个线程。 线程进入写锁的前提条件：
Java多线程 ReentrantReadWriteLock原理及实例详解
08-25
主要介绍了Java多线程 ReentrantReadWriteLock原理及实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
ReadWriteLock接口及其实现ReentrantReadWriteLock方法
08-30
其次，ReentrantReadWriteLock 可以提供公平锁和非公平锁两种锁类型，满足不同的应用场景。最后，ReentrantReadWriteLock 的实现方式简单、灵活，易于维护和扩展。 ReadWriteLock 接口及其实现 ...
ReentrantReadWriteLock 源码解析
01-21
　针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁 类图如下： 说明：如上图所示Sync为ReentrantReadWriteLock...
ReentrantReadWriteLock.xmind
04-08
ReentrantReadWriteLock 读写锁除了保证写操作对读操作可见性以及并发行提升外，简化了读写交互场景开发
60.Lock-ReentranLock-ReentrantReadWriteLock.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
并发库应用之五 & ReadWriteLock场景应用
weixin_30920513的博客
02-27 222
　　Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。 　　读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，我们只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个...
01入门及简单应用-ReentrantReadWriteLock原理-AQS-并发编程(Java)
gaogzhen的博客
12-12 505
01入门及简单应用-ReentrantReadWriteLock原理-AQS-并发编程(Java)
关于ReentrantReadWriteLock两个问题及解决心得(转)
行吟阁
05-19 6353
<br />前些时候写了一个简单的cache类，实现了一些基本的功能：get和update操作。由于使用在多线程的环境中，为了提高效率，我采用了ReadWriteLock，毕竟我这里缓存更新少，取数据多。特别是一些timeout为-1的数据（持久数据），添加进去之后基本不会被更新。这种场景用读写锁是自然而然的事情（由于时间比较紧，也没去花时间了解有没有什么更适合的锁）。<br />    缓存实现中<br />        public V get(K key){<br />            rea
测试ReentrantReadWriteLock的相应特性
weixin_42163781的博客
04-01 163
ReentrantReadWriteLock 所在的包是java.util.concurrent.locks.ReentrantReadWriteLock，读写锁所包含的锁有俩中，一种是与读操作相关的锁也被称为共享锁，一种是与写操作相关的锁也被称为排它锁，在没有写入操作时，读锁之间互不排斥，多个线程都可以获取读锁，当在涉及写入操作时，只有一个线程可以获取写锁进行写入操作，也就是说，当在读取时，多个...
ReentrantReadWriteLock特性测试
weixin_33884611的博客
12-21 73
2019独角兽企业重金招聘Python工程师标准>>> ...
ReentrantReadWriteLock优势及使用
泊川
06-17 1146
1)优势 多线程读取并修改一个资源时，我们过去通常使用 synchronized同步锁，这个是有性能损失的，很多情况下：资源对象总是被大量并发读取，偶尔有一个线程进行修改，也就是说：以读为主，修改不是 很频繁，那么我们在JDK5.0中用ReentrantReadWriteLock就获得比synchronized更高并发性能，高并发性能是我使用 JDK5.0主要目的，而不是annotation和泛
【Java并发编程】ReentrantReadWriteLock源码及实现原理分析
热门推荐
fxkcsdn的博客
08-30 1万+
继承关系 ReadLock和WriteLock是ReentrantReadWriteLock的两个内部类，Lock的上锁和释放锁都是通过AQS来实现的。 AQS定义了独占模式的acquire()和release()方法，共享模式的acquireShared()和releaseShared()方法.还定义了抽象方法tryAcquire()、tryAcquiredShared()、tryR...
Lock、ReentrantLock、ReentrantReadWriteLock原理及应用深入解析
徐刚的技术博客
07-24 6050
Lock相比于synchronized具有更强大的功能，本文详细介绍lock、ReentrantLock和ReentrantReadWriteLock的原理与实用场景
ReentrantReadWriteLock使用的实际场景
最新发布
06-03
ReentrantReadWriteLock 是 Java 并发包中的一种锁机制，它可以同时支持多个读线程访问共享资源，但只允许一个写线程访问共享资源。它的主要实际场景有以下几个： 1. 缓存 在缓存的实现中，读操作通常比写操作更频繁。使用 ReentrantReadWriteLock 可以让多个线程同时读取缓存，提高读取缓存的效率，同时在更新缓存时只允许一个线程进行写操作，保证数据的一致性。 2. 数据库操作 在数据库操作中，读操作通常比写操作更频繁，使用 ReentrantReadWriteLock 可以让多个线程同时读取数据库，提高读取数据库的效率，同时在更新数据库时只允许一个线程进行写操作，保证数据的一致性。 3. 文件操作 在文件操作中，读操作通常比写操作更频繁，使用 ReentrantReadWriteLock 可以让多个线程同时读取文件，提高读取文件的效率，同时在更新文件时只允许一个线程进行写操作，保证数据的一致性。 4. 集合操作 在集合操作中，读操作通常比写操作更频繁，使用 ReentrantReadWriteLock 可以让多个线程同时读取集合，提高读取集合的效率，同时在更新集合时只允许一个线程进行写操作，保证数据的一致性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值