JUC-how to use ReadWriteLock

最新推荐文章于 2022-06-24 16:38:40 发布

原创最新推荐文章于 2022-06-24 16:38:40 发布 · 219 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

java 同时被 2 个专栏收录

89 篇文章

订阅专栏

后端

18 篇文章

订阅专栏

本文探讨了在并发编程中如何通过ReentrantReadWriteLock实现读多写少原则，分析了不同操作场景下的锁策略，并举例展示了如何使用ReadWriteLock确保读写互斥。

as we know.JUC play a important role in in concurrent progammering,the demand for read more to write less.we should use ReadWriteLock,instead of Lock.

first and foremost.let we analyze the requirement of read more to write less.

operation1	operation2	result
read	read	coexist
read	write	mutex
write	write	mutex

secondly,choose appropriate lock to implement requirement.

package JavaAdvanced;

import com.sun.corba.se.spi.ior.ObjectKey;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author 韦海涛
 * @version 1.0
 * @date 4/2/2021 1:44 PM
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。
 * 但是有一个线程想去写共享资源来，就不应该再有其他线程进行读或者写
 * 小总结：
 *  读-读-共存
 *  读-写-不共存
 *  写-写-不共存
 *
 *  写操作：原子+独占:整个过程必须是一个完整的统一体，中间不允许被打断
 *
 *
 */

class MyCache{
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(String key,Object value){
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在写入");
            TimeUnit.SECONDS.sleep(3);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"\t写入完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }

    }

    public void get(String key){
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在读取");
            TimeUnit.SECONDS.sleep(3);
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName()+"\t读取完成"+result);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.readLock().unlock();
        }
    }
}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.put(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

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

refer to the above code,we can konw,if write locked.the next write lock cannot achieve,and read lock also cannot achieve until current wirte unlocked.