Lock总结

Lock在我们日常研发中经常会使用到，比如ReenTrantLock，ReentrantReadWriteLock，StampedLock (JDK1.8新增)，

下面就详细介绍一下它们的使用方法。

• ReenTrantLock

  ReenTrantLock支持公平锁和非公平锁,也是独占锁,下面来说一下ReenTrantLock下的方法和使用。

  1. lock： 获取阻塞锁。

     // 默认是费公平锁，可自定，在参数中增加 true-公平 false-非公平
     ReenTrantLock lockObjcet = new ReenTrantLock();
     try {
       // 获取锁 ，如果获取不到则阻塞线程
       lockObjcet.lock();
       // 同步代码块
     } catch (Exception e) {
       
     } finally {
       // 释放锁
       lockObjcet.unLock();
     }
     

  2. tryLock： 获取非阻塞锁，如果无法获取到锁，返回false，获取到了返回true。

       ReenTrantLock lock = new ReenTrantLock();
     if (lock.tryLock()) {
       // 获取到了锁
     } else {
       // 没有获取到锁
     }
     

  3. tryLock(time)： 获取非阻塞超时锁，在time时间内如果获取到了锁，返回true，获取不到锁返回false。

     ReenTrantLock lock = new ReenTrantLock();
     // 获取锁，如果在指定时间内还未获得，则返回false
     if (lock.tryLock(100)) {
       // 获取到了锁
     } else {
       // 没有获取到锁
     }
     

  4. lockInterruptibly()： 获取可中断锁，和lock区别就是在获取锁的过程中可以中断线程。

  5. unlock()： 解锁

  6. boolean isHeldByCurrentThread()： 判断锁是否是当前线程持有，是返回true，不是返回false。

  7. boolean isLocked()： 判断锁是否被获取或占用。

  8. boolean isFair()： 是否是公平锁，是 返回true， 不是返回false。

  9. Thread getOwner()： 获取当前锁的拥有者， 如果有拥有者则返回拥有者，如果没有返回null。

  10. boolean hasQueuedThreads()： 判断是否有等待线程，如果有则返回true，反之false。

  11. boolean hasQueuedThread(Thread thread)： 判断入参的线程是否存在于等待队列中，如果存在则返回true，反之false。

  12. int getQueueLength()： 获取等待队列中线程总数。

  13. Collection getQueuedThreads()： 获取等待队列中的所有线程。

  14. boolean hasWaiters(Condition condition)： 否有线程在与此锁关联的给定条件上等待，有返回true 反之 false。

  15. int getWaitQueueLength(Condition condition)：获取被参数条件等待的线程总数。

  16. Collection getWaitingThreads(Condition condition)： 获取当前锁的条件等待的所有线程.

• ReentrantReadWriteLock

  读写锁： 读锁可以多线程一起获取，写锁只有一个线程可以获取，读写锁支持公平锁和非公平锁，支持重入锁。

  读锁： 可以被多个线程共同获取锁，同时进入代码块。

  写锁：只允许一个线程获取，如果当前线程获取到写锁后，发现有线程获取了读锁，并且不是当前线程，这时当前线程就进入等待状态。

  代码示例：

  // 读写锁
  private  ReadWriteLock rw = new ReentrantReadWriteLock();
  // 读锁 共享锁
  private  Lock r = rw.readLock();
  // 写锁 排它锁
  private  Lock w = rw.writeLock();
  

  • WriteLock
    1. lock()： 写锁为独占锁，当线程A获取到了写锁时任何线程都不能获取到读锁和写锁，如果线程A获取到了写锁，但是读锁已经被线程B获取并且未释放，这时就需要将线程A状态改为等待，等待线程B释放了写锁再继续执行。
    2. unlock()： 解锁。
  • ReadLock
    1. lock()： 加锁。
    2. unlock()： 解锁。

• StampedLock (JDK1.8新增)

  StampedLock： 读写锁，但是StampedLock比ReenTrantReadWriteLock更块,但是StampedLock用于乐观读锁，悲观读锁，和写锁，StampedLock不支持重入锁，StampedLock 的悲观读锁、写锁都不支持条件变量。

  1. tryOptimisticRead： 乐观读。
  2. readLock： 悲观读。
  3. writeLock： 悲观写。

  代码示例：

  /**
   * @Auther: lantao
   * @Date: 2019-05-05 17:55
   * @Company: 随行付支付有限公司
   * @maill: lan_tao@suixingpay.com
   * @Description: TODO
   */
  public class StampedLockTest {
  
      static StampedLock s =new StampedLock();
  
      public static void main(String[] args) {
  
          // 悲观读
          long l = s.readLock();
  
          // 释放悲观读
          s.unlockRead(l);
  
  
          // 悲观写
          long l1 = s.writeLock();
  
          // 释放悲观写
          s.unlockWrite(l1);
  
  
          // 乐观读 升级 悲观读
          long l2 = s.tryOptimisticRead();
  
          //验证是否被修改 如果返回false 会释放 l2，所以后续直接释放l3即可
          if (!s.validate(l2)){
              // 升级悲观读
              long l3 = s.readLock();
              s.unlockRead(l3);
          }
      }
  }
  

• Conditionn

  Condition： Lock 的条件 ,其实初始化的是ConditionObject， ConditionObject是Condition的实现，singal和signlAll的时候需要在获取锁后。

  1. await()： 线程等待，相当于**Objcet的wait()**方法。
  2. awaitNanos(time)： 等待一定时间，如果超过则继续执行，相当于Object的wait(time)方法。
  3. signal()： 随机唤醒一个被Condition.await()的线程，相当于Object的notify()方法。
  4. signalAll()： 唤醒全部被Condition.await()的线程，相当于Object的notifyAll()方法。

  代码示例：

  /**
   * @Auther: lantao
   * @Date: 2019-04-15 14:49
   * @Company: 随行付支付有限公司
   * @maill: lan_tao@suixingpay.com
   * @Description: Condition 条件 有 singal signalAll 和 await 方法 和Object 的 notify notifyAll 和 wait 是一个意思同样会释放锁  执行singal和notify的时候也需要在等待获取锁
   */
  public class LockCondition {
  
      public static ReentrantLock lock = new ReentrantLock();
  
      public static Condition a = lock.newCondition();
  
      public static Condition b = lock.newCondition();
  
      public static void main(String[] args) throws InterruptedException {
          Runnable runnable = () -> {
              try {
                  lock.lock();
                  System.out.println(Thread.currentThread().getName());
                  a.await();
  
                  System.out.println(Thread.currentThread().getName() +  " 的 a conndition 被唤醒了");
  
                  b.await();
  
                  System.out.println(Thread.currentThread().getName() +  " 的 b conndition 被唤醒了");
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          };
  
          Runnable runnable1 = () -> {
              try {
                  lock.lock();
                  System.out.println("线程" +Thread.currentThread().getName() + " 开始执行a condition sinalAll");
                  a.signalAll();
  
              } catch (Exception e) {
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          };
  
          Runnable runnable2 = () -> {
              try {
                  lock.lock();
                  System.out.println("线程" +Thread.currentThread().getName() + " 开始执行b condition sinalAll");
                  b.signalAll();
  
              } catch (Exception e) {
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          };
  
          new Thread(runnable,"Thread1").start();
          new Thread(runnable,"Thread2").start();
          Thread.sleep(100);
          new Thread(runnable1,"Thread3").start();
          Thread.sleep(100);
          new Thread(runnable2,"Thread4").start();
      }
  }
  
  // 执行结果
  Thread1
  Thread2
  线程Thread3 开始执行a condition sinalAll
  Thread1 的 a conndition 被唤醒了
  Thread2 的 a conndition 被唤醒了
  线程Thread4 开始执行b condition sinalAll
  Thread1 的 b conndition 被唤醒了
  Thread2 的 b conndition 被唤醒了
  

  博客地址：https://lantaoblog.site