开发者社区> 张起灵-小哥> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Java——多线程高并发系列之ReadWriteLock读写锁

简介: Java——多线程高并发系列之ReadWriteLock读写锁
+关注继续查看

写在前面


synchronized内部锁与 ReentrantLock 锁都是独占锁(排它锁),同一时间只允许一个线程执行同步代码块,可以保证线程的安全性,但是执行效率低。


ReentrantReadWriteLock读写锁是一种改进的排他锁,也可以称作共享/排他锁。允许多个线程同时读取共享数据,但是一次只允许一个线程对共享数据进行更新。


读写锁通过读锁与写锁来完成读写操作,线程在读取共享数据前必须先持有读锁,该读锁可以同时被多个线程持有,即它是共享的。线程在修改共享数据前必须先持有写锁,写锁是排他的,一个线程持有写锁时其他线程无法获得相应的锁。


读锁只是在读线程之间共享,任何一个线程持有读锁时,其他线程都无法获得写锁,保证线程在读取数据期间没有其他线程对数据进行更新,使得读线程能够读到数据的最新值,保证在读数据期间共享变量不被修改。

获得条件

排他性

作用

读锁

写锁未被任意线程持有

对读线程是共享的,对写线程是排他的

允许多个读线程可以同时读取共享数据,保证在读共享数据时,没有其他线程对共享数据进行修改

写锁

该写锁未被其他线程持有,并且相应的读锁也未被其他线程持有

对读线程或者写线程都是排他的

保证写线程以独占的方式修改共享数据

读写锁允许读读共享,读写互斥,写写互斥。

java.util.concurrent.locks包中定义了ReadWriteLock接口,该接口中定义了 readLock()返回读锁,定义 writeLock()方法返回写锁,该接口的实现类是ReentrantReadWriteLock

注意readLock()writeLock()方法返回的锁对象是同一个锁的两个不同的角色,不是分别获得两个不同的锁。ReadWriteLock 接口实例可以充当两个角色。

Demo1(读读共享)


ReadWriteLock读写锁可以实现多个线程同时读取共享数据,即读读共享,可以提高程序的读取数据的效率。

package com.szh.lock.readwrite;
 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 *  ReadWriteLock 读写锁的读读共享,允许多个线程同时获得读锁
 */
public class Test01 {
 
    static class Service {
        //定义读写锁
        ReadWriteLock rwLock=new ReentrantReadWriteLock();
        //定义方法读取数据
        public void read() {
            try {
                rwLock.readLock().lock(); //获得读锁
                System.out.println(Thread.currentThread().getName() + "获得读锁,开始读取数据的时间:"
                                + System.currentTimeMillis());
                TimeUnit.MILLISECONDS.sleep(1000 * 3); //模拟读取数据用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                rwLock.readLock().unlock(); //释放读锁
            }
        }
    }
 
    public static void main(String[] args) {
        Service s=new Service();
 
        //创建 5 个线程,调用 read() 方法
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    s.read(); //在线程中调用 read()读取数据
                }
            }).start();
        }
 
        //运行程序后, 这几个线程几乎可以同时获得锁读, 执行 lock() 后面的代码
    }
}

可以看到这五个子线程都可以顺利的获得读锁来读取数据。 即读读共享。

image

Demo2(写写互斥)


package com.szh.lock.readwrite;
 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 演示 ReadWriteLock 读写锁的写写互斥
 * ReadWriteLock 的 writeLock() 写锁是互斥的, 只允许有一个线程持有
 */
public class Test02 {
 
    static class Service {
        //定义读写锁
        ReadWriteLock rwLock=new ReentrantReadWriteLock();
        //定义方法修改数据
        public void write() {
            try {
                rwLock.writeLock().lock(); //申请获得写锁
                System.out.println(Thread.currentThread().getName() + " 获得写锁,开始修改数据的时间:"
                                + System.currentTimeMillis());
                TimeUnit.MILLISECONDS.sleep(1000 * 3); //模拟修改数据的用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " 修改数据完毕时的时间== "
                                + System.currentTimeMillis());
                rwLock.writeLock().unlock(); //释放写锁
            }
        }
    }
 
    public static void main(String[] args) {
        Service s=new Service();
 
        //创建3个线程修改数据
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    s.write();
                }
            }).start();
        }
 
        //从执行结果来看, 同一时间只有一个线程获得写锁
    }
}

可以看到,当Thread-0获得了写锁之后,在它修改完数据,释放写锁的这段时间内,其他线程是无法进来获得写锁的。其他线程要想获得写锁,必须等待其他线程修改完数据释放了写锁才可以。即写写互斥。

image

Demo3(读写互斥)


package com.szh.lock.readwrite;
 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 演示 ReadWriteLock 读写锁的读写互斥
 * 一个线程获得读锁时,写线程等待; 一个线程获得写锁时,其他线程等待
 */
public class Test03 {
 
    static class Service {
        //定义读写锁
        ReadWriteLock rwLock=new ReentrantReadWriteLock();
 
        //定义方法读取数据
        public void read() {
            try {
                rwLock.readLock().lock(); //申请获得读锁
                System.out.println(Thread.currentThread().getName() + "获得读锁,开始读取数据的时间:"
                        + System.currentTimeMillis());
                Thread.sleep(1000 * 3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " 释放了读锁...");
                rwLock.readLock().unlock(); //释放读锁
            }
        }
 
        //定义方法修改数据
        public void write() {
            try {
                rwLock.writeLock().lock(); //申请获得写锁
                System.out.println(Thread.currentThread().getName() + " 获得写锁,开始修改数据的时间:"
                        + System.currentTimeMillis());
                TimeUnit.MILLISECONDS.sleep(1000 * 3); //模拟修改数据的用时
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " 修改数据完毕时的时间== "
                        + System.currentTimeMillis());
                rwLock.writeLock().unlock(); //释放写锁
            }
        }
    }
 
    public static void main(String[] args) {
        Service s=new Service();
 
        //定义一个线程读数据
        new Thread(new Runnable() {
            @Override
            public void run() {
                s.read();
            }
        }).start();
 
        //定义一个线程写数据
        new Thread(new Runnable() {
            @Override
            public void run() {
                s.write();
            }
        }).start();
    }
}

可以看到,当Thread-0获得了读锁之后,在它读取完数据之前,其他线程是无法进来获得写锁的(但是可以获得读锁),也就是保证了当前获得读锁的线程读取到的是最新的数据(未被其他线程修改的数据)。而当Thread-0读取完数据释放了读锁之后,Thread-1这个时候才可以获得写锁进行数据的修改,而当一个线程获得写锁的时候,其他任何线程都无法获得读锁和写锁。

image

Demo4(三个线程同时向map集合中存/取数据)


import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 *
 */
class MyCache {
    //创建map集合
    private volatile Map<String,Object> map = new HashMap<>();
 
    //创建读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 
    //存数据
    public void put(String key,Object value) {
        //添加写锁
        readWriteLock.writeLock().lock();
 
        try {
            System.out.println(Thread.currentThread().getName() + " 正在写操作 " + key);
            //暂停一会
            TimeUnit.MILLISECONDS.sleep(300);
            //存数据
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + " 写完了 " + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放写锁
            readWriteLock.writeLock().unlock();
        }
    }
 
    //取数据
    public Object get(String key) {
        //添加读锁
        readWriteLock.readLock().lock();
 
        Object obj = null;
        try {
            System.out.println(Thread.currentThread().getName() + " 正在读操作 " + key);
            //暂停一会
            TimeUnit.MILLISECONDS.sleep(300);
            //取数据
            obj = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 读完了 " + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            readWriteLock.readLock().unlock();
        }
        return obj;
    }
}
 
public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyCache myCache = new MyCache();
 
        //创建3个线程向map集合中存数据
        for (int i = 1; i <= 3; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.put(num + "",num + "");
            },String.valueOf(i)).start();
        }
 
        TimeUnit.MILLISECONDS.sleep(300);
 
        //创建3个线程从map集合中取数据
        for (int i = 1; i <= 3; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.get(num + "");
            },String.valueOf(i)).start();
        }
    }
}

从程序运行结果中可以看到:首先进行了向map集合中存数据的过程,在线程2没有写完之前,线程3是无法进行写操作的,也即 写写互斥(要想获取某个数据的写锁,就要确保该数据的读锁、写锁都没有被其他线程所持有)。后面的线程3、线程1也是同样的道理。


而写操作全部完成之后,下面进行的是从map集合中读数据的过程,可以看到线程321同时都在进行读操作,也都同时读取完成了,这就说明多个线程之间是可以同时读,也即 读读共享(要想获取某个数据的读锁,就要确保该数据的写锁没有被其他线程所持有就可以了)。

image

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
线程 - Java 多线程编程(上)
线程 - Java 多线程编程(上)
69 0
线程 - Java 多线程编程(下)
线程 - Java 多线程编程(下)
25 0
Java多线程那些事,对Java并发编程2w余字的总结,超详细(从入门到完全掌握)
Java多线程那些事,对Java并发编程2w余字的总结,超详细(从入门到完全掌握)
80 0
java多线程中的死锁、活锁、饥饿、无锁都是什么鬼?
死锁、活锁、饥饿是关于多线程是否活跃出现的运行阻塞障碍问题,如果线程出现了这三种情况,即线程不再活跃,不能再正常地执行下去了。
70 0
五分钟带你玩转多线程(一)java多线程基础知识简介
线程概念 进程:是一个执行中的程序,如打开网易云音乐,网易云音乐就是一个进程 线程:是进程的组成,一个进程包含多个线程,是jvm最小调度单元。如网易云音乐听歌是一个线程,评价是一个线程。
52 0
Java的并发编程中的多线程问题到底是怎么回事儿?
原创: Hollis 在我之前的一篇《再有人问你Java内存模型是什么,就把这篇文章发给他。》文章中,介绍了Java内存模型,通过这篇文章,大家应该都知道了Java内存模型的概念以及作用,这篇文章中谈到,在Java并发编程中,通常会遇到三个问题,即原子性问题、一致性问题和有序性问题。
1060 0
【Java学习笔记之六】java三种循环(for,while,do......while)的使用方法及区别
第一种:for循环  循环结构for语句的格式:         for(初始化表达式;条件表达式;循环后的操作表达式) {      循环体;       } eg: 1 class Dome_For2{ 2 public static void main(String[] args) { 3 //System.
1013 0
833
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载