java 读写锁 ReentrantReadWriteLock

ReentrantReadWriteLock 是一个可重入的读写锁,它相较于ReentrantLock提高了没有写线程持有锁时读线程的并发量

这是没有加入任何锁时的程序

class cache{
    
    void put(){

        try {
            System.out.println(Thread.currentThread().getName()+"\t 开始写操作");
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName()+"\t 写操作完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
        }
    }

    void get(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t 开始读操作");
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName()+"\t 读操作完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
        }
    }
}
public class ReadWriteLockDemo {

    public static void main(String[] args) {
        cache cache=new cache();
        for (int i = 0; i <10 ; i++) {
            final int temp=i;
            if(temp%2==0){
                new Thread(()->{
                    cache.put();

                },"A"+i).start();
            }else {
                new Thread(()->{
                    cache.get();

                },"B"+i).start();
            }

        }

    }
}

A0	 开始写操作  **写操作未完成被读操作中断**
B1	 开始读操作
A2	 开始写操作
B3	 开始读操作
A4	 开始写操作
B5	 开始读操作
A6	 开始写操作
B7	 开始读操作
A8	 开始写操作
B9	 开始读操作
B1	 读操作完成
A0	 写操作完成
A2	 写操作完成
B3	 读操作完成
A4	 写操作完成
B5	 读操作完成
A6	 写操作完成
B7	 读操作完成
A8	 写操作完成
B9	 读操作完成

可以发现写操作被读操作中断,没有保证原子性
下面是加入读写锁 ReentrantReadWriteLock

class cache{
    HashMap map=new HashMap();
    ReentrantReadWriteLock rwlock=new ReentrantReadWriteLock();

    void put(){
        rwlock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t 开始写操作");
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName()+"\t 写操作完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwlock.writeLock().unlock();
        }
    }

    void get(){
        rwlock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t 开始读操作");
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName()+"\t 读操作完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwlock.readLock().unlock();
        }
    }
}

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        cache cache=new cache();
        for (int i = 0; i <10 ; i++) {
            final int temp=i;
            if(temp%2==0){
                new Thread(()->{
                    cache.put();

                },"A"+i).start();
            }else {
                new Thread(()->{
                    cache.get();

                },"B"+i).start();
            }

        }

    }
}

A0	 开始写操作
A0	 写操作完成
B1	 开始读操作
B1	 读操作完成
A2	 开始写操作
A2	 写操作完成
B3	 开始读操作
B3	 读操作完成
A4	 开始写操作
A4	 写操作完成
B5	 开始读操作
B5	 读操作完成
A6	 开始写操作
A6	 写操作完成
A8	 开始写操作
A8	 写操作完成
B7	 开始读操作
B9	 开始读操作
B7	 读操作完成
B9	 读操作完成

可以发现如果写线程完成之前没有其他线程中断

总结
读 读 可以共存
读 写 不可以共存
写 写 不可以共存