这篇文章将为大家详细讲解有关怎样理解Java中的锁,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。
读写锁维护一对关联锁,一个只用于读操作,一个只用于写操作。读锁可以由多个线程同时持有,又称共享锁。写锁同一时间只能由一个线程持有,又称互斥锁。同一时间,两把锁不能被不同线程持有。读写锁适合读取操作多于写入操作的场景,改进互斥锁的性能,比如集合的并发安全性改造,缓存组件等。
ReentrantReadWriteLock需要一个owner用来标记那个写操作的线程获取到了锁,owner只会标记写操作的线程引用,不会标记读操作的线程,一个writeCount用来记录写操作加锁的次数, 一个readCount用来记录读操作加锁的次数,还有一个waiters等待队列用来存放没有抢到锁的线程列表
当有写操作线程进来时,会先判断readCount的值,如果readCount为0说明读锁未被占用
然后判断writeCount的值,如果writeCount为0,说明写锁未被占用
然后通过CAS操作进行抢锁将writeCount值加1,如果抢到锁则将owner设置为当前写操作线程的引用
如果writeCount不为0同时owner指向当前写线程的引用,则将writeCount的值加1
如果writeCount不为0同时owner指向的不是当前写线程的引用,则将则将线程放入等待队列
如果CAS抢锁失败,则将线程放入等待队列
如果写操作线程进来时,readCount不为0说明读锁已被占用,则将线程放入等待队列
当有读操作线程进来时,会先判断writeCount的值,如果writeCount为0说明写锁未被占用
然后通过CAS将readCount的值加1
如果读操作线程进来时,writeCount不为0说明写锁被占用
如果写锁是被当前线程占用则该线程可以继续获得读锁,即锁降级
如果写锁不是被当前线程占用,则将线程放入等待队列
当有写线程释放锁时,会将writeCount的值减1,如果writeCount的值为0,则将owner设为null同时唤醒等待队列头部的线程出队列进行抢锁操作
如果等待队列的头部线程是读操作,则会进行CAS操作将readCount值加1同时唤醒下一个等待线程
如果下一个线程还是读操作,则会进行CAS操作将readCount值加1并且继续唤醒下一个等待线程
如果下一个线程是写操作,则不会唤醒需要等到将读锁释放完之后才会唤醒
手动实现ReentrantReadWriteLock示例:
public class MyReadWriteLock { private AtomicInteger readCount = new AtomicInteger(0); private AtomicInteger writeCount = new AtomicInteger(0); // 独占锁 拥有者 private AtomicReference<Thread> owner = new AtomicReference<>(); // 等待队列 private volatile LinkedBlockingQueue<WaitNode> waiters = new LinkedBlockingQueue<WaitNode>(); class WaitNode { int type = 0; // 0 为想获取独占锁的线程, 1为想获取共享锁的线程 Thread thread = null; int arg = 0; public WaitNode(Thread thread, int type, int arg) { this.thread = thread; this.type = type; this.arg = arg; } } // 获取独占锁 public void lockWrite() { int arg = 1; // 尝试获取独占锁,若成功,退出方法, 若失败... if (!tryLockWrite(arg)) { // 标记为独占锁 WaitNode waitNode = new WaitNode(Thread.currentThread(), 0, arg); waiters.offer(waitNode); // 进入等待队列 // 循环尝试拿锁 for (; ; ) { // 若队列头部是当前线程 WaitNode head = waiters.peek(); if (head != null && head.thread == Thread.currentThread()) { if (!tryLockWrite(arg)) { // 再次尝试获取 独占锁 LockSupport.park(); // 若失败,挂起线程 } else { // 若成功获取 waiters.poll(); // 将当前线程从队列头部移除 return; // 并退出方法 } } else { // 若不是队列头部元素 LockSupport.park(); // 将当前线程挂起 } } } } // 释放独占锁 public boolean unlockWrite() { int arg = 1; // 尝试释放独占锁 若失败返回true,若失败... if (tryUnlockWrite(arg)) { WaitNode next = waiters.peek(); // 取出队列头部的元素 if (next != null) { Thread th = next.thread; LockSupport.unpark(th); // 唤醒队列头部的线程 } return true; // 返回true } return false; } // 尝试获取独占锁 public boolean tryLockWrite(int acquires) { // 如果read count !=0 返回false if (readCount.get() != 0) return false; int wct = writeCount.get(); // 拿到 独占锁 当前状态 if (wct == 0) { if (writeCount.compareAndSet(wct, wct + acquires)) { // 通过修改state来抢锁 owner.set(Thread.currentThread()); // 抢到锁后,直接修改owner为当前线程 return true; } } else if (owner.get() == Thread.currentThread()) { writeCount.set(wct + acquires); // 修改count值 return true; } return false; } // 尝试释放独占锁 public boolean tryUnlockWrite(int releases) { // 若当前线程没有 持有独占锁 if (owner.get() != Thread.currentThread()) { throw new IllegalMonitorStateException(); // 抛IllegalMonitorStateException } int wc = writeCount.get(); int nextc = wc - releases; // 计算 独占锁剩余占用 writeCount.set(nextc); // 不管是否完全释放,都更新count值 if (nextc == 0) { // 是否完全释放 owner.compareAndSet(Thread.currentThread(), null); return true; } else { return false; } } // 获取共享锁 public void lockRead() { int arg = 1; if (tryLockRead(arg) < 0) { // 如果tryAcquireShare失败 // 将当前进程放入队列 WaitNode node = new WaitNode(Thread.currentThread(), 1, arg); waiters.offer(node); // 加入队列 for (; ; ) { // 若队列头部的元素是当前线程 WaitNode head = waiters.peek(); if (head != null && head.thread == Thread.currentThread()) { if (tryLockRead(arg) >= 0) { // 尝试获取共享锁, 若成功 waiters.poll(); // 将当前线程从队列中移除 WaitNode next = waiters.peek(); if (next != null && next.type == 1) { // 如果下一个线程也是等待共享锁 LockSupport.unpark(next.thread); // 将其唤醒 } return; // 退出方法 } else { // 若尝试失败 LockSupport.park(); // 挂起线程 } } else { // 若不是头部元素 LockSupport.park(); } } } } // 解锁共享锁 public boolean unLockRead() { int arg = 1; if (tryUnLockRead(arg)) { // 当read count变为0,才叫release share成功 WaitNode next = waiters.peek(); if (next != null) { LockSupport.unpark(next.thread); } return true; } return false; } // 尝试获取共享锁 public int tryLockRead(int acquires) { for (; ; ) { if (writeCount.get() != 0 && owner.get() != Thread.currentThread()) return -1; int rct = readCount.get(); if (readCount.compareAndSet(rct, rct + acquires)) { return 1; } } } // 尝试解锁共享锁 public boolean tryUnLockRead(int releases) { for (; ; ) { int rc = readCount.get(); int nextc = rc - releases; if (readCount.compareAndSet(rc, nextc)) { return nextc == 0; } } } }
锁降级指的是写锁降级为读锁,是指持有写锁的同时,再获取读锁,随后释放写锁的过程。 写锁是线程独占,读锁是线程共享,所以写锁降级为读锁可行,而读锁升级为写锁不可行。
代码示例:
class TeacherInfoCache { static volatile boolean cacheValid; 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; } } finally { // 锁降级 rwl.readLock().lock(); rwl.writeLock().unlock(); } } return data; } finally { rwl.readLock().unlock(); } } } class DataBase { static String queryUserInfo() { System.out.println("查询数据库。。。"); return "name:Kody,age:40,gender:true,"; } } class Redis { static Map<String, Object> data = new HashMap<>(); }
关于怎样理解Java中的锁就分享到这里了,希望以上内容可以对大家有一定的帮助,可以学到更多知识。如果觉得文章不错,可以把它分享出去让更多的人看到。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。