AQS看这一篇就够了「AbstractQueuedSynchronizer 从源码角度剖析」

已于 2023-05-27 20:15:20 修改
阅读量96 收藏
点赞数
分类专栏： Java学习屋 文章标签： java 开发语言
于 2023-05-27 20:08:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q787599931/article/details/130905345
版权

在这里插入图片描述

简介

AQS( Abstract Queued Synchronizer ）是一个抽象的队列同步器，通过维护一个共享资源状态（ Volatile Int State ）和一个先进先出（ FIFO ）的线程等待队列来实现一个多线程访问共享资源的同步框架。

核心的方法

AbstractQueuedSynchronizer, 底层使用了模版设计模式，抽象类的具体实现，需要实现底下几个方法
protected boolean tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
protected boolean tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
protected int tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
protected boolean tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
protected boolean isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。

几种锁区别

1.ReentrantLock是独占锁，一次只能有一个线程抢到资源；
2.Semaphore是共享共享锁 ，可以实现多个线程共同抢占到资源；
3.CountDownLatch会在调用 await() 后阻塞等到计数器变为0（线程中需要执行countDown()让计数器减去1）才往下执行；
CyclicBarrier会在调用 await()后阻塞所有线程，直到所有线程都到达这里后，在往后执行；
CountDownLatch是计数器，只能使用一次，而 CyclicBarrier 的计数器提供 reset 功能，可以多次使用。

图示

image.png

独占锁

ReentrantLock(可重入锁)

state 初始化为 0，表示未锁定状态。A 线程 lock() 时，会调用 tryAcquire() 独占该锁并将 state+1 。此后，其他线程再 tryAcquire() 时就会失败，直到 A 线程 unlock() 到 state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A 线程自己是可以重复获取此锁的（state 会累加），这就是可重入的概念。但要注意，获取多少次就要释放多少次，这样才能保证 state 是能回到零态的。

总结：公平锁和非公平锁只有两处不同：

  1. 非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。
  2. 非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排 到后面。

公平锁和非公平锁就这两点区别，如果这两次 CAS 都不成功，那么后面非公平锁和公平锁是一样的，都要进入到阻塞队列等待唤醒。

相对来说，非公平锁会有更好的性能，因为它的吞吐量比较大。当然，非公平锁让获取锁的时间变得更加不确定，可能会导致在阻塞队列中的线程长期处于饥饿状态。

共享锁

Semaphore(信号量)

介绍

Semaphore(信号量)可以指定多个线程同时访问某个资源。

  • 公平模式： 调用 acquire() 方法的顺序就是获取许可证的顺序，遵循 FIFO；
  • 非公平模式： 抢占式的。

源码实现

//实现共享锁的时候是判断 state 是否小于设定的值的
protected final boolean tryReleaseShared(int releases) {
    for (;;) {
        int current = getState();
        int next = current + releases;
        if (next < current) // overflow
            throw new Error("Maximum permit count exceeded");
        if (compareAndSetState(current, next))
            return true;
    }
}

使用示例

public class SemaphoreExample1 {
  
  // 请求的数量
  private static final int threadCount = 550;

  public static void main(String[] args) throws InterruptedException {
   
     // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
    ExecutorService threadPool = Executors.newFixedThreadPool(300);
   
     // 一次只能允许执行的线程数量。
    final Semaphore semaphore = new Semaphore(20);

    for (int i = 0; i < threadCount; i++) {
     
      final int threadnum = i;
      threadPool.execute(() -> {// Lambda 表达式的运用
        try {
          semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20
          test(threadnum);
          semaphore.release();// 释放一个许可
        } catch (InterruptedException e) {
          e.printStackTrace();
        }

      });
    }
    
    threadPool.shutdown();
    System.out.println("finish");
  }

  public static void test(int threadnum) throws InterruptedException {
    Thread.sleep(1000);// 模拟请求的耗时操作
    System.out.println("threadnum:" + threadnum);
    Thread.sleep(1000);// 模拟请求的耗时操作
  }  
}

CountDownLatch(倒计时器)

介绍

CountDownLatch 允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕。

CountDownLatch 是共享锁的一种实现,它默认构造 AQS 的 state 值为 count。当线程使用 countDown() 方法时,其实使用了tryReleaseShared方法以 CAS 的操作来减少 state,直至 state 为 0 。当调用 await() 方法的时候，如果 state 不为 0，那就证明任务还没有执行完毕，await() 方法就会一直阻塞，也就是说 await()方法之后的语句不会被执行。然后，CountDownLatch 会自旋 CAS 判断 state == 0，如果 state == 0 的话，就会释放所有等待的线程，await() 方法之后的语句得到执行。

应用场景

1、某一线程在开始运行前等待 n 个线程执行完毕。

将 CountDownLatch 的计数器初始化为 n （new CountDownLatch(n)），每当一个任务线程执行完毕，就将计数器减 1 （countdownlatch.countDown()），当计数器的值变为 0 时，在 CountDownLatch 上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

2、实现多个线程开始执行任务的最大并行性。

注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch 对象，将其计数器初始化为 1 （new CountDownLatch(1)），多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为 0，多个线程同时被唤醒。

使用示例

//每个线程执行完成时候，调用 countDownLatch.countDown() 计数器减去1
//调用 countDownLatch.await() 后，会等待所有线程执行完后才会往下执行
public class CountDownLatchExample1 {
      // 请求的数量
      private static final int threadCount = 550;
    
      public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
        ExecutorService threadPool = Executors.newFixedThreadPool(300);
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
          final int threadnum = i;
          threadPool.execute(() -> {// Lambda 表达式的运用
            try {
              test(threadnum);
            } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            } finally {
              countDownLatch.countDown();// 表示一个请求已经被完成
            }
    
          });
        }
        countDownLatch.await();
        threadPool.shutdown();
        System.out.println("finish");
      }
    
      public static void test(int threadnum) throws InterruptedException {
        Thread.sleep(1000);// 模拟请求的耗时操作
        System.out.println("threadnum:" + threadnum);
        Thread.sleep(1000);// 模拟请求的耗时操作
      }
}

CyclicBarrier(循环栅栏)

介绍

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是：让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

CyclicBarrier 默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用 await() 方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

应用场景

CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个 Excel 保存了用户所有银行流水，每个 Sheet 保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个 sheet 里的银行流水，都执行完之后，得到每个 sheet 的日均银行流水，最后，再用 barrierAction 用这些线程的计算结果，计算出整个 Excel 的日均银行流水。

使用示例

public class CyclicBarrierExample2 {
      // 请求的数量
      private static final int threadCount = 550;
      // 需要同步的线程数量
      private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
    
      public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
    
        for (int i = 0; i < threadCount; i++) {
          final int threadNum = i;
          Thread.sleep(1000);
          threadPool.execute(() -> {
            try {
              test(threadNum);
            } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            } catch (BrokenBarrierException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            }
          });
        }
        threadPool.shutdown();
      }
    
      public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
        System.out.println("threadnum:" + threadnum + "is ready");
        try {
          /**等待60秒，保证子线程完全执行结束*/
          cyclicBarrier.await(60, TimeUnit.SECONDS);
        } catch (Exception e) {
          System.out.println("-----CyclicBarrierException------");
        }
        System.out.println("threadnum:" + threadnum + "is finish");
      }

}

关键源码

AbstractQueuedSynchronizer

//该抽象定义state各种获取方法，抽象资源的获取方法
//最核心的方法 就是 acquire() ，acquireShared(int)
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
     
    private volatile int state;//共享变量，使用volatile修饰保证线程可见性
    
    //返回同步状态的当前值
    protected final int getState() {
         return state;
    }
     // 设置同步状态的值
    protected final void setState(int newState) {
         state = newState;
    }
    
    //原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
    protected final boolean compareAndSetState(int expect, int update) {
        //这里调用的是底层native的方法,进行cas操作
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }            
              
    //节点对象(是对每个获取资源线程的封装)  其包含了需要同步的线程本身及其等待状态，如是否被阻塞、是否等待唤醒、是否已经被取消等。   
    static final class Node {
       
        //变量waitStatus则表示当前Node结点的等待状态，共有5种取值CANCELLED、SIGNAL、CONDITION、PROPAGATE、0。
        volatile int waitStatus;
    
        volatile Node prev;
    
        volatile Node next;
    
        volatile Thread thread;
    
        Node nextWaiter;
    
        final boolean isShared() {
            return nextWaiter == SHARED;
        }
             
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
    
        Node(Thread thread, int waitStatus) { // Used by Condition
                this.waitStatus = waitStatus;
                this.thread = thread;
         }  
     }
    
    //线程获取资源(独享)由以下代码组成( ReentrantLock.lock() 等也是调用这个方法)
   
    //1.结点进入队尾后，检查状态，找到安全休息点；
    //2.调用park()进入waiting状态，等待unpark()或interrupt()唤醒自己；
    //3.被唤醒，看自己是不是有资格能拿到号(通过前驱节点的状态来判断)。
    //  如果拿到，head指向当前结点，并返回从入队到拿到号的整个过程中是否被中断过；如果没拿到，继续流程1。
    public final void acquire(int arg) {
      if (!tryAcquire(arg) &&
         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))         
         selfInterrupt();
    }
     //将当前线程加到等待队列尾
    private Node addWaiter(Node mode) {
        //以给定模式构造结点。mode有两种：EXCLUSIVE（独占）和SHARED（共享）
        Node node = new Node(Thread.currentThread(), mode);
    
        //尝试快速方式直接放到队尾。
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }    
        
        //上一步失败则通过enq入队。
        enq(node);
        return node;
    }  
    //自旋，等待获取到线程资源 
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
            try {
                boolean interrupted = false;
                for (;;) {
                    final Node p = node.predecessor();
                    //尝试获取资源，获取不到则放入等待队列
                    if (p == head && tryAcquire(arg)) {
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    //这儿回去判断线程的唤醒状态(通过判断前驱节点的状态)
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
     }    
     
    //线程获取资源(共享)由以下代码组成
    public final void acquireShared(int arg) {
       //这里可以看下 Semaphore.tryAcquireShared() 的实现
       if (tryAcquireShared(arg) < 0)
          doAcquireShared(arg);
    }
    private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);//加入队列尾部
        boolean failed = true;//是否成功标志
        try {
            boolean interrupted = false;//等待过程中是否被中断过的标志
            for (;;) {
                final Node p = node.predecessor();//前驱
                if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
                    int r = tryAcquireShared(arg);//尝试获取资源
                    if (r >= 0) {//成功
                        setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
                        p.next = null; // help GC
                        if (interrupted)//如果等待过程中被打断过，此时将中断补上。
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
    
                //判断状态，寻找安全点，进入waiting状态，等着被unpark()或interrupt()
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }            
     
    //独占方式。尝试获取资源，成功则返回true，失败则返回false
    //居然怎么获取资源，交给子类(ReentrantLock，Semaphore，CountDownLatch...)实现
    protected boolean tryAcquire(int arg) {
         throw new UnsupportedOperationException();
    }
    
    
    protected boolean tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
    protected int tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
    protected boolean tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
    protected boolean isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。                          
        
 }

ReentrantLock

    //公平锁和非公平锁的区别就是
    //公平锁会直接调用 acquire() 按队列顺序获取资源
    //非公平锁会直接调用 compareAndSetState(0, 1) 进行cas操作，获取资源，获取不到再调用 acquire() 进入等待队列
    public class ReentrantLock implements Lock, java.io.Serializable {
        
        /** Synchronizer providing all implementation mechanics */
        private final Sync sync;
        public ReentrantLock() {
            // 默认非公平锁
            sync = new NonfairSync();
        }
        public ReentrantLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
        }                          
        
        //公平锁实现
        static final class FairSync extends Sync {
            //公平锁在获取资源时，会直接调用 acuqire()
            final void lock() {
                acquire(1);
            }
            // AbstractQueuedSynchronizer.acquire(int arg)
            public final void acquire(int arg) {
                if (!tryAcquire(arg) &&
                    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                    selfInterrupt();
            }
            protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) {
                    // 1. 和非公平锁相比，这里多了一个判断：是否有线程在等待
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
       
        //非公平锁实现
        static final class NonfairSync extends Sync {
        final void lock() {
            // 2. 和公平锁相比，这里会直接先进行一次CAS，成功就返回了
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        // AbstractQueuedSynchronizer.acquire(int arg)
        public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
    /**
     * Performs non-fair tryLock.  tryAcquire is implemented in
     * subclasses, but both need nonfair try for trylock method.
     */
    final boolean nonfairTryAcquire(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()) {
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

Semaphore

    //与独享锁的区别，信号量，可通过传参控制state的最大值
    //Semaphore的公平锁在自旋的时候会通过 hasQueuedPredecessors() 判断当前任务前面还有别的任务没，没有的话才会被执行
    public class Semaphore implements java.io.Serializable {
       
        private final Sync sync;

        abstract static class Sync extends AbstractQueuedSynchronizer {
            private static final long serialVersionUID = 1192457210091910933L;

            Sync(int permits) {
                setState(permits);
            }

            final int getPermits() {
                return getState();
            }

            //非公平锁，可通过参数 acquires 设置 state 的最大值，从而控制线程最大数量 
            final int nonfairTryAcquireShared(int acquires) {
                for (;;) {
                    int available = getState();
                    int remaining = available - acquires;
                    if (remaining < 0 ||
                        compareAndSetState(available, remaining))
                        return remaining;
                }
            }

           //....
        }

        static final class NonfairSync extends Sync {
            private static final long serialVersionUID = -2694183684443567898L;

            NonfairSync(int permits) {
                super(permits);
            }

            protected int tryAcquireShared(int acquires) {
                return nonfairTryAcquireShared(acquires);
            }
        }

        static final class FairSync extends Sync {
            private static final long serialVersionUID = 2014338818796000944L;

            FairSync(int permits) {
                super(permits);
            }

            //
            protected int tryAcquireShared(int acquires) {
                for (;;) {
                    //判断当前线程是否还有前置任务
                    if (hasQueuedPredecessors())
                        return -1;
                    int available = getState();
                    int remaining = available - acquires;
                    if (remaining < 0 ||
                        compareAndSetState(available, remaining))
                        return remaining;
                }
            }
        }

        public Semaphore(int permits) {
            sync = new NonfairSync(permits);
        }

           public Semaphore(int permits, boolean fair) {
            sync = fair ? new FairSync(permits) : new NonfairSync(permits);
        }

         //加锁
        public void acquire() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }   
       
        //释放锁
        public void release() {
            sync.releaseShared(1);
        }
        
        //判断当前线程前面还有没有为执行的节点任务，有的话返回true
        public final boolean hasQueuedPredecessors() {
            // The correctness of this depends on head being initialized
            // before tail and on head.next being accurate if the current
            // thread is first in queue.
            Node t = tail; // Read fields in reverse initialization order
            Node h = head;
            Node s;
            return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
        }

    }
杭州水果捞｜Java毕业设计成品
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
队列同步器(AbstractQueuedSynchronizer)源码简析
Stay Hungry, Stay Foolish!
06-09 533
文章目录1 AQS概述2 AQS常用方法2 AQS实现分析2.1 同步队列2.1.1 入队2.1.2 出列2.2 同步状态2.2.1 独占式(EXCLUSIVE)2.2.2 共享式(SHARED)2.2.3 超时获取方式2.3 阻塞和唤醒线程2.3.1 parkAndCheckInterrupt2.3.2 unparkSuccessor2.3.3 LockSupport3 总结参考资料 文章后续于https://github.com/zgkaii/CS-Study-Notes更新，欢迎批评指正！ 1 A
老猿说说-AbstractQueuedSynchronizer(1)
热门推荐
老猿说说专栏
10-13 13万+
引导 AbstractQueuedSynchronizer中文翻译叫做同步器，简称AQS,是各种各样锁的基础，比如 说 ReentrantLock、CountDownLatch等等，这些我们经常用的锁底层实现都是AQS,所以 学好AQS对于后面理解锁的实现是非常重要的。 锁章节的内容是这么安排的： AQS源码非常多，我们会分成两个小节来说，先把底层原理弄清楚； 我们平时用不到AQS,只会接触到ReentrantLock、CountDownLatch这些锁，我们以两 个锁为例子，讲解下源码，因为AQS只要弄
AbstractQueuedSynchronizer 源码分析
jijianshuai的专栏
06-26 1852
概述Java的内置锁一直都是备受争议的，在JDK 1.6之前，synchronized这个重量级锁其性能一直都是较为低下，虽然在1.6后，进行大量的锁优化策略,但是与Lock相比synchronized还是存在一些缺陷的：虽然synchronized提供了便捷性的隐式获取锁释放锁机制（基于JVM机制），但是它却缺少了获取锁与释放锁的可操作性，可中断、超时获取锁，且它为独占式在高并发场景下性能大打折扣
AbstractQueuedSynchronizer(AQS)源码分析
技术分享
06-26 371
目录 AQS结构 Node结构 AQS阻塞链表 ReentrantLock ReentrantLock FairSync ReentrantLock NonfairSync Condition CountDownLatch 为了搞清楚AQS到底是有什么特性需要先看看AQS有哪些属性 AQS结构 通过结构图可以看到主要的属性有hea...............
AbstractQueuedSynchronizer源码分析
blogs_broadcast的博客
06-18 819
AbstractQueuedSynchronizer是concurrent工具包的核心抽象类，也是lock,Semaphore、CountDownLatch的基础。（CyclicBarriar内部是通过reentrantlock实现）一.源码分析1.继承AbstractQueuedSynchronizer继承AbstractOwnableSynchronizerpublic abstract cl...
AQS源码分析 (1).pdf
01-22
java锁底层实现，AQS源码分析。我在公司内部分享写的，如果想进一步了解，可以私聊
JUC(一)-AQS源码分析
01-21
AQS源码分析一、锁的介绍1.1 乐观锁/悲观锁1.2 共享锁/独占锁1.3 公平锁/非公平锁1.4 小结二、AQS框架结构介绍2.1 类图2.2 AQS数据结构三、源码详解3.1 acquire源码详解3.2 release源码详解四、从ReentranLock看公平...
Java并发系列之AbstractQueuedSynchronizer源码分析（概要分析）
08-27
**Java并发系列之AbstractQueuedSynchronizer源码分析概要** **1. AbstractQueuedSynchronizer（AQS）的定义与作用** AbstractQueuedSynchronizer（AQS）是Java并发编程中的核心组件，它是一个抽象的、基于FIFO...
Java并发 结合源码分析AQS原理
08-25
在这篇文章中，我们将深入探讨AQS的原理和实现机制，并结合源码分析，了解AQS是如何工作的。 AQS的特点 1. 使用Node实现FIFO队列，用于构建锁或者其他同步装置的基础框架。 2. 利用volatile int state表示状态，...
[隐匿撕源码] 从ReentrantLock剖析AQS
01-20
这篇文章就作为开端，干就完事了。 从ReentrantLock开始 ReentrantLock 是JDK给我们提供的显示锁 在功能上远远强于synchronized 是功能上 不是性能上,随着JDK版本的一代又一代升级 synchronized的性能已经远远不是...
多线程基础(十四)：AbstractQueuedSynchronizer源码分析
dhaibo1986的专栏
11-03 445
文章目录1.类结构及成员变量1.1 类结构和注释1.1.1 类结构1.1.2 注释1.2 成员变量及常量2.构造方法3.关键的内部类3.1 Node3.1.1 注释3.1.2 常量3.1.3 变量3.1.3.1 waitStatus3.1.3.2 其他变量3.1.4 构造函数3.1.4.1 Node()3.1.4.2 Node(Thread thread, Node mode)3.1.4.3 Node(Thread thread, int waitStatus)3.2 ConditionObject4.基
AbstractQueuedSynchronizer源码解析
Cris Blog
12-04 355
AbstractQueuedSynchronizer 源码解析前言1. AQS的基本结构小结 前言 本文主要从源码角度解析AQS(AbstractQueuedSynchronizer)的各个方法。 1. AQS的基本结构 AQS是一个构建锁和其他同步组件（如：ReentranLock，CountDownLatch，Semaphore…）的基础框架。 static final class N...
AbstractQueuedSynchronizer源码分析-java8
iCoding91
05-02 606
1.AbstractQueuedSynchronizer特点总结 类功能宏观描述 此类对实现阻塞锁，依赖FIFO等待队列的同步机制(如semaphores，events等)提供了一个框架。 AQS被作为同步器的辅助子类时，子类应该被定义为非public类型的内部辅助类，以用于实现闭合类的同步属性. CountDownLatch和Semaphore都使用其作为内部辅助类。 此类...
Java并发包之AbstractQueuedSynchronizer源码分析
zjp的博客
03-24 253
AQS(AbstractQueuedSynchronizer)是JUC里非常重要的类，像可重入锁ReentrantLock和CountDownLatch等底层都是有AQS来实现的。由于AQS底层结构比较复杂，如果直接讲源码的话大家可能看的一头雾水，这篇文章就从ReentrantLock的加锁和解锁入手，来一步步解析AQS的源码和底层工作原理。 首先说一下AQS的基本结构，其中维护了一个双向链表，链表中每个节点都包含一个线程，其结构示意图如下： AQS结构示意图 链表中的节点Node有如下几个重要
AbstractQueuedSynchronizer源码深度解析
IT搬砖工在路上
12-30 605
#总体介绍 基于队列的抽象同步器，它是jdk中所有显示的线程同步工具的基础，像ReentrantLock/DelayQueue/CountdownLatch等等，都是借助AQS实现的。Java中已经有了synchronized关键字，那么为什么还需要来这么一出呢？因为AQS能实现更多维度，更多场景的锁机制，例如共享锁（读锁）/基于条件的线程阻塞/可以实现公平和非公平的锁策略/可以实现锁等待的中断，而synchronized关键字由JVM实现，在代码使用层面来说，如果仅仅是使用独占锁，那synchronize
AbstractQueuedSynchronizer源码解析（上）
SuZhan0711
01-02 443
目录一、摘要二、AQS2.1 类定义2.2 基本属性2.2.1 简单属性2.1.2 共享锁和排它锁的区别2.1.3 同步队列属性2.1.4 条件队列的属性2.1.5 Node2.3 Condition三、同步器的状态 一、摘要 队列同步器AbstractQueuedSynchronizer，是用来构建锁或者其他同步组件的基础框架，它使用了一个 int 成员变量表示同步状态，通过内置的 FIFO 队列来完成资源获取线程的排队工作。同步器的设计是基于模板方法模式的，也就是说，使用者需要继承同步器并重写指定的方
Java 1.6 AbstractQueuedSynchronizer源码解析
yuenkin的专栏
03-12 1489
AbstractQueuedSynchronizer源码解析
AQS源码解析：Java锁实现深度剖析
"AQS源码分析"是一份深入研究Java锁底层实现的关键文档，主要关注的是AbstractQueuedSynchronizer（AQS）类的内部工作机制。AQS是Java并发库中的一个重要组件，它提供了一个模板用于同步器的设计，许多Java内置的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杭州水果捞｜Java毕业设计成品

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值