1.android wake_lock 锁源码分析
2.慢查询日志中的源码 Lock_time 从哪里来？
3.ReentrantLock 源码解析 | 京东云技术团队
4.33张图解析ReentrantReadWriteLock源码
5.Lock的await/singal 和 Object的wait/notify 的区别

android wake_lock 锁源码分析

       在Android系统中，WakeLock锁被广泛用于保持设备唤醒，查询避免进入休眠状态，源码以满足应用程序持续运行的查询需求。本文从源码角度对WakeLock的源码基本流程原理进行深入分析。

       WakeLock主要存在三种表现形式：

       1. PowerManager.WakeLock：此接口由PMS提供给应用层和其它组件，查询笑傲梦幻客户端源码下载用于申请WakeLock。源码

       2. PowerManagerService.WakeLock：它是查询PowerManager.WakeLock在PMS内部的具体实现。

       3. SuspendBlocker：在向底层节点操作时，源码PowerManagerService.WakeLock会转变为这种形式。查询

       接下来，源码我们通过一个实例演示如何申请WakeLock锁。查询

       在PowerManagerService中，源码会根据特定条件禁用部分WakeLock。查询这通常发生在：

       1. 强制进入suspend状态。源码

       2. 当WakeLock所属进程不处于active状态且进程adj大于PROCESS_STATE_RECEIVER。

       3. 设备Idle处于IDLE状态，且所属进程不在doze白名单中。

       当禁用条件满足时，mWakeLockSuspendBlocker会调用JNI方法nativeAcquireSuspendBlocker。

       在power.c文件中，acquire_wake_lock的实现会将一个字符串数据写入指定的路径文件节点，新版本路径为“/sys/power/wake_lock”，演示平台源码旧版本为“/sys/android_power/acquire_partial_wake_lock”。至此，WakeLock锁的获取过程基本完成。释放过程与获取类似。

       文章结束，感谢您的阅读。

慢查询日志中的 Lock_time 从哪里来？

       在探讨慢查询日志中的 Lock_time 时，首先要了解的是，与这位老相识的关联并不仅限于它表示锁等待时间这一层面，而是深入理解 Lock_time 的构成以及它是如何被计算得出的。

       深入研究 Lock_time 之前，我们仅知其代表锁等待时间，却未探入其具体组成与计算过程。在众多 SQL 执行时间较长的场景中，我们时常困惑于 Lock_time 的数值似乎与其等待时间并不成正比，如观察到 Lock_time 仅为 0. 秒。

       本文旨在揭开 Lock_time 的面纱，探索它包含的锁等待时间的来源以及计算方式。基于 MySQL 8.0. 源码，我们将重点放在 InnoDB 存储引擎上，通过分析其实现逻辑，以直观呈现 Lock_time 的跳转链接源码组成与计算过程。

       首先，明确 Lock_time 的计算方法。它由表锁等待时间和行锁等待时间两部分相加形成。这启示我们，对 Lock_time 的理解不仅限于表锁等待时间的考量，还需关注行锁等待时间的计算与累加。

       在表锁等待时间的实现中，源码展示了从 Sql_cmd_dml::execute() 函数开始，到 lock_external() 方法的执行，整个过程涉及多个函数和调用，包括 lock_tables()、mysql_lock_tables() 等。这一系列操作最终在 thd->inc_lock_usec() 函数中实现了表锁等待时间的累积。

       值得注意的是，表锁等待时间并非单纯反映锁等待过程，它还包含了执行一些初始化操作所需的时间，如同步刷脏页操作。对于 FLUSH TABLES ... WITH READ LOCK 语句，表锁等待时间更包含了将涉及的表所属表空间的脏页同步到磁盘所需的时间。

       行锁等待时间的计算则更为直接，主要关注的是在加锁过程中记录的等待时间。通过 sel_set_rec_lock() 函数进行加锁操作，名字打分源码当其他事务持有该记录的行锁时，等待时间即开始计算。通过代码逻辑，我们可直观理解这一过程，即在获取行锁或等待超时后，通过当前时间减去开始时间计算得到行锁等待时间。

       综上所述，Lock_time 由表锁与行锁等待时间共同构成，两者在累加的过程中最终形成 Lock_time。表锁等待时间不仅包含锁等待时间本身，还可能涉及额外的初始化操作时间，而行锁等待时间则更为直接且精确。通过深入分析源码，我们对 Lock_time 的构成有了更全面的理解。

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 功能更加丰富，支持公平锁实现，支持中断响应以及限时等待等，是处理并发问题很好的解决方案。

张图解析ReentrantReadWriteLock源码

       今天，我们深入探讨ReentrantReadWriteLock源码，解析其内部结构与工作原理。文章分为多个部分，逐一剖析读写锁的创建、获取与释放过程。

       读写锁规范与实现

       ReentrantReadWriteLock（简称RRW）作为读写锁，其核心功能在于控制并发访问的读与写操作。为了规范读写锁的使用，RRW首先声明了ReadWriteLock接口，并通过ReadLock与WriteLock实现接口，确保读锁与写锁的正确操作。

       为了实现锁的基本功能，WriteLock与ReadLock都继承了Lock接口。这些类内部依赖于AQS（AbstractQueuedSynchronizer）抽象类，AQS为加锁和解锁过程提供了统一的模板函数，简化了锁实现的复杂性。

       核心组件与流程

       AQS提供了一套多线程访问共享资源的同步模板，包括tryAcquire、release等核心抽象函数。WriteLock与ReadLock通过继承Sync类，实现了AQS中的tryAcquire、release（写锁）和tryAcquireShared、tryReleaseShared（读锁）函数。

       Sync类在ReentrantReadWriteLock中扮演关键角色，它不仅实现了AQS的抽象函数，还通过位运算优化了读写锁状态的存储，减少了资源消耗。此外，Sync类还定义了HoldCounter与ThreadLocalHoldCounter，进一步管理锁的状态与操作。

       公平与非公平策略

       为了适应不同场景的需求，ReentrantReadWriteLock支持公平与非公平策略。通过Sync类的FairSync与NonfairSync子类，实现了读锁与写锁的阻塞控制。公平策略确保了线程按顺序获取锁，而非公平策略允许各线程独立竞争。

       全局图与细节解析

       文章最后，构建了一张全局图，清晰展示了ReentrantReadWriteLock的各个组件及其相互关系。通过深入细节，分别解释了读写锁的创建、获取与释放过程。以Lock接口的lock与unlock方法为主线，追踪了从Sync类出发的实现路径，包括tryAcquire、tryRelease等核心函数，以及它们在流程图中的表现。

       总结，ReentrantReadWriteLock通过继承AQS并扩展公平与非公平策略，实现了高效、灵活的读写锁功能。通过精心设计的Sync类及其相关组件，确保了多线程环境下的并发控制与资源访问优化。深入理解其内部实现，有助于在实际项目中更好地应用读写锁，提升并发性能与系统稳定性。

Lock的await/singal 和 Object的wait/notify 的区别

       Lock的await/singal 和 Object的wait/notify 的区别

       åœ¨ä½¿ç”¨Lock之前，我们都使用Object 的wait和notify实现同步的。举例来说，一个producer和consumer，consumer发现没有东西了，等待，produer生成东西了，唤醒。

       çº¿ç¨‹consumer 线程producer

        synchronize(obj){

        obj.wait();//没东西了，等待

       } synchronize(obj){

        obj.notify();//有东西了，唤醒

       }

       æœ‰äº†lock后，世道变了，现在是：

       lock.lock();

       condition.await();

       lock.unlock(); lock.lock();

       condition.signal();

       lock.unlock();

       ä¸ºäº†çªå‡ºåŒºåˆ«ï¼Œçœç•¥äº†è‹¥å¹²ç»†èŠ‚。区别有三点：

       1. lock不再用synchronize把同步代码包装起来；

       2. 阻塞需要另外一个对象condition；

       3. 同步和唤醒的对象是condition而不是lock，对应的方法是await和signal，而不是wait和notify。

       ä¸º

       ä»€ä¹ˆéœ€è¦ä½¿ç”¨condition呢？简单一句话，lock更灵活。以前的方式只能有一个等待队列，在实际应用时可能需要多个，比如读和写。为了这个灵活

       æ€§ï¼Œlock将同步互斥控制和等待队列分离开来，互斥保证在某个时刻只有一个线程访问临界区（lock自己完成），等待队列负责保存被阻塞的线程

       ï¼ˆcondition完成）。

       é€šè¿‡æŸ¥çœ‹ReentrantLock的源代码发现，condition其实是等待队列的一个管理者，condition确保阻塞的对象按顺序被唤醒。

       åœ¨Lock的实现中，LockSupport被用来实现线程状态的改变，后续将更进一步研究LockSupport的实现机制。