10分钟从源码级别搞懂AQS(AbstractQueuedSynchronizer)

ReentrantLock底层原理与高并发实战避坑指南 ReentrantLock是Java并发编程中实现线程安全的核心工具,其本质是基于AQS(AbstractQueuedSynchronizer)框架构建的可重入同步器,通过Unsafe提供的CAS原子操作与CPU缓存一致性协议(如MESI)协同工作。它区别于synchronized的关键在于显式控制锁的获取、释放、超时、中断及条件等待等生命周期行为,从而在高并发场景下提供更精细的调度能力。技术价值体现在可控阻塞、公平性选择、多条件队列等工程灵活性上,广泛应用于订单幂等校验、分布式ID生成、缓存穿透防护等临界 阅读详情

观看本文大约需要10分钟,可以带着几个问题去观看

  1. 什么是AQS,它是干啥用的?
  2. AQS是使用什么数据结构实现的?
  3. AQS获取/释放同步状态是如何实现的?
  4. AQS除了具有synchronized的功能还拥有什么其他特性?
  5. AQS如何去实现非公平锁、公平锁?
  6. 什么是Condition?它跟AQS是什么关系?

AQS数据结构

什么是AQS呢?

AQS是一个同步队列(阻塞队列),是并发包中的基础,很多并发包中的同步组件底层都使用AQS来实现,比如:ReentrantLock、读写锁、信号量等等...

AQS有三个重要的字段,分别是: head 头节点、tail 尾节点、state 同步状态

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    //头节点
    private transient volatile Node head;
    //尾节点
    private transient volatile Node tail;
    //同步状态
    private volatile int state;   
}    

头尾节点很好理解,因为AQS本身就是个双向链表,那么state同步状态是什么?

AQS中使用同步状态表示资源,然后使用CAS来获取/释放资源,比如设置资源为1,一个线程来尝试获取资源,由于同步状态目前为1,于是该线程CAS替换同步状态为0,成功后表示获取到资源,之后其他线程再来获取资源就无法获取了(状态为0),直到获取资源的线程来释放资源

上述获取/释放资源也可以理解成获取/释放锁

同时三个字段都被volatile修饰,用volatile来保证内存可见性,防止其他线程修改这些数据时当前线程无法感知

通过上面的描述,我们可以知道AQS大概长这样

image.png

当某个线程获取资源失败时,会被构建成节点加入AQS中

节点Node是AQS中的内部类,Node中有些重要的字段一起来看看

static final class Node {
        //节点状态
        volatile int waitStatus;
    
        //前驱节点
        volatile Node prev;
​
        //后继节点
        volatile Node next;
        
        //当前节点所代表的线程
        volatile Thread thread;
​
        //等待队列使用时的后继节点指针
        Node nextWaiter;
}

prev、next、thread应该都好理解

AQS同步队列和等待队列都使用这种节点,当等待队列节点被唤醒出队时,方便加入同步队列

nextWaiter就是用于节点在等待队列中指向下一个节点

waitStatus表示节点的状态

不太理解状态不要紧,我们后文遇到再说

经过上面的描述,节点大概是长成这样的

image.png

AQS中还有另外一个内部类ConditionObject用于实现等待队列/条件队列,我们后文再来说说

AQS中可以分为独占、共享模式,其中这两种模式下还可以支持响应中断、纳秒级别超时

独占模式可以理解为同一时间只有一个线程能够获取同步状态

共享模式可以理解为可以有多个线程能够获取同步状态,方法中常用shared标识

方法中常用acquire标识获取同步状态,release标识释放同步状态

image.png

这些方法都是模板方法,规定流程,将具体的实现留给实现类去做(比如获取同步状态,该如何获取交给实现类去实现)

独占式

独占式实际就是时刻上只允许一个线程独占该资源,多线程竞争情况下也只能有一个线程获取同步状态成功

获取同步状态

不响应中断的独占获取和响应中断、超时的类似,我们以acquire为例查看源码

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

tryAcquire 方法用于尝试获取同步状态,参数arg表示获取多少同步状态,获取成功返回true 则会退出方法,留给实现类去实现

addWaiter

addWaiter(Node.EXCLUSIVE) 构建独占式节点,并用CAS+失败重试的方式加入AQS的末尾

    private Node addWaiter(Node mode) {
        //构建节点
        Node node = new Node(Thread.currentThread(), mode);
        //尾节点不为空则CAS替换尾节点
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //尾节点为空或则CAS失败执行enq
        enq(node);
        return node;
    }
    private Node enq(final Node node) {
        //失败重试
        for (;;) {
            Node t = tail;
            //没有尾节点 则CAS设置头节点(头尾节点为一个节点),否则CAS设置尾节点
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

enq方法主要以自旋(中途不会进入等待模式)去CAS设置尾节点,如果AQS中没有节点则头尾节点为同一节点

由于添加到尾节点存在竞争,因此需要用CAS去替换尾节点

image.png

acquireQueued

acquireQueued方法主要用于AQS队列中的节点来自旋获取同步状态,在这个自旋中并不是一直执行的,而是会被park进入等待

final boolean acquireQueued(final Node node, int arg) {
    //记录是否失败
    boolean failed = true;
    try {
        //记录是否中断过
        boolean interrupted = false;
        //失败重试 
        for (;;) {
            //p 前驱节点
            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);
    }
}

在尝试获取同步状态前有个条件p == head && tryAcquire(arg):前驱节点是头节点

因此AQS中的节点获取状态是FIFO的

但即使满足前驱节点是头节点,并不一定就能获取同步状态成功,因为还未加入AQS的线程也可能尝试获取同步状态,以此来实现非公平锁

那如何实现公平锁呢?

在尝试获取同步状态前都加上这个条件就行了呗!

再来看看shouldParkAfterFailedAcquire 获取同步状态失败后应该停放

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //前驱节点状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //前驱节点状态是SIGNAL 说明前驱释放同步状态回来唤醒 直接返回
        return true;
    if (ws > 0) {
        //如果前驱状态大于0 说明被取消了,就一直往前找,找到没被取消的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        //排在没被取消的节点后面
        pred.next = node;
    } else {
        //前驱没被取消,而且状态不是SIGNAL CAS将状态更新为SIGNAL,释放同步状态要来唤醒
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

实际上是park前的一些准备

再来看看 parkAndCheckInterrupt ,用工具类进入等待状态,被唤醒后检查是否中断

private final boolean parkAndCheckInterrupt() {
        //线程进入等待状态... 
        LockSupport.park(this);
         //检查是否中断 (会清除中断标记位)
        return Thread.interrupted();
}

在acquireQueued的中如果未获取同步状态并且抛出异常,最终会执行cancelAcquire取消

当感知到中断时返回true回去,来到第一层acquire方法执行selfInterrupt方法,自己中断线程

acquire流程图:

  1. 先尝试获取同步状态失败则CAS+失败重试添加到AQS末尾
  1. 前驱节点为头节点且获取同步状态成功则返回,否则进入等待状态等待唤醒,唤醒后重试
  1. 在2期间发生异常取消当前节点

image.png

释放同步状态

先进行释放同步状态,成功后头节点状态不为0 唤醒下一个状态不是被取消的节点

public final boolean release(int arg) {
    //释放同步状态
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //唤醒下一个状态不大于0(大于0就是取消)的节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}
响应中断

acquireInterruptibly用于响应中断的获取同步状态

public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    //查看是否被中断,中断抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

doAcquireInterruptibly 与原过程类似,就是在被唤醒后检查到被中断时抛出中断异常

    private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    //被唤醒后检查到被中断时抛出中断异常
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

响应中断的获取同步状态被中断时会直接抛出中断异常,而不响应的是自己中断

响应超时

响应超时的获取同步状态使用tryAcquireNanos 超时时间为纳秒级别

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

可以看出响应超时同时也会响应中断

doAcquireNanos也与原过程类似

    private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                //还有多久超时
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)
                    //已超时
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                    //大于1ms
                    nanosTimeout > spinForTimeoutThreshold)
                    //超时等待
                    LockSupport.parkNanos(this, nanosTimeout);
                //响应中断
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

响应超时在自旋期间会计算还有多久超时,如果大于1ms就等待对应的时间,否则就继续自旋,同时响应中断

共享

共享式就是允许多个线程同时获取一定的资源,比如信号量、读锁就是用共享式实现的

其实共享式与独占式流程类似,只是尝试获取同步状态的实现不同

我们用个获取同步状态的方法来说明

共享式获取同步状态使用acquireShared

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

tryAcquireShared 尝试获取同步状态,参数arg表示获取多少同步状态,返回剩余可获取同步状态的数量

如果剩余可获取同步状态数量小于0 说明 未获取成功进入doAcquireShared

    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) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        //如果前驱节点为头节点 并且 获取同步状态成功 设置头节点
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                //获取失败进入会等待的自旋
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

响应中断、超时等方法也与独占式类似,只是有些设置细节不同

Condition

上文曾说过AQS充当阻塞(同步)队列,Condition来充当等待队列

AQS的内部类ConditionObject就是Condition的实现,它充当等待队列,用字段记录头尾节点

public class ConditionObject implements Condition{
        //头节点
        private transient Node firstWaiter;
        //尾节点
        private transient Node lastWaiter;  
}

节点之间使用nextWait指向下一个节点,形成单向链表

image.png

同时提供await系列方法来让当前线程进入等待,signal系列方法来唤醒

        public final void await() throws InterruptedException {
            //响应中断
            if (Thread.interrupted())
                throw new InterruptedException();
            //添加到末尾 不需要保证原子性,因为能指向await一定是获取到同步资源的
            Node node = addConditionWaiter();
            //释放获取的同步状态
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            //不在同步队列就park进入等待
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //被唤醒后自旋获取同步状态
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            //取消后清理
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

await主要将节点添加到condition object末尾,释放获取的同步状态,进入等待,唤醒后自旋获取同步状态

signal的主要逻辑在transferForSignal中

    final boolean transferForSignal(Node node) {
        //CAS修改节点状态 失败返回 变成取消
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        //加入AQS末尾
        Node p = enq(node);
        int ws = p.waitStatus;
        //CAS将节点状态修改为SIGNAL 成功则唤醒节点
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }

signal 主要把状态从-2condition 修改为 0(失败则取消节点), 然后加入AQS的末尾,最后再将状态该为-1 signal,成功则唤醒节点

为什么加入AQS末尾还是使用enq去CAS+失败重试操作保证原子性呢?

因为ConditionObject允许有多个,也就一个AQS同步队列可能对应多个Condition等待(条件)队列

image.png

总结

本篇文章以AQS为核心,深入浅出的描述AQS实现的数据结构、设计思想、获取/释放同步资源的源码级流程、Condition等

AQS使用头尾节点来实现双向队列,提供同步状态和获取/释放同步状态的模板方法来实现阻塞(同步)队列,并且这些字段使用volatile修饰,保证可见性与读取的场景配合,不需要保证原子性,在写的场景下常用CAS保证原子性

AQS与Condition使用相同类型的节点,在AQS中节点维护成双向链表,在Condition中节点维护成单向链表,节点除了维护指向关系,还需要记录对应线程和节点状态

AQS分为独占式和共享式,使用独占式时只允许一个线程获取同步状态,使用共享式时则允许多个线程获取同步状态;其中还提供响应中断、等待超时的类似方法

获取同步状态:先尝试获取同步状态,如果失败则CAS+失败重试的方式将节点添加到AQS末尾,等待被前驱节点唤醒;只有当前驱节点为头节点并且获取同步状态成功才返回,否则进入等待,被唤醒后继续尝试(自旋);在此期间如果发生异常,在抛出异常前会取消该节点

释放同步状态:尝试释放同步状态,成功后唤醒后继未被取消的节点

在获取同步状态时,被唤醒后会检查中断标识,如果是响应中断的则会直接抛出中断异常,不响应的则是在最外层自己中断

响应超时时,在自旋获取同步状态期间会计时,如果距离超时小于1ms就不进入等待的自旋,大于则再等待对应时间

AQS充当阻塞队列,Condition充当它的等待队列来实现等待/通知模式,AQS的内部类ConditionObject在await时会加入Condition末尾并释放同步状态进入等待队列,在被唤醒后自旋(失败会进入等待)获取同步状态;在single时会CAS的将condition头节点并加入AQS尾部再去唤醒(因为一个AQS可能对应多个Condition因此要CAS保证原子性)

大厂Java面试八股文解析与高频考点实战 Java面试中的八股文考察是验证开发者基本功的重要手段,涉及JVM、并发编程、Spring框架等核心技术原理。理解HashMap底层实现、AQS同步机制等核心概念,不仅能应对面试,更能提升实际工程中的问题解决能力。大厂通过这类标准化问题评估候选人的知识体系完整性和抗压能力,尤其在分布式系统、高并发场景下,对源码级理解和性能优化有更高要求。掌握JVM内存模型、MySQL索引优化等高频考点,结合Redis、Spring等热词相关的实战经验,是提升面试成功率的关键。 阅读详情

相关推荐

Java后端高效学习路径:以面试场景驱动核心技术深度掌握

1. 先搞清楚“进步最快”到底指什么,别被标题带偏 看到“进步最快”这种标题,很多人第一反应是找捷径、找速成秘籍。但以我十多年的经验来看,对于Java后端开发,尤其是面向7月这种求职季,所谓的“最快”路径,从来不是指时间最短,而是 单位时间内投入产出比最高、方向最准、最不容易走回头路 的方法。 这个标题里罗列了场景题、八股文、Java基础、AI大模型、JVM、MySQL、Spring……看起来包罗万象。如果你真按这个清单从头到尾学一遍,大概率会陷入“什么都想学,什么都学不深”的困境,时间花了,面试一聊就露怯

weixin_30268921的博客 377

Java面试突击指南:7天构建核心知识体系与高频考点解析

在Java技术生态中,掌握核心原理与工程实践是开发者应对技术面试与解决实际问题的关键。理解JVM内存模型、垃圾回收机制等底层原理,是优化应用性能、排查线上问题的基石。并发编程中的锁机制、线程池与AQS框架,则为构建高并发、高可用的分布式系统提供了核心工具。这些技术通过Spring等主流框架,广泛应用于电商、金融等需要处理高并发事务与复杂业务逻辑的场景。本文聚焦Java面试中的高频考点与实战场景,围绕HashMap、ConcurrentHashMap等热词,提供了一套高效的突击策略与知识串联方法,帮助开发者在

weixin_34074740的博客 465

Java后端面试7天冲刺:从知识点记忆到问题解决能力

如果你正在准备 Java 后端面试,感觉知识点又多又杂,不知道从哪开始,或者刷了很多题但回答时总感觉不成体系,那这篇文章就是为你准备的。我见过太多候选人,基础概念背得滚瓜烂熟,但一遇到“为什么”和“怎么做”的场景题就卡壳。面试官真正想听的,不是你复述八股文,而是你如何用这些知识解决实际问题。这篇文章不会给你一份新的、更长的八股文清单,而是帮你用 7 天时间,把 Java 基础、并发、JVM、MySQL、Spring 这些核心模块,从“知识点记忆”升级为“问题解决能力”。我会告诉你每个模块最高频的考点是什么,

weixin_34185512的博客 358

Java后端面试7天速成:HashMap、JVM、并发、MySQL、Redis、Spring核心考点精讲

最近在帮团队做技术面试复盘,发现很多同学在准备后端开发面试时,普遍存在几个痛点:知识点零散不成体系,面对“HashMap为什么线程不安全”、“JVM内存模型”、“Spring Bean生命周期”这类高频问题,只能背答案,不理解背后的设计思想和应用场景;项目经验描述不清,无法将技术点与实际业务结合;面对“如何设计一个高并发秒杀系统”这类场景题,更是无从下手。 针对这些痛点,我结合近期的面试官经验和一线大厂的最新考察趋势,整理了一份 《Java后端开发面试急救包》 。这份计划的核心是 “每天2小时,7天系统突击

weixin_30268921的博客 386

FPGA时钟设计陷阱:为什么你的MRCC引脚总触发Place 30-675错误?

本文深入解析FPGA开发中常见的Place 30-675错误,揭示MRCC引脚与时钟资源分配的关键问题。通过对比MRCC与普通IO引脚特性,分析错误根源,并提供时钟约束优化、IP核重配置和手动布局三套解决方案,帮助工程师规避时钟设计陷阱,提升FPGA系统稳定性。

potato的博客 694

用Matlab机器人工具箱搞定六轴机械臂建模:从DH参数到3D可视化(附完整代码)

本文详细介绍了如何使用Matlab机器人工具箱进行六轴机械臂建模,涵盖从DH参数转换到3D可视化的完整流程。通过正运动学验证、逆解计算和工作空间分析等实战案例,帮助开发者快速掌握机械臂建模技巧,并提供性能优化建议和完整代码示例。

weixin_28733637的博客 361

Java面试高效突击指南:核心模块、高频考点与实战策略

在软件开发领域,Java作为主流编程语言,其技术栈涵盖基础语法、集合框架、并发编程、JVM原理及主流框架等核心模块。理解这些模块的原理是构建稳定、高效应用的基础。例如,并发编程中的线程池通过复用线程资源提升系统性能,其核心参数和工作流程是面试高频考点;JVM的垃圾回收机制则关乎应用的内存管理与性能表现。掌握这些核心技术不仅能解决实际工程中的性能瓶颈和内存泄漏问题,更能帮助开发者在面试中系统性地展示知识体系。本文聚焦于Java面试中的核心模块与高频考点,提供了一套针对性的高效复习策略,帮助求职者快速构建知识框

weixin_33866037的博客 353

Nangate 45nm FreePDK开源工艺库:从RTL到GDSII全流程实战

在数字IC设计中,标准单元库是连接逻辑综合与物理实现的基石,它定义了每个单元的逻辑功能、时序延迟与物理尺寸。开源EDA工具链的成熟,使得个人也能借助免费工艺套件完整跑通芯片设计流程。Nangate 45nm FreePDK作为一套经典的开源工艺库,凭借结构清晰、配套完善的特性,成为学习数字后端和时序收敛的理想训练场。从综合工具Yosys读取Liberty文件进行逻辑映射,到OpenROAD执行布局布线与时钟树综合,再到使用OpenSTA分析关键路径延迟,这套流程涵盖了数字设计最核心的环节。通过亲手操作,开发

weixin_29168393的博客 282

Java秋招突击:高频考点与实战策略精讲

在Java后端开发领域,掌握核心原理是构建高性能、高可用系统的基石。理解JVM内存模型、垃圾回收机制、并发编程模型以及数据库事务与索引原理,是每一位开发者必须跨越的技术门槛。这些底层知识不仅决定了代码的执行效率,更直接关系到系统的稳定性和扩展性。从技术价值来看,深入理解Java并发中的AQS同步器框架和synchronized锁升级机制,能够帮助开发者编写出更安全、高效的多线程程序;而精通MySQL的B+树索引结构与事务隔离级别,则是进行数据库性能优化和保证数据一致性的关键。在实际应用场景中,无论是应对高并

weixin_34396103的博客 386

零件边界线提取处理原理详解

该程序提出了一种高效的点云边界提取方法,通过三阶段处理流程实现零件几何特征的精确提取。首先采用RANSAC算法进行坐标系标准化,包括主平面检测、点云分割和双重旋转对齐。接着使用凹包算法和RANSAC直线拟合提取底面边界。最后通过多方向密度切片分析(Z向100片、X向50片),自动选择高密度切片进行边界提取和直线拟合。算法具有鲁棒性强、处理效率高(支持OpenMP并行计算)和参数可配置等特点,能有效提取零件的几何边界特征,为后续质量检测提供基础。实验结果显示该方法能准确提取零件的多方向边界线。

weixin_45196569的博客 434

STM32步进电机控制三大方案:GPIO/定时器/PWM深度对比

步进电机控制是嵌入式运动控制的基础技术,其核心在于精确生成脉冲(PUL)、方向(DIR)和使能(EN)三路数字信号。原理上,脉冲频率决定转速,脉冲数量决定位置,方向电平决定转向,而使能时序保障驱动器可靠启停。该技术具有高定位精度、开环稳定性与低成本优势,广泛应用于3D打印机、CNC设备、自动化产线等场景。在STM32平台实现时,需兼顾硬件隔离设计(如6N137光耦)、HAL库抽象封装及实时性约束。本文围绕GPIO模拟、定时器中断与PWM比较输出三种主流方法,系统剖析其时序机制、CPU开销、抗干扰能力与工业适

weixin_35755640的博客 88

Java技术栈面试核心:从基础到分布式系统实战

Java作为企业级开发的主流语言,其技术栈涵盖从基础语法到分布式系统的完整体系。理解JVM内存模型、并发编程原理和Spring框架设计是构建Java技术深度的基础。在实际工程中,这些技术通过MySQL索引优化、Redis持久化策略等数据存储方案落地,最终支撑起分布式系统下的CAP理论实践。本文以Java技术面试为切入点,剖析如何将语言特性、框架原理与系统设计相结合,特别针对AQS并发机制、Spring循环依赖解决等高频考点进行深度解析,帮助开发者建立完整的知识图谱应对现代技术面试的网状考察模式。

weixin_33994429的博客 294

3.嵌入式控制器EC学习,源码框架(60/64端口)(一)

服务函数剖析 上一篇讲到while循环会一直查询十六个标志位是否满足要求,一旦其中某个标志位为1时,程序将会执行相应的服务函数,而执行服务函数是通过函数指针(service_table[ _R1 ])();来实现的。接下来我们分别来看看这十六个服务函数分别包含了哪些内容。 16个函数的函数名如下: const FUNCT_PTR_V_V code service_table[16] = { // Hi-Level Service Service_PCI, // Host 6

qq_30135687的博客 4160

Java面试短期高效突击攻略:核心考点与实战话术

在软件工程实践中,构建稳固的知识体系是应对技术挑战的基础。其核心原理在于将零散的技术点组织成逻辑自洽的框架,从而在面对复杂问题时能快速定位与系统阐述。这一方法在技术面试场景中价值尤为突出,它能高效展示候选人的问题解决能力与知识深度。无论是准备求职面试还是进行技术复盘,掌握核心概念的框架化表达都至关重要。本文聚焦于Java技术栈的高频面试场景,深入剖析了包括HashMap、JVM内存模型在内的关键热词,以及并发编程、Spring事务等核心模块的应答逻辑与实战话术,旨在帮助开发者在有限时间内构建最具针对性的面试

weixin_30340819的博客 352

EMB电子机械制动系统和EHB电子液压制动系统控制功能的对比

EMB电子机械制动系统相比EHB液压制动系统具有显著优势:响应速度更快(<100ms)、控制精度更高(±2N·m)、能实现单轮独立控制,支持0.1%级制动力调节。在ABS、ESC等安全功能上表现更优,制动平顺性和NVH性能更好,同时提升能量回收效率15%-20%。特别适合智能驾驶需求,可使AEB等系统响应时间缩短50ms,紧急制动距离减少1米以上。EMB系统完美契合高阶自动驾驶对快速响应和精准控制的要求。

m0_59012156的博客 890

用 MATLAB 实现鼻子和嘴的检测

为了方便起见,这里我们使用了 CascadeObjectDetector 中自带的 haarcascade_frontalface_alt2.xml 文件,该文件包含了多个包含鼻子和嘴的样本图像。其中 bbox 变量表示检测到的所有鼻子和嘴的边界框信息。在图像处理中,鼻子和嘴的检测是十分重要的一项任务。本文将介绍如何使用 MATLAB 实现鼻子和嘴的检测,并提供相应的源代码。然后,我们可以调用之前创建的 detector 对象来进行鼻子和嘴的检测。综上所述,我们可以使用以上代码实现鼻子和嘴的检测。

qq_39605374的博客 258

2026 Java面试突击:高频考点与场景化应答实战指南

Java作为企业级应用开发的核心语言,其技术体系涵盖内存管理、并发编程和框架设计等关键领域。理解JVM内存模型和垃圾回收机制是优化应用性能的基础,而并发编程中的线程安全、锁机制和线程池管理直接影响系统稳定性。这些技术原理在高并发、分布式场景下具有重要价值,如电商秒杀、金融交易等业务都需要可靠的Java技术栈支撑。本文聚焦HashMap实现原理、volatile关键字应用等高频考点,结合线程池配置实战和OOM排查案例,帮助开发者快速掌握面试核心要点。通过识别关键热词和建立知识点关联,提升技术表达和问题解决能力

weixin_34288121的博客 412

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Java面试突击:高频问题驱动的高效知识体系构建与实战策略

在Java后端开发领域,构建扎实的知识体系是应对技术面试和工程实践的基础。其核心原理在于将零散的技术点通过核心问题串联起来,形成相互关联的知识网络,而非孤立记忆。这种以问题为导向的学习方法具有显著的技术价值,它能帮助开发者快速定位知识盲区,并建立从原理到应用的通路。在实际应用场景中,面对诸如高并发、JVM调优、数据库优化等复杂问题时,这种结构化的知识网络能有效指导解决方案的设计与实施。本文聚焦于Java面试准备,通过剖析HashMap、并发编程等高频面试问题,深入探讨如何利用‘问题树’方法,将Java基础、

weixin_30493401的博客 372

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Java多线程实战:从JMM、锁优化到高并发秒杀落地

Java多线程是并发编程的核心基础,其本质是理解CPU指令重排、JVM内存模型(JMM)与操作系统线程调度的协同机制。volatile关键字通过内存屏障保障可见性与有序性,但无法保证复合操作原子性;synchronized和ReentrantLock的锁升级、AQS队列、公平性策略直接影响高并发场景吞吐与延迟。在电商秒杀、支付幂等、分布式锁等真实业务中,需结合ConcurrentHashMap扩容机制、CAS优化、Redis Lua原子性及租约续期等技术权衡一致性与性能。本文聚焦生产级多线程问题诊断与调优,

weixin_33923762的博客 364

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Java面试突击:从散点记忆到体系构建的高效备战策略

在软件开发领域,构建扎实的知识体系是工程师应对复杂技术挑战的核心能力。其原理在于将离散的技术点通过逻辑关联形成网络化认知,从而提升问题分析与解决效率。这种体系化思维的技术价值在于,它能帮助开发者从记忆知识点升级为理解技术脉络,在面对综合性场景时快速定位并串联解决方案。尤其在Java技术栈中,高频的面试场景如高并发处理、JVM性能调优、数据库优化等,都要求候选人不仅能回答“是什么”,更能阐述“如何关联”与“为何如此”。本文聚焦于Java面试准备,通过“问题-知识-场景”三维框架,将核心的并发编程、JVM机制、

452

Java面试突击指南:高频考点速成与场景题攻坚策略

在软件工程领域,构建高效、可靠的系统离不开对核心编程范式和底层原理的深刻理解。Java作为主流后端开发语言,其知识体系庞大,面试考察往往聚焦于基础原理、并发模型、JVM机制、数据库优化及框架设计等核心模块。理解这些技术的底层原理,如JVM内存管理与垃圾回收机制、MySQL的索引数据结构与事务隔离级别,是评估开发者工程能力的关键。这些知识不仅能解决日常开发中的性能瓶颈与并发安全问题,更在高并发、分布式等复杂业务场景中发挥核心价值。本文聚焦Java面试高频考点,通过‘以题带学’的方式,直击HashMap、线程池

weixin_34268169的博客 462

Java面试八股文笔记:从HashMap到JVM,构建面试知识地图

在Java后端开发中,面试准备往往绕不开对基础原理的深挖。无论是HashMap在JDK 8中的红黑树优化,还是JVM内存区域与垃圾回收机制,这些知识点看似零散,实则共同构成了Java工程师的技术底座。理解原理背后的设计动机——比如为何链表过长要转为红黑树、为何ConcurrentHashMap采用CAS+synchronized——比死记结论更能应对面试官的连环追问。与此同时,并发编程中的线程池参数、AQS队列、MySQL索引与事务隔离级别、Redis缓存一致性等问题,都是高频场景题的核心。将这类知识系统化

weixin_34185320的博客 378

Java面试突击指南:高效备战核心考点与实战验证

在软件开发领域,Java作为主流编程语言,其技术栈的深度和广度是面试考察的重点。理解Java虚拟机(JVM)的内存管理、垃圾回收机制以及并发编程的核心原理,是构建高性能、高可用系统的基石。这些底层知识不仅决定了程序的运行效率,也直接影响着系统的稳定性和扩展性。从技术价值看,掌握JVM调优和并发控制能有效解决线上OOM、死锁等常见生产问题,提升应用性能。在应用场景上,无论是互联网高并发业务,还是企业级复杂系统,扎实的Java基础、对Spring框架的深入理解以及对MySQL索引与事务的优化能力,都是工程师的核

weixin_34232744的博客 416

Java面试体系化攻略:从知识网络构建到实战场景解析

在软件工程领域,构建稳固的知识体系是工程师应对复杂挑战的基石。其核心原理在于将离散的技术点通过逻辑关联形成网络化认知,这不仅能深化对单一概念(如数据结构或并发模型)的理解,更能提升解决综合性问题的能力。这种体系化思维的技术价值在于,它使开发者能够从底层机制(如JVM内存管理)推理出高层应用表现,并高效应对高并发、分布式等真实场景。尤其在Java开发者的职业成长与面试准备中,面对海量的八股文和层出不穷的场景题,系统化的知识网络构建成为破局关键。本文聚焦于如何将Java基础、并发编程、JVM、MySQL及Spr

weixin_30243533的博客 391

Java面试突击:框架化记忆与场景拆解的高效备战策略

在软件工程实践中,扎实的计算机基础与高效的问题解决能力是应对技术挑战的核心。理解底层原理,如并发编程中的原子性、可见性与有序性,是构建稳定系统的基石。这些概念源于Java内存模型(JMM),它们共同保障了多线程环境下数据的一致性与程序执行的正确性,其技术价值在于为高并发场景提供了可靠的理论支撑。在实际应用场景中,无论是构建电商秒杀系统还是实现分布式任务调度,都需要基于这些原理进行技术选型与架构设计。本文聚焦于Java后端开发,针对面试中高频出现的JVM内存模型、MySQL索引优化等核心知识点,提供了一套框架

weixin_34161064的博客 579
上一篇: 5个案例和流程图让你从0到1搞懂volatile关键字!
下一篇: 12张图一次性搞懂高性能并发容器ConcurrentLinkedQueue!
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值