ReadWriteLock使用及抢锁原理
概述
概念
-
维护一对关联锁，一个只能用来读操作，一个只能用来写操作；
-
读锁可以由多个读线程共同持有（共享锁），写锁是排他的（独享锁）。
-
同一时间，两把锁不能被不同线程持有
使用场景
适合读取操作多于写入操作的场景，改进互斥锁的性能，比如：集合的并发线程安全性改造、缓存组件。
为什么读的时候还需要加锁？
当写的操作为需要保证原子性的多步操作时，此时如果只是在写上加锁而未在读上加锁，就可能会造成原子性问题，即当写执行到一半的时候，另外一个线程执行了读操作，从而使得读到的数据时不准确的，产生了数据分裂。
锁降级
指的是写锁降级为读锁。持有写锁的同时，在获取读锁，锁喉释放写锁的过程。写锁时线程独占，读锁是共享的，所以写到读是降级（读到写为升级，是不能实现的）。
应用
场景一
package com.hzw.subject1.lock;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class MyLockHashMap {
private final Map<String, Object> m = new HashMap<>();
private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();
public Object get(String key) {
r.lock();
try {
return m.get(key);
} finally {
r.unlock();
}
}
public Object[] allKeys() {
r.lock();
try {
return m.keySet().toArray();
} finally {
r.unlock();
}
}
public Object put(String key, Object obj) {
w.lock();
try {
return m.put(key, obj);
} finally {
w.unlock();
}
}
public void clear() {
w.lock();
try {
m.clear();
} finally {
w.unlock();
}
}
}
场景二
package com.hzw.subject1.lock;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class MyLockCache {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(UserInfoCache.get("insist"));
}
}).start();
}
}
}
class UserInfoCache {
private static volatile boolean cacheValid;
private static final ReadWriteLock rwl = new ReentrantReadWriteLock();
static Object get(String dataKey) {
Object data = null;
//读取数据，加读锁
rwl.readLock().lock();
try {
if (cacheValid) {
data = Redis.data.get(dataKey);
} else {
//通过加锁的方式去访问DB，加写锁
rwl.readLock().unlock();
rwl.writeLock().lock();
try {
if (!cacheValid) {
data = DataBase.queryUserInfo();
Redis.data.put(dataKey, data);
cacheValid = true;
} else {
data = Redis.data.get(dataKey);
}
} finally {
//锁降级
rwl.readLock().lock();
rwl.writeLock().unlock();
}
}
return data;
} finally {
rwl.readLock().unlock();
}
}
}
class DataBase {
static String queryUserInfo() {
System.out.println("查询数据库。。。");
return "name:insist,age:18,gender:true,";
}
}
class Redis {
static Map<String, Object> data = new HashMap<>();
}
原理
流程
手写读写锁
package com.hzw.subject1.lock.mylock;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.*;
public class MyReadWriteLock implements ReadWriteLock {
private AtomicInteger rCount = new AtomicInteger();
private AtomicInteger wCount = new AtomicInteger();
/**
* 独占锁的拥有者
*/
private AtomicReference<Thread> owner = new AtomicReference<>();
/**
* 等待队列
*/
private LinkedBlockingQueue<Node> waiters = new LinkedBlockingQueue<>();
static class Node{
//独占锁type
static final int MONOPOLY = 0;
//共享锁type
static final int SHARE = 1;
/**
* 约定必须为一下选项：
* MONOPOLY 为想获取独占锁的线程
* SHARE为想获取共享锁的线程
*/
int type;
Thread thread;
int arg;
public Node(Thread thread, int type, int arg){
this.thread = thread;
this.type = type;
this.arg = arg;
}
public static Node createMonopoly(Thread thread) {
return new Node(thread, MONOPOLY, 1);
}
public static Node createShare(Thread thread) {
return new Node(thread, SHARE, 1);
}
}
@Override
public Lock readLock() {
return new Lock() {
@Override
public void lock() {
//尝试抢锁
if (!tryLock()) {
Node current = Node.createMonopoly(Thread.currentThread());
//抢锁失败，加入等待队列
waiters.offer(current);
//自旋
for (; ; ) {
Node head = waiters.peek();
//如果唤醒的不是队列头，在判定为伪唤醒，让其重新进入park状态
if (null != head && head.thread == Thread.currentThread() && tryLock()) {
//唤醒的线程抢到锁以后移除等待队列
waiters.poll();
//如果下一个线程依旧是读线程，继续唤醒下一个线程
Node next = waiters.peek();
if (null != next && next.type == Node.SHARE) {
LockSupport.unpark(next.thread);
}
return;
}
LockSupport.park();
}
}
}
@Override
public boolean tryLock() {
int wc = wCount.get();
if (wc == 0)
return rCount.incrementAndGet() > 0;
if (owner.get() == Thread.currentThread())
return rCount.incrementAndGet() > 0;
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
//当前线程中断状态为true则抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//尝试抢锁
if (tryLock())
return true;
//如果等待时间<=0则直接抢锁失败
if (time <= 0)
return false;
//将time转换为纳秒
long nanos = unit.toNanos(time);
//抢锁的最后期限
long deadline = nanos + System.nanoTime();
for (; ; ) {
if (tryLock())
return true;
if (System.nanoTime() - deadline > 0L)
return false;
}
}
@Override
public void unlock() {
//尝试解锁
if (tryUnlock()) {
//解锁成功，唤醒等待队列头部的线程
Node head = waiters.peek();
if (null != head) {
LockSupport.unpark(head.thread);
}
}
}
/**
* 尝试解除共享锁
* @return 是否解除
*/
private boolean tryUnlock() {
for (; ; ) {
int rc = rCount.get();
int nrc = rc - 1;
if (rCount.compareAndSet(rc, nrc))
return nrc == 0;
}
}
@Override
public void lockInterruptibly() throws InterruptedException {
//判断线程中断状态
if (Thread.interrupted())
throw new InterruptedException();
//尝试抢锁
if (!tryLock()) {
Node current = Node.createMonopoly(Thread.currentThread());
//抢锁失败，加入等待队列
waiters.offer(current);
//自旋
for (; ; ) {
Node head = waiters.peek();
//如果唤醒的不是队列头，在判定为伪唤醒，让其重新进入park状态
if (null != head && head.thread == Thread.currentThread() && tryLock()) {
//唤醒的线程抢到锁以后移除等待队列
waiters.poll();
//如果下一个线程依旧是读线程，继续唤醒下一个线程
Node next = waiters.peek();
if (null != next && next.type == Node.SHARE) {
LockSupport.unpark(next.thread);
}
return;
}
//判断线程中断状态
if (Thread.interrupted())
throw new InterruptedException();
LockSupport.park();
}
}
}
@Override
public Condition newCondition() {
return null;
}
};
}
@Override
public Lock writeLock() {
return new Lock() {
@Override
public void lock() {
//尝试抢锁
if (!tryLock()) {
Node current = Node.createMonopoly(Thread.currentThread());
//抢锁失败，加入等待队列
waiters.offer(current);
//自旋
for (; ; ) {
Node head = waiters.peek();
//如果唤醒的不是队列头，在判定为伪唤醒，让其重新进入park状态
if (current == head && tryLock()) {
//唤醒的线程抢到锁以后移除等待队列
waiters.poll();
return;
}
LockSupport.park();
}
}
}
@Override
public boolean tryLock() {
int rc = rCount.get();
int wc = wCount.get();
//判断wCount是否为0,若wCount != 0 则说明锁已经被占用
if (wc == 0) {
if (rc != 0)
return false;
//通过CAS(0, 1)进行抢锁
if (wCount.compareAndSet(wc, 1)) {
//将owner设为当前线程的引用
owner.set(Thread.currentThread());
return true;
}
//判断当前占用锁的线程是否为当前线程
} else if(owner.get() == Thread.currentThread()){
//锁重入，count++
wCount.getAndIncrement();
return true;
}
//锁已被占用，且不是自己或抢锁失败
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
//当前线程中断状态为true则抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//尝试抢锁
if (tryLock())
return true;
//如果等待时间<=0则直接抢锁失败
if (time <= 0)
return false;
//将time转换为纳秒
long nanos = unit.toNanos(time);
//抢锁的最后期限
long deadline = nanos + System.nanoTime();
for (; ; ) {
if (tryLock())
return true;
if (System.nanoTime() - deadline > 0L)
return false;
}
}
@Override
public void unlock() {
//尝试解锁
if (tryUnlock()) {
//解锁成功，唤醒等待队列头部的线程
Node head = waiters.peek();
if (null != head) {
LockSupport.unpark(head.thread);
}
}
}
private boolean tryUnlock() {
//判断是否是当前线程拿到的锁，如果不是，抛出异常
if (owner.get() != Thread.currentThread())
throw new IllegalMonitorStateException();
//将count减1
int c = wCount.get() -1;
//判断count是否为0，如果为0，则当前线程的锁全部解完，将owner置空
if (c != 0)
return false;
owner.set(null);
wCount.set(c);
return true;
}
@Override
public void lockInterruptibly() throws InterruptedException {
//判断线程中断状态
if (Thread.interrupted())
throw new InterruptedException();
//尝试抢锁
if (!tryLock()) {
Node current = Node.createMonopoly(Thread.currentThread());
//抢锁失败，加入等待队列
waiters.offer(current);
//自旋
for (; ; ) {
Node head = waiters.peek();
//如果唤醒的不是队列头，在判定为伪唤醒，让其重新进入park状态
if (current == head && tryLock()) {
//唤醒的线程抢到锁以后移除等待队列
waiters.poll();
return;
}
//判断线程中断状态
if (Thread.interrupted())
throw new InterruptedException();
LockSupport.park();
}
}
}
@Override
public Condition newCondition() {
return null;
}
};
}
}