独占锁(写锁)/共享锁(读锁)/互斥锁

最新推荐文章于 2022-03-19 23:13:13 发布

L_J_X03

最新推荐文章于 2022-03-19 23:13:13 发布

阅读量291

点赞数

分类专栏： lock 文章标签：独占锁共享锁互斥锁 ReadWriteLock

本文链接：https://blog.csdn.net/L_J_X03/article/details/116273233

版权

lock 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

这篇博客探讨了Java中ReentrantReadWriteLock的使用，它在多线程环境下提供了读写锁机制。通过示例代码展示了如何在读写操作中应用读锁和写锁，以实现高效并发读取和独占写入。同时强调了volatile关键字在保证缓存可见性方面的作用。

摘要由CSDN通过智能技术生成

独占锁：指该锁一次只能被一个线程所持有，ReentrantLock和Synchronized都是独占锁
共享锁：指该锁可被多个线程所持有
对ReentrantReadWriteLock的读锁的共享锁，其写锁是独占锁。
读锁的共享锁可保证并发读是非常高效的，读写，写读，写写时互斥的
在这里插入图片描述

在这里插入图片描述
注意：
在高内聚低耦合的情况下，都是线程操作资源类

ReentrantLock与ReentrantReadWriteLock都是能进行加锁，但是ReentrantLock只能允许一个线程进行操作，ReentrantReadWriteLock在读的时候能运行多个线程进行操作，但是在写的时候只允许一个线程进行操作。

读写锁控制对多线程的操作

往缓存里面的东西，要用volatile修饰保证可见性

package com.example.demo.Test;

import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockTest {

    public static void main(String[] args) {
        Mycache mycache = new Mycache();
        for(int i = 0 ; i < 10 ; i++){
            final int sa = i ;
            new Thread(()->{
                mycache.put(sa+"",sa+"");
            },String.valueOf(i)).start();
        }

        for(int i = 0 ; i < 5 ; i++){
            final int sa = i ;
            new Thread(()->{
                mycache.get(sa+"");
            },String.valueOf(i)).start();
        }
    }

    static class Mycache{  //线程调用的资源类
        //创建一个map存储数据，并且保证他的一致性和原子性
        /**
         * 往缓存里面的东西要用 volatile 保证可见性
         */
        static volatile HashMap<String,String> map = new HashMap<String,String>();
        static ReentrantReadWriteLock reentrantReadWriteLock = new  ReentrantReadWriteLock();
        /**
         * 添加数据
         * @param key
         * @param value
         */
        public  void put(String key,String value){
            ReentrantReadWriteLock.WriteLock lock = reentrantReadWriteLock.writeLock();
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"正在写入数据"+value);
                try {TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
                map.put(key,value);
                System.out.println(Thread.currentThread().getName()+"已写入数据"+value);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                //解锁放在finally里面
                lock.unlock();
            }

        }

        /**
         * 获取数据
         * @param key
         */
        public  void get(String key){
            ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
            readLock.lock();
            try{
                System.out.println(Thread.currentThread().getName()+"正在获取数据");
                try {TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(Thread.currentThread().getName()+"读取的数据为："+map.get(key));
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                readLock.unlock();
            }
        }

    }
}