独占锁（写锁）/ 共享锁（读锁）/ 互斥锁
独占锁：指该锁一次只能被一个线程所持有。
- 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这种重锁，并发性得到了提升，因为可以同时读了。
