独占锁（写锁）/ 共享锁（读锁）/ 互斥锁

独占锁（写锁）/ 共享锁（读锁）/ 互斥锁

独占锁：指该锁一次只能被一个线程所持有。

• ReentrantLock、Synchronized都是独占锁，并且是可重入锁（递归锁）
  共享锁：指该锁可以被多个线程持有。
• ReentrantReadWriteLock的读锁是共享锁，写锁是独占锁。

读锁的共享锁可以保证并发读的高效，读写，写读，写写的过程是互斥的。

写操作：原子+ 独占，整个过程是不可以被分割、被打断的。

package com.company;

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;

/**
* 手写一个缓存
* 1.读
* 2.写
* 3.清空
*/
class MyCache{//资源类
   //可见性，禁止指令重排
   private volatile Map<String,Object> map = new HashMap<>();
   //读写一体，读的时候也是只有一个人可以读，即排着队读
   private ReadWriteLock rwlock = new ReentrantReadWriteLock();//可重入的读写锁
   public void put(String key,Object value){
       rwlock.writeLock().lock();
       try
       {
           System.out.println(Thread.currentThread().getName()+"正在写入"+ key);
           try {TimeUnit.MILLISECONDS.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}
           map.put(key,value);
           System.out.println(Thread.currentThread().getName()+"写入完成");
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           rwlock.writeLock().unlock();
       }
   }
   public void get(String key) {
       rwlock.readLock().lock();
       try {
           System.out.println(Thread.currentThread().getName() + "正在读取");
           try {
               TimeUnit.MILLISECONDS.sleep(300);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           Object result = map.get(key);
           System.out.println(Thread.currentThread().getName() + "读取完成" + result);
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           rwlock.readLock().unlock();
       }
   }
}

/**
* 读、写锁
* 读，大家可以一起读
* 写只允许一个人可以写:原子、独占
*
* 读-读可以共存
* 读-写、写-写u可以同时出现
*/
public class ReadWriteLockDemo {
   public static void main(String[] args) {
       MyCache myCache= new MyCache();
       for (int i = 0; i < 3; i++) {
           final int tempInt = i;
           new Thread(()->{
               myCache.put(tempInt+"",tempInt+"");
           },"Thread_No"+i).start();
       }
       for (int i = 0; i < 3; i++) {
           final int tempInt = i;
           new Thread(()->{
               myCache.get(tempInt+"");
           },"Thread_No"+i).start();
       }
   }
}

Console：

• Thread_No0正在写入0
• Thread_No0写入完成
• Thread_No2正在写入2
• Thread_No2写入完成
• Thread_No1正在写入1
• Thread_No1写入完成

写入与其他操作互斥。

• Thread_No0正在读取

• Thread_No1正在读取

• Thread_No2正在读取

• Thread_No2读取完成2

• Thread_No0读取完成0

• Thread_No1读取完成1

读读可以同时进行。

读写分离，既保证了数据的一致性，比较于Synchronized这种重锁，并发性得到了提升，因为可以同时读了。