【原创】JUC包源码分析07 | 借助AQS自定义锁

/** 
 * 获取一个独占锁，不考虑被干扰.    
 */  
public final void acquire(int arg) { 
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
} 


/** 
 * 释放独占锁，不考虑被干扰.     
 */ 
public final boolean release(int arg) { 
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
} 


 /** 
 * 获取一个共享锁，不考虑干扰.   
 */ 
public final void acquireShared(int arg) { 
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
} 


/** 
 * 释放一个共享锁.  
 */ 
public final boolean releaseShared(int arg) { 
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

/**
 * 复写AQS的tryAcquire()和tryRelease()方法
 */
public class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 0L;


    /**
     * 尝试获取锁方法
     *
     * @param acquires 量
     * @return 成功：true，失败:false
     */
    @Override
    protected boolean tryAcquire(int acquires) {
        // 获取当前线程
        final Thread current = Thread.currentThread();
        int c = getState();
        // 如果没有线程获取到锁
        if (c == 0) {
            // CAS操作，为当前线程尝试获取锁
            if (compareAndSetState(0, acquires)) {
                // 进入到这里，代表一定获取了锁
                // 设置当前线程为独占锁线程
                setExclusiveOwnerThread(current);
                // 返回true,代表获取了锁
                return true;
            }
        } // 判断是否是当前线程重复获取锁（锁重入）
          else if (current == getExclusiveOwnerThread()) {
            // 进入到这里，代表是重入锁
            // 设置state
            setState(c + acquires);
            // 返回true,代表获取了锁
            return true;
        }
        // CAS失败，又不是重入，那么锁一定是被其他线程占用着
        // 即代表没有获取到锁
        return false;
    }


    /**
     * 尝试释放锁
     *
     * @param releases 量
     * @return 成功：true，失败:false
     */
    @Override
    protected boolean tryRelease(int releases) {
        // 直接将当前state减去相应的releases
        int c = getState() - releases;
        // 必须是当前线程才能释放锁
        // 也就是获取锁的线程才能释放自己的锁
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 如果c == 0, 代表之前的锁已经释放
        if (c == 0) {
            // 此时没有线程持有锁
            free = true;
            // 没有线程持有锁
            setExclusiveOwnerThread(null);
        }
        // 设置回state
        setState(c);
        // 返回true: 释放锁成功，没有线程持有锁
        // 返回false: 锁依然有线程在持有，可能是重入锁
        return free;
    }
}

/**
 * Desp: 借用AQS实现可重入的独占锁
 * 2021-01-03 17:15 
 * Created by zhru.
 */
public class SingleLock {


  /**
   * 复写AQS的tryAcquire()和tryRelease()方法
   */
 private static final class Sync extends AbstractQueuedSynchronizer{
      private static final long serialVersionUID = 0L;


      /**
       * 尝试获取锁方法
       *
       * @param acquires 量
       * @return 成功：true，失败:false
       */
      @Override
      protected boolean tryAcquire(int acquires) {
          final Thread current = Thread.currentThread();
          int c = getState();
          if (c == 0) {
              if (compareAndSetState(0, acquires)) {
                  setExclusiveOwnerThread(current);
                  return true;
              }
          } else if (current == getExclusiveOwnerThread()) {
              setState(c + acquires);
              return true;
          }
          return false;
      }


      /**
       * 尝试释放锁
       *
       * @param releases 量
       * @return 成功：true，失败:false
       */
      @Override
      protected boolean tryRelease(int releases) {
          int c = getState() - releases;
          if (Thread.currentThread() != getExclusiveOwnerThread())
              throw new IllegalMonitorStateException();
          boolean free = false;
          if (c == 0) {
              free = true;
              setExclusiveOwnerThread(null);
          }
          setState(c);
          return free;
        }
  }


    // 定义变量
  private final Sync sync;


  /**
   * 默认构造方法
   */
  public SingleLock() {
      this.sync = new Sync();
  }


  /**
   * 尝试获取锁
   */
  public void tryLock() {
      // 直接调用我们自定义的tryAcquire()方法
      sync.tryAcquire(1);
  }


  /**
   * 获取锁
   */
  public void lock() {
        // 调用我们自定义AQS子类的acquire()方法
      sync.acquire(1);
  }


  /**
   * 释放锁
   */
    public void unlock() {
      // 调用我们自定义AQS子类的release()方法
      sync.release(1);
   }
}

// 不使用锁的使用对象
static int oneNum = 0;
// 使用自定义锁时的使用对象
static int twoNum = 0;
// 循环次数
static int roundSize = 100000;


public static void main(String[] args) throws Exception {
   // 为了方便，直接调用Executors工具类
   // 实际业务场景，不建议使用
  ExecutorService executorService = Executors.newFixedThreadPool(5);


   for (int i = 0; i < roundSize; i++) {
     executorService.execute(() -> addOne());
   }
  
    // ===========使用自定义的锁============
    SingleLock singleLock = new SingleLock();
      for (int i = 0; i < roundSize; i++) {
        executorService.execute(() -> {
            singleLock.lock();
            try {
                addTwo();
            } finally {
                singleLock.unlock();
            }
        });
    }
  
    Thread.sleep(5000L);
    System.out.println("使用自定义锁执行结果:" + twoNum);
    executorService.shutdown();
}


// 自增1
private static void addOne() {
    oneNum++;
}
// 自增1
private static void addTwo() {
    twoNum++;
}