深入理解JAVA中的锁（二）

深入理解JAVA中的锁（二）

1. locks包的介绍

2.Lock 接口

代码示例：

public class GetLockDemo {
  // 公平锁  
   static Lock lock =new ReentrantLock(true);
  // 非公平锁  static Lock lock = new ReentrantLock();
  public static void main(String[] args) throws InterruptedException {
    // 主线程 拿到锁    lock.lock();
    Thread thread =
        new Thread(
            () -> {
              // 子线程 获取锁（不死不休）              System.out.println("begain to get lock...");
              lock.lock();
              System.out.println("succeed to get lock...");
              //              // 子线程 获取锁(浅尝辄止)
              //              boolean result = lock.tryLock();
              //              System.out.println("是否获得到锁：" + result);
              //
              //              // 子线程 获取锁(过时不候)
              //              try {
              //                boolean result1 = lock.tryLock(5, TimeUnit.SECONDS);
              //                System.out.println("是否获得到锁：" + result1);
              //              } catch (InterruptedException e) {
              //                e.printStackTrace();
              //              }
              //
              //              // 子线程 获取锁（任人摆布）              //              try {
              //                System.out.println("start to get lock Interruptibly");
              //                lock.lockInterruptibly();
              //              } catch (InterruptedException e) {
              //                e.printStackTrace();
              //                System.out.println("dad asked me to stop...");
              //              }
            });
    thread.start();
    Thread.sleep(10000L);
    lock.unlock();
  }
}

结论：

• lock() 最常用
• lockInterruptibly() 方法一般更昂贵，有的实现类可能没有实 lockInterruptible() 方法。只有真的需要用中断时，才使用，使用前应看清实现类对该方法的描述。

3. Condition

Condition示例：

public class ConditionDemo {
  static Lock lock = new ReentrantLock();
  static Condition condition = lock.newCondition();
  public static void main(String[] args) throws InterruptedException {
    Thread thread =
        new Thread(
            () -> {
              lock.lock();
              System.out.println("condition.await()");
              try {
                condition.await();
                System.out.println("here i am...");
              } catch (InterruptedException e) {
                e.printStackTrace();
              } finally {
                lock.unlock();
              }
            });
    thread.start();
    Thread.sleep(2000L);
    lock.lock();
    condition.signalAll();
    lock.unlock();
  }
}

4.ReetrantLock

ReentrantLock是可重入锁，同一线程可以多次获取到锁。

ReentrantLock实现原理：
1.ReentrantLock需要一个owner用来标记那个线程获取到了锁，一个count用来记录锁的重入次数和一个waiters等待队列用来存放没有抢到锁的线程列表
2.当有线程进来时，会先判断count的值，如果count为0说明锁没有被占用
3.然后通过CAS操作进行抢锁
4.如果抢到锁则count的值会加1，同时将owner设置为当前线程的引用
5.如果count不为0同时owner指向当前线程的引用，则将count的值加1
6.如果count不为0同时owner指向的不是当前线程的引用，则将线程放入等待队列waiters中
7.如果CAS抢锁失败，则将线程放入等待队列waiters中
8.当线程使用完锁后，会释放其持有的锁，释放锁时会将count的值减1，如果count值为0，则将owner设为null
9.owner为null后，则会唤醒等待队列头部的线程进行抢锁

public class MyReentrantLock implements Lock {
  // 标记重入次数的count值  private AtomicInteger count = new AtomicInteger(0);
  // 锁的拥有者  private AtomicReference<Thread> owner = new AtomicReference<>();
  // 等待队列  private LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();
  @Override
  public boolean tryLock() {
    // 判断count是否为0，若count！=0，说明锁被占用    int ct = count.get();
    if (ct != 0) {
      // 判断锁是否被当前线程占用，若被当前线程占用，做重入操作，count+=1
      if (owner.get() == Thread.currentThread()) {
        count.set(ct + 1);
        return true;
      } else {
        // 若不是当前线程占用，互斥，抢锁失败，return false
        return false;
      }
    } else {
      // 若count=0， 说明锁未被占用，通过CAS（0，1） 来抢锁      if (count.compareAndSet(ct, ct + 1)) {
        // 若抢锁成功，设置owner为当前线程的引用        owner.set(Thread.currentThread());
        return true;
      } else {
        return false;
      }
    }
  }
  @Override
  public void lock() {
    // 尝试抢锁    if (!tryLock()) {
      // 如果失败，进入等待队列      waiters.offer(Thread.currentThread());
      // 自旋      for (; ; ) {
        // 判断是否是队列头部，如果是        Thread head = waiters.peek();
        if (head == Thread.currentThread()) {
          // 再次尝试抢锁          if (!tryLock()) {
            // 若抢锁失败，挂起线程，继续等待            LockSupport.park();
          } else {
            // 若成功，就出队列            waiters.poll();
            return;
          }
        } else {
          // 如果不是队列头部，就挂起线程          LockSupport.park();
        }
      }
    }
  }
  public boolean tryUnlock() {
    // 判断，是否是当前线程占有锁，若不是，抛异常    if (owner.get() != Thread.currentThread()) {
      throw new IllegalMonitorStateException();
    } else {
      // 如果是，就将count-1  若count变为0 ，则解锁成功      int ct = count.get();
      int nextc = ct - 1;
      count.set(nextc);
      // 判断count值是否为0
      if (nextc == 0) {
        owner.compareAndSet(Thread.currentThread(), null);
        return true;
      } else {
        return false;
      }
    }
  }
  @Override
  public void unlock() {
    // 尝试释放锁    if (tryUnlock()) {
      // 获取队列头部， 如果不为null则将其唤醒      Thread thread = waiters.peek();
      if (thread != null) {
        LockSupport.unpark(thread);
      }
    }
  }
  @Override
  public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    return false;
  }
  @Override
  public void lockInterruptibly() throws InterruptedException {}
  @Override
  public Condition newCondition() {
    return null;
  }
}

5. synchronized VS Lock

synchronized：
优点：
1.使用简单，语义清晰，哪里需要点哪里
2.由JVM提供，提供了多种优化方案（锁粗化，锁消除，偏向锁，轻量级锁）
3.锁的释放由虚拟机完成，不用人工干预，降低了死锁的可能性
缺点：
悲观的排他锁，无法实现锁的高级功能如公平锁，读写锁等。
Lock：
优点：可以实现synchronized无法实现的锁的高级功能如公平锁，读写锁等，同时还可以实现更多的功能　
缺点：需手动释放锁unlock，使用不当容易造成死锁。
结论: 两者都是可重入锁，synchronized可以类比为傻瓜相机，提供了固定的功能，而Lock可以类比为单方，可以根据需要调节所需的功能

6. 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;
      }
    }
  }
}

7. 锁降级

锁降级指的是写锁降级为读锁，是指持有写锁的同时，再获取读锁，随后释放写锁的过程。
写锁是线程独占，读锁是线程共享，所以写锁降级为读锁可行，而读锁升级为写锁不可行。

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<>();
}