1.java中的公平k公公平非公平锁不怕有的线程一直得不到执行吗
2.ReentrantLock 源码解析 | 京东云技术团队
3.ZookeeperApach Curator 框架源码分析：初始化过程（一）Ver 4.3.0
4.面试突击46：公平锁和非公平锁有什么区别？
5.ReentrantLock源码详细解析
6.JUC架构-ReentrantLock的公平与非公平

java中的非公平锁不怕有的线程一直得不到执行吗

       首先来看公平锁和非公平锁，我们默认使用的锁源锁锁是非公平锁，只有当我们显示设置为公平锁的平锁情况下，才会使用公平锁，和非下面我们简单看一下公平锁的源码源码，如果等待队列中没有节点在等待，公平k公公平aqs源码流程分析则占有锁，锁源锁如果已经存在等待节点，平锁则返回失败，和非由后面的源码程序去将此线程加入等待队列

       通过上面的代码，我们可以推断，公平k公公平当使用公平锁的锁源锁情况下，并且同一个线程的平锁执行时间较长时，线程内部进行了多次的和非锁的获取和释放，效率非常低下，源码可以参加Lesson8中的demo：

       demo Lesson8LockIntPerform:在使用ReentrantLock加非公平锁的情况下个线程循环下单数为：

       demo Lesson8LockIntPerform:在使用ReentrantLock加非公平锁的情况下个线程循环下单数为：

       demo Lesson8LockFairIntPerform:在使用ReentrantLock加公平锁的情况下个线程循环下单数为：

       demo Lesson8LockFairIntPerform:在使用ReentrantLock加公平锁的情况下个线程循环下单数为：

       上面的demo中，在使用公平锁的情况下性能明显降低，非公平锁的性能是公平锁性能的几十倍以上，这和公平锁每次试图占有锁时，都必须先要进等待队列，按照FIFO的顺序去获取锁，因此在我们的实验情景下，使用公平锁的线程进行了频繁切换，而频繁切换线程，性能必然会下降的厉害，这也告诫了我们在实际的开发过程中，在需要使用公平锁的情景下，务必要考虑线程的切换频率。

       接下来我们来看一下读写锁，通过看读写锁的实现源码，我们可以发现，读锁和写锁共用同一个等待队列，那么在采用非公平锁的情况下，如果读锁的线程执行时间比较长，并且读锁的并发比较高，那么写锁的线程便永远都拿不到锁，那么实际的情况会不会是这样呢？

       demo Lesson3WriteReadLock:此demo的读线程在不断的占用读锁，按照推论，写锁的线程是没有机会获取到锁的，但是实际情况是写锁的线程可以正常的获取到锁，那么是什么原因使得写锁的线程可以获取到锁的了？通过查看源代码，会发现有这样的一个方法：

       上面的方法，实现了一个新的读线程获取锁的中断，它会读取等待队列中下一个等待锁的线程，如果它是获取写锁的线程，那么此方法返回为真，调用它的程序会把这个试图获取读锁的线程加入到等待队列，从而终止了读线程一直都在占有锁的情况。

ReentrantLock 源码解析 | 京东云技术团队

       并发指同一时间内进行了多个线程。并发问题是多个线程对同一资源进行操作时产生的问题。通过加锁可以解决并发问题，框架源码解析视频ReentrantLock 是锁的一种。

       1 ReentrantLock

       1.1 定义

       ReentrantLock 是 Lock 接口的实现类，可以手动的对某一段进行加锁。ReentrantLock 可重入锁，具有可重入性，并且支持可中断锁。其内部对锁的控制有两种实现，一种为公平锁，另一种为非公平锁.

       1.2 实现原理

       ReentrantLock 的实现原理为 volatile+CAS。想要说明 volatile 和 CAS 首先要说明 JMM。

       1.2.1 JMM

       JMM (java 内存模型 Java Memory Model 简称 JMM) 本身是一个抽象的概念，并不在内存中真实存在的，它描述的是一组规范或者规则，通过这组规范定义了程序中各个变量的访问方式.

       由于 JMM 运行的程序的实体是线程。而每个线程创建时 JMM 都会为其创建一个自己的工作内存 (栈空间), 工作内存是每个线程的私有数据区域。而 java 内存模型中规定所有的变量都存储在主内存中，主内存是共享内存区域，所有线程都可以访问，但线程的变量的操作 (读取赋值等) 必须在自己的工作内存中去进行，首先要将变量从主存拷贝到自己的工作内存中，然后对变量进行操作，操作完成后再将变量操作完后的新值写回主内存，不能直接操作主内存的变量，各个线程的工作内存中存储着主内存的变量拷贝的副本，因不同的线程间无法访问对方的工作内存，线程间的通信必须在主内存来完成。

       如图所示：线程 A 对变量 A 的操作，只能是从主内存中拷贝到线程中，再写回到主内存中。

       1.2.2 volatile

       volatile 是 JAVA 的关键字用于修饰变量，是 java 虚拟机的轻量同步机制，volatile 不能保证原子性。 作用：

       作用：CAS 会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读 - 改 - 写操作。

       1.2.4 AQSAQS 的全称是 AbstractQueuedSynchronizer（抽象的队列式的同步器），AQS 定义了一套多线程访问共享资源的同步器框架。

       AQS 主要包含两部分内容：共享资源和等待队列。AQS 底层已经对这两部分内容提供了很多方法。

       2 源码解析

       ReentrantLock 在包 java.util.concurrent.locks 下，实现 Lock 接口。

       2.1 lock 方法

       lock 分为公平锁和非公平锁。

       公平锁：

       非公平锁：上来先尝试将 state 从 0 修改为 1，如果成功，代表获取锁资源。如果没有成功，调用 acquire。state 是 AQS 中的一个由 volatile 修饰的 int 类型变量，多个线程会通过 CAS 的方式修改 state，在并发情况下，只会有一个线程成功的禾鲜配送源码修改 state。

       2.2 acquire 方法

       acquire 是一个业务方法，里面并没有实际的业务处理，都是在调用其他方法。

       2.3 tryAcquire 方法

       tryAcquire 分为公平和非公平两种。

       公平：

       非公平：

       2.4 addWaiter 方法

       在获取锁资源失败后，需要将当前线程封装为 Node 对象，并且插入到 AQS 队列的末尾。

       2.5 acquireQueued 方法

       2.6 unlock 方法

       释放锁资源，将 state 减 1, 如果 state 减为 0 了，唤醒在队列中排队的 Node。

       3 使用实例

       3.1 公平锁

       1. 代码：

       2. 执行结果：

       3. 小结：

       公平锁可以保证每个线程获取锁的机会是相等的。

       3.2 非公平锁

       1. 代码：

       2. 执行结果：

       3. 小结：

       非公平锁每个线程获取锁的机会是随机的。

       3.3 忽略重复操作

       1. 代码：

       2. 执行结果：

       3. 小结：

       当线程持有锁时，不会重复执行，可以用来防止定时任务重复执行或者页面事件多次触发时不会重复触发。

       3.4 超时不执行

       1. 代码：

       2. 执行结果：

       3. 小结：

       超时不执行可以防止由于资源处理不当长时间占用资源产生的死锁问题。

       4 总结

       并发是现在软件系统不可避免的问题，ReentrantLock 是可重入的独占锁，比起 synchronized 功能更加丰富，支持公平锁实现，支持中断响应以及限时等待等，是处理并发问题很好的解决方案。

ZookeeperApach Curator 框架源码分析：初始化过程（一）Ver 4.3.0

       Curator是由Netflix开源的一款用于简化Zookeeper客户端开发的工具，它提供了一套高级别API，使得开发者可以更简单易懂地实现分布式应用程序。Curator构建在Zookeeper原生客户端之上，提供了连接重试、异常处理、节点监听等常见功能，减轻了开发者的工作负担。Curator由多个模块组成，其中curator-framework和curator-recipes是最常用的部分，此外还提供了分布式锁等功能。

       Curator的最新版本为5.X系列，不再支持ZK 3.4.X及之前的版本。主要的改动在5.X系列中，原因包括代码重构、API调整等，导致不兼容之前的版本。

       Curator的下载地址可以通过Maven依赖管理或Apache官方网站获取。要开始使用Curator，需要搭建Zookeeper集群环境，详细部署过程可参考其他文章。

       引入Curator依赖后，开发者可以使用CuratorFrameworkFactory构建实例，通过此实例连接Zookeeper集群并执行分布式操作，如分布式锁等。Curator内部实现了重试策略、连接管理等，使得操作更为便捷且稳定。黄金版源码

       Curator提供了可重入锁（公平锁）的示例，开发者可以通过简单的代码实现分布式锁功能。初始化CuratorFramework实例的过程包括设置连接参数、构建实例、启动连接等步骤，内部会处理网络重连、异常处理等逻辑。

       在Curator的初始化过程中，CuratorFrameworkImpl是核心类，它负责构建与Zookeeper集群的连接，并封装了一系列关键组件，如连接管理、异常检测、负载均衡等。CuratorZookeeperClient类负责Zookeeper客户端的封装和调用。

       CuratorFrameworkImpl的启动过程涉及初始化连接状态管理器、启动客户端连接、执行后台操作等关键步骤。通过CAS操作确保线程安全，并在异常情况下自动重试连接。

       连接状态管理器（ConnectionStateManager）负责维护连接状态并处理状态变更通知，确保在状态改变时能够及时通知到监听器。通知机制包括注册一次性监听器、注册CuratorListener和ConnectionStateListener，以及处理未处理的错误。

       Curator的会话管理机制包括连接状态检查和重连策略，确保在连接断开后能够自动恢复连接。在状态变更时，连接状态管理器会通知所有注册的监听器，执行相应的回调逻辑。

       Curator还提供了缓存机制，用于保存节点数据并在数据发生变化时进行更新。此外，Curator支持多次注册监听器，确保在连接断开后能够重新注册监听器，以避免丢失监听事件。

       通过上述分析，Curator为开发者提供了高效、稳定的Zookeeper客户端实现，简化了分布式应用程序的开发过程。在实际应用中，开发者需要根据项目需求选择合适的版本和功能模块，以充分利用Curator提供的便利性。

面试突击：公平锁和非公平锁有什么区别？

       从公平的角度来说，Java 中的锁总共可分为两类：公平锁和非公平锁。但公平锁和非公平锁有哪些区别？孰优孰劣呢？在 Java 中的应用场景又有哪些呢？接下来我们一起来看。

正文

       公平锁：每个线程获取锁的顺序是按照线程访问锁的先后顺序获取的，最前面的线程总是最先获取到锁。 非公平锁：每个线程获取锁的顺序是随机的，并不会遵循先来先得的直播源码怎么扒规则，所有线程会竞争获取锁。 举个例子，公平锁就像开车经过收费站一样，所有的车都会排队等待通过，先来的车先通过，如下图所示：

       通过收费站的顺序也是先来先到，分别是张三、李四、王五，这种情况就是公平锁。 而非公平锁相当于，来了一个强行加塞的老司机，它不会准守排队规则，来了之后就会试图强行加塞，如果加塞成功就顺利通过，当然也有可能加塞失败，如果失败就乖乖去后面排队，这种情况就是非公平锁。

应用场景

       在 Java 语言中，锁 synchronized 和 ReentrantLock 默认都是非公平锁，当然我们在创建 ReentrantLock 时，可以手动指定其为公平锁，但 synchronized 只能为非公平锁。 ReentrantLock 默认为非公平锁可以在它的源码实现中得到验证，如下源码所示：当使用 new ReentrantLock(true) 时，可以创建公平锁，如下源码所示：

公平和非公平锁代码演示

       接下来我们使用 ReentrantLock 来演示一下公平锁和非公平锁的执行差异，首先定义一个公平锁，开启 3 个线程，每个线程执行两次加锁和释放锁并打印线程名的操作，如下代码所示：

import?java.util.concurrent.locks.Lock;import?java.util.concurrent.locks.ReentrantLock;public?class?ReentrantLockFairTest?{ static?Lock?lock?=?new?ReentrantLock(true);public?static?void?main(String[]?args)?throws?InterruptedException?{ for?(int?i?=?0;?i?<?3;?i++)?{ new?Thread(()?->?{ for?(int?j?=?0;?j?<?2;?j++)?{ lock.lock();System.out.println("当前线程："?+?Thread.currentThread().getName());lock.unlock();}}).start();}}}

       以上程序的执行结果如下图所示：接下来我们使用非公平锁来执行上面的代码，具体实现如下：

import?java.util.concurrent.locks.Lock;import?java.util.concurrent.locks.ReentrantLock;public?class?ReentrantLockFairTest?{ static?Lock?lock?=?new?ReentrantLock();public?static?void?main(String[]?args)?throws?InterruptedException?{ for?(int?i?=?0;?i?<?3;?i++)?{ new?Thread(()?->?{ for?(int?j?=?0;?j?<?2;?j++)?{ lock.lock();System.out.println("当前线程："?+?Thread.currentThread().getName());lock.unlock();}}).start();}}}

       以上程序的执行结果如下图所示：从上述结果可以看出，使用公平锁线程获取锁的顺序是：A -> B -> C -> A -> B -> C，也就是按顺序获取锁。而非公平锁，获取锁的顺序是 A -> A -> B -> B -> C -> C，原因是所有线程都争抢锁时，因为当前执行线程处于活跃状态，其他线程属于等待状态（还需要被唤醒），所以当前线程总是会先获取到锁，所以最终获取锁的顺序是：A -> A -> B -> B -> C -> C。

执行流程分析公平锁执行流程

       获取锁时，先将线程自己添加到等待队列的队尾并休眠，当某线程用完锁之后，会去唤醒等待队列中队首的线程尝试去获取锁，锁的使用顺序也就是队列中的先后顺序，在整个过程中，线程会从运行状态切换到休眠状态，再从休眠状态恢复成运行状态，但线程每次休眠和恢复都需要从用户态转换成内核态，而这个状态的转换是比较慢的，所以公平锁的执行速度会比较慢。

非公平锁执行流程

       当线程获取锁时，会先通过 CAS 尝试获取锁，如果获取成功就直接拥有锁，如果获取锁失败才会进入等待队列，等待下次尝试获取锁。这样做的好处是，获取锁不用遵循先到先得的规则，从而避免了线程休眠和恢复的操作，这样就加速了程序的执行效率。 公平锁和非公平锁的性能测试结果如下，以下测试数据来自于《Java并发编程实战》：

        从上述结果可以看出，使用非公平锁的吞吐率（单位时间内成功获取锁的平均速率）要比公平锁高很多。

优缺点分析

       公平锁的优点是按序平均分配锁资源，不会出现线程饿死的情况，它的缺点是按序唤醒线程的开销大，执行性能不高。 非公平锁的优点是执行效率高，谁先获取到锁，锁就属于谁，不会“按资排辈”以及顺序唤醒，但缺点是资源分配随机性强，可能会出现线程饿死的情况。

总结

       在 Java 语言中，锁的默认实现都是非公平锁，原因是非公平锁的效率更高，使用 ReentrantLock 可以手动指定其为公平锁。非公平锁注重的是性能，而公平锁注重的是锁资源的平均分配，所以我们要选择合适的场景来应用二者。

       是非审之于己，毁誉听之于人，得失安之于数。

       公众号：Java面试真题解析

       面试合集：/post/

ReentrantLock源码详细解析

       在深入解析ReentrantLock源码之前，我们先了解ReentrantLock与同步机制的关系。ReentrantLock作为Java中引入的并发工具类，由Doug Lea编写，相较于synchronized关键字，它提供了更为灵活的锁管理策略，支持公平与非公平锁两种模式。AQS（AbstractQueuedSynchronizer）作为实现锁和同步器的核心框架，由AQS类的独占线程、同步状态state、FIFO等待队列和UnSafe对象组成。AQS类的内部结构图显示了其组件的构成。在AQS框架下，等待队列采用双向链表实现，头结点存在但无线程，T1和T2节点中的线程可能在自旋获取锁后进入阻塞状态。

       Node节点作为等待队列的基本单元，分为共享模式和独占模式，值得关注的是waitStatus成员变量，它包含五种状态：-3、-2、-1、0、1。本文重点讨论-1、0、1状态，-3状态将不涉及。非公平锁与公平锁的差异在于，非公平锁模式下新线程可直接尝试获取锁，而公平锁模式下新线程需排队等待。

       ReentrantLock内部采用非公平同步器作为其同步器实现，构造函数中根据需要选择非公平同步器或公平同步器。ReentrantLock默认采用非公平锁策略。非公平锁与公平锁的区别在于获取锁的顺序，非公平锁允许新线程跳过等待队列，而公平锁严格遵循队列顺序。

       在非公平同步器的实例中，我们以T1线程首次获取锁为例。T1成功获取锁后，将exclusiveOwnerThread设置为自身，state设置为1。紧接着，T2线程尝试获取锁，但由于state为1，获取失败。调用acquire方法尝试获得锁，尝试通过tryAcquire方法实现，非公平同步器的实现调用具体逻辑。

       在非公平锁获取逻辑中，通过CAS操作尝试交换状态。交换成功后，设置独占线程。当当前线程为自身时，执行重入操作，叠加state状态。若获取锁失败，则T2和T3线程进入等待队列，调用addWaiter方法。队列初始化通过enq方法实现，enq方法中的循环逻辑确保线程被正确加入队尾。新线程T3调用addWaiter方法入队，队列初始化完成。

       在此过程中，T2和T3线程开始自旋尝试获取锁。若失败，则调用parkAndCheckInterrupt()方法进入阻塞状态。在shouldParkAfterFailedAcquire方法中，当前驱节点等待状态为CANCELLED时，方法会找到第一个非取消状态的节点，并断开取消状态的前驱节点与该节点的连接。若T5线程加入等待队列，T3和T4线程因为自旋获取锁失败进入finally块调用取消方法，找到等待状态不为1的节点（即T2），断开连接。

       理解了shouldParkAfterFailedAcquire方法后，我们关注acquireQueued方法的实现。该方法确保线程在队列中正确释放，如果队列的节点前驱为head节点，成功获取锁后，调用setHead方法释放线程。setHead方法通过CAS操作更新head节点，释放线程。acquire方法中的阻塞是为防止线程在唤醒后重新尝试获取锁而进行的额外阻断。

       锁的释放过程相对简单，将state减至0，将exclusiveOwnerThread设置为null，完成锁的释放。通过上述解析，我们深入理解了ReentrantLock的锁获取、等待、释放等核心机制，为并发编程提供了强大的工具支持。

JUC架构-ReentrantLock的公平与非公平

       ReentrantLock是Java中一种强大的可重入锁，提供了与synchronized不同的线程同步机制。它的重要特性包括：

       1. 可重入性：允许线程多次获取同一锁，但需要精确管理锁的获取和释放，以防止死锁。

       2. 公平与非公平选择：ReentrantLock有两种模式：公平锁和非公平锁。公平锁按申请顺序分配锁，确保每个线程按等待时间获取，可能增加性能开销；非公平锁则优先给当前持有锁的线程，提高效率，但可能导致线程饥饿。

       3. 显式控制：与synchronized不同，ReentrantLock需要显式调用lock()获取锁和unlock()释放锁，适合更精细的同步控制。

       4. 条件变量：ReentrantLock支持Condition接口，实现复杂的线程协作和等待通知机制。

       5. 可中断的获取：lockInterruptibly()方法允许在获取锁时响应中断，避免阻塞过久。

       6. 保证可见性：与synchronized一样，ReentrantLock确保线程可见性，避免数据同步问题。

       在选择ReentrantLock时，需注意平衡公平性、效率和线程饥饿的风险。默认情况下，它采用非公平模式，但可以为特定场景调整为公平锁。深入了解其公平与非公平的实现细节，可以参考AQS源码和Condition的讲解。

java中的各种锁详细介绍

       Java提供了多种锁以满足不同的并发需求，这些锁的特性各异，适用于不同的场景。本文旨在概述锁的源码（JDK 8版本），并举例说明使用场景，帮助读者理解锁的知识点以及不同锁的适用情况。接下来，我们将按照以下结构进行分类介绍：乐观锁 vs 悲观锁、自旋锁 vs 适应性自旋锁、无锁 vs 偏向锁 vs 轻量级锁 vs 重量级锁、公平锁 vs 非公平锁、可重入锁 vs 非可重入锁、独享锁 vs 共享锁。

       乐观锁 vs 悲观锁

       乐观锁与悲观锁基于对并发操作的预设不同。悲观锁假设并发操作中一定会出现数据修改，因此在获取数据时会先加锁，以防止数据被修改。在Java中，synchronized关键字和Lock接口的实现类多采用悲观锁策略。相反，乐观锁假设并发操作中不会修改数据，只在尝试修改数据时检查数据是否已被修改，若数据未被修改则成功完成操作，否则根据情况采取不同的策略。

       自旋锁 vs 适应性自旋锁

       自旋锁是一种在无需阻塞线程的情况下，通过循环检查条件来尝试获取锁的机制。当锁长时间未被释放时，自旋锁会导致线程持续消耗处理器资源，因此引入了适应性自旋锁。适应性自旋锁会根据前一次自旋等待的时间和锁的持有者状态来决定是否继续自旋或立即阻塞线程。

       无锁 vs 偏向锁 vs 轻量级锁 vs 重量级锁

       锁的状态从无锁升级到重量级锁，主要依据锁的竞争情况和锁的状态。无锁允许所有线程同时访问资源，但只有一个线程能修改成功。偏向锁是为单线程操作而优化的锁，可以避免不必要的锁操作。轻量级锁在偏向锁被其他线程尝试访问时升级，通过自旋和CAS操作尝试获取锁。重量级锁则在多线程竞争时，通过阻塞等待线程来获取锁。

       公平锁 vs 非公平锁

       公平锁按照申请锁的顺序为线程分配锁，确保等待的线程不会饿死，但可能降低整体吞吐效率。非公平锁则直接尝试获取锁，可能导致后申请锁的线程先获取到锁，从而提高吞吐效率，但存在饿死等待线程的风险。

       可重入锁 vs 非可重入锁

       可重入锁允许线程在嵌套调用时重复获取同一锁，避免死锁。非可重入锁不允许重复获取同一锁，可能导致死锁情况。

       独享锁 vs 共享锁

       独享锁一次只能被一个线程持有，允许多线程同时读取数据但不允许写操作。共享锁则允许多个线程同时读取数据，但不允许写操作，以提高并发读取效率。

       通过以上分类介绍，我们可以更直观地理解Java中锁的特性和适用场景。不同锁的设计旨在解决特定的并发问题，选择合适的锁类型可以显著提升程序的性能和稳定性。

synchronized和ReentrantLock的5个区别！

       在Java中，尽管synchronized（内置锁）和ReentrantLock（可重入锁）都具备锁定和同步的功能，但它们在使用方式、操作细节和特性上存在显著差异。以下是对两者五个主要区别的简要阐述：

       区别1：用法

       synchronized适用于方法、静态方法和代码块，而ReentrantLock仅限于代码块。synchronized的锁操作更为简洁，而ReentrantLock则需要手动创建和管理锁。

       区别2：加锁与释放

       synchronized自动进行加锁和释放，而ReentrantLock则需要显式调用lock和unlock方法。ReentrantLock的解锁操作需确保在finally块中执行，以防止资源泄漏。

       区别3：锁类型

       synchronized是公平锁，ReentrantLock则可选择公平或非公平。默认ReentrantLock是非公平锁，通过new ReentrantLock(true)可创建公平锁。

       区别4：中断响应

       ReentrantLock支持lockInterruptibly，允许中断并释放锁，解决死锁问题。synchronized则不会响应中断，可能导致线程阻塞。

       区别5：底层实现

       synchronized基于JVM的监视器（Monitor），字节码中表现为monitorenter和monitorexit。ReentrantLock则通过AQS（AbstractQueuedSynchronizer）API实现，源码更易理解和定制。

       总结来说，synchronized和ReentrantLock在使用时需根据具体需求选择，它们的差异体现在控制的灵活性、中断响应和底层实现等方面。