深入理解Java中的锁(三)

2019-08-16 11:22:53来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

深入理解Java中的锁(三)

ReadWriteLock接口

读写锁维护一对关联锁,一个只用于读操作,一个只用于写操作。读锁可以由多个线程同时持有,又称共享锁。写锁同一时间只能由一个线程持有,又称互斥锁。同一时间,两把锁不能被不同线程持有。读写锁适合读取操作多于写入操作的场景,改进互斥锁的性能,比如集合的并发安全性改造,缓存组件等。

ReentrantReadWriteLock实现原理分析

  1. ReentrantReadWriteLock需要一个owner用来标记那个写操作的线程获取到了锁,owner只会标记写操作的线程引用,不会标记读操作的线程,一个writeCount用来记录写操作加锁的次数, 一个readCount用来记录读操作加锁的次数,还有一个waiters等待队列用来存放没有抢到锁的线程列表
  2. 当有写操作线程进来时,会先判断readCount的值,如果readCount为0说明读锁未被占用
  3. 然后判断writeCount的值,如果writeCount为0,说明写锁未被占用
  4. 然后通过CAS操作进行抢锁将writeCount值加1,如果抢到锁则将owner设置为当前写操作线程的引用
  5. 如果writeCount不为0同时owner指向当前写线程的引用,则将writeCount的值加1
  6. 如果writeCount不为0同时owner指向的不是当前写线程的引用,则将则将线程放入等待队列
  7. 如果CAS抢锁失败,则将线程放入等待队列
  8. 如果写操作线程进来时,readCount不为0说明读锁已被占用,则将线程放入等待队列
  9. 当有读操作线程进来时,会先判断writeCount的值,如果writeCount为0说明写锁未被占用
  10. 然后通过CAS将readCount的值加1
  11. 如果读操作线程进来时,writeCount不为0说明写锁被占用
  12. 如果写锁是被当前线程占用则该线程可以继续获得读锁,即锁降级
  13. 如果写锁不是被当前线程占用,则将线程放入等待队列
  14. 当有写线程释放锁时,会将writeCount的值减1,如果writeCount的值为0,则将owner设为null同时唤醒等待队列头部的线程出队列进行抢锁操作
  15. 如果等待队列的头部线程是读操作,则会进行CAS操作将readCount值加1同时唤醒下一个等待线程
  16. 如果下一个线程还是读操作,则会进行CAS操作将readCount值加1并且继续唤醒下一个等待线程
  17. 如果下一个线程是写操作,则不会唤醒需要等到将读锁释放完之后才会唤醒

手动实现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<>();
}

?

原文链接:https://www.cnblogs.com/coding-diary/p/11261238.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:[Spring cloud 一步步实现广告系统] 5. 投放系统配置+启动+实体

下一篇:java高并发系列 - 第18天:玩转java线程池,这一篇就够了