java-15种锁之独占锁(写)/共享锁(读)/互斥锁

1、Java读写锁理论

写锁（独占锁）：是指该锁一次只能被一个线程锁持有。对ReentrantLock和Sychronized而言都是独占锁。

读锁（共享锁）：是指该锁可被多个线程持有。对ReentrantReadWriteLock而言，其读锁是共享锁，其写锁是独占锁。读锁的共享性可保证并发读是非常高效的，读写、写读、写写的过程都是互斥的。

2、Java读写锁代码验证

Demo One：代码没有加读写锁的情况

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.ReentrantReadWriteLock;



/**

 * 多个线程同时读一个资源类的时候是没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。

 * 但是，如果有一个线程想去写共享资源，就不应该有其他线程去读或者写

 * <p>

 * 总结：

 * 读-读共存

 * 读-写不共存

 * 写-读不共存

 * 写-写不共存

 *

 * 写操作：原子+独占，整个过程必须是一个完整体，中间不能有任何中断

 */

public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {

        MyCache myCache = new MyCache();

        for (int i = 0; i < 5; i++) {

            int finalI = i;

            new Thread(() -> {

                myCache.put(finalI + "", finalI + "");

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

        }



        for (int i = 0; i < 5; i++) {

            int finalI = i;

            new Thread(() -> {

                myCache.get(finalI + "");

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

        }



    }

}



class MyCache {

    private volatile Map<String, String> map = new HashMap<>();



    //private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();



    public void put(String key, String value) {

        System.out.println(Thread.currentThread().getName() + "正在写......");

        try {

            TimeUnit.MILLISECONDS.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        map.put(key, value);

        System.out.println(Thread.currentThread().getName() + "写已经完成");

    }



    public String get(String key) {

        System.out.println(Thread.currentThread().getName() + "正在读......");

        try {

            TimeUnit.MILLISECONDS.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        String value = map.get(key);

        System.out.println(Thread.currentThread().getName() + "读已经完成");

        return value;

    }

}

程序执行结果如下：0号线程还没有写完就4号线程写操作、3号线程写操作、2号线程写操作等等打断，所以没有加读写锁的并发操作并不安全。

Demo Two：代码加了读写锁的情况下

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.ReentrantReadWriteLock;



/**

 * 多个线程同时读一个资源类的时候是没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。

 * 但是，如果有一个线程想去写共享资源，就不应该有其他线程去读或者写

 * <p>

 * 总结：

 * 读-读共存

 * 读-写不共存

 * 写-读不共存

 * 写-写不共存

 *

 * 写操作：原子+独占，整个过程必须是一个完整体，中间不能有任何中断

 */

public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {

        MyCache myCache = new MyCache();

        for (int i = 0; i < 5; i++) {

            int finalI = i;

            new Thread(() -> {

                myCache.put(finalI + "", finalI + "");

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

        }



        for (int i = 0; i < 5; i++) {

            int finalI = i;

            new Thread(() -> {

                myCache.get(finalI + "");

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

        }



    }

}



class MyCache {

    private volatile Map<String, String> map = new HashMap<>();



    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();



    public void put(String key, String value) {

        rwLock.writeLock().lock();

        System.out.println(Thread.currentThread().getName() + "正在写......");

        try {

            TimeUnit.MILLISECONDS.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        map.put(key, value);

        System.out.println(Thread.currentThread().getName() + "写已经完成");

        rwLock.writeLock().unlock();

    }



    public String get(String key) {

        rwLock.readLock().lock();

        System.out.println(Thread.currentThread().getName() + "正在读......");

        try {

            TimeUnit.MILLISECONDS.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        String value = map.get(key);

        System.out.println(Thread.currentThread().getName() + "读已经完成");

        rwLock.readLock().unlock();

        return value;

    }

}

程序执行结果如下：0号线程写操作完全执行完成之后才会去执行1、3、2、4号线程的写操作，读操作就不需要保证原子+独占，可以随机读取共享资源，保证读的并发性能。