小结

docs/thread/BlockingQueue.md

@@ -749,7 +749,7 @@ public class DelayQueueDemo {
 这是一个 5 秒延迟的元素
 ```
 
-## 总结
+## 小结
 
 本文介绍了 Java 中的阻塞队列，包括 ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue、LinkedTransferQueue、LinkedBlockingDeque 和 DelayQueue。它们都是线程安全的，可以在多线程环境下使用。
 

docs/thread/ConcurrentHashMap.md

@@ -923,7 +923,7 @@ public class UserVisitCounter {
 
 ConcurrentHashMap使我们能够无需担心并发问题就能构建这样一个高效的统计系统。
 
-## 总结
+## 小结
 
 ConcurrentHashMap 是线程安全的，支持完全并发的读取，并且有很多线程可以同时执行写入。在早期版本（例如 JDK 1.7）中，ConcurrentHashMap 使用分段锁技术。整个哈希表被分成一些段（Segment），每个段独立加锁。这样，在不同段上的操作可以并发进行。从 JDK 1.8 开始，ConcurrentHashMap 的内部实现有了很大的变化。它放弃了分段锁技术，转而采用了更先进的并发控制策略，如 CAS 操作和红黑树等，进一步提高了并发性能。
 

docs/thread/ConcurrentLinkedQueue.md

@@ -482,7 +482,7 @@ queue当前的大小为：4
 
 
 
-## 总结
+## 小结
 
 ConcurrentLinkedQueue 是一种先进先出（FIFO，First-In-First-Out）的队列，它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的。该队列不允许 null 元素。
 

docs/thread/CopyOnWriteArrayList.md

@@ -179,7 +179,7 @@ CopyOnWrite 容器有很多优点，但是同时也存在两个问题，即内
 
 **如果读线程能够立即读到新添加的数据就叫数据实时性**。当对第 5 行的断点放开后，读线程感知到了数据的变化，所以读到了完整的数据 1,2,3,4，这叫**数据最终一致性**，尽管有可能中间间隔了好几秒才感知到。
 
-## 总结
+## 小结
 
 CopyOnWriteArrayList 是一个线程安全的变体，它是 Java 的 ArrayList 类的并发版本。这个类的线程安全是通过一个简单但强大的想法实现的：每当列表修改时，就创建列表的一个新副本。
 

docs/thread/CountDownLatch.md

@@ -495,7 +495,7 @@ static final class QNode implements ForkJoinPool.ManagedBlocker {
 
 有兴趣的小伙伴可以去看看 JDK 源代码，这里不做过多叙述。
 
-## 总结
+## 小结
 
 总的来说，CountDownLatch，CyclicBarrier，Phaser 是一个比一个强大，但也一个比一个复杂，需要根据自己的业务需求合理选择。
 

docs/thread/LockSupport.md

@@ -254,7 +254,7 @@ public class ABCPrinter {
 - 主线程稍微延迟后调用 t1 的 unpark，启动整个打印流程。
   这样可以保证每个线程按照预期的顺序进行工作。
 
-## 总结
+## 小结
 
 LockSupport 提供了一种更底层和灵活的线程调度方式。它不依赖于同步块或特定的锁对象。可以用于构建更复杂的同步结构，例如自定义锁或并发容器。LockSupport.park 与 LockSupport.unpark 的组合使得线程之间的精确控制变得更容易，而不需要复杂的同步逻辑和对象监视。
 

docs/thread/ReentrantReadWriteLock.md

@@ -418,7 +418,7 @@ public class CachedData {
 
 这样的结构允许在确保数据一致性的同时，实现并发读取的优势，从而提高多线程环境下的性能。
 
-## 总结
+## 小结
 
 ReentrantReadWriteLock 是 Java 的一种读写锁，它允许多个读线程同时访问，但只允许一个写线程访问，或者阻塞所有的读写线程。这种锁的设计可以提高性能，特别是在数据结构中，读操作的数量远远超过写操作的情况下。
 

docs/thread/ScheduledThreadPoolExecutor.md

@@ -627,7 +627,7 @@ private void siftUp(int k, RunnableScheduledFuture<?> key) {
 可见，每次新增节点时，只是根据父节点来判断，而不会影响兄弟节点。
 
 
-## 总结
+## 小结
 
 `ScheduledThreadPoolExecutor`是一个定时任务的线程池，它的主要作用是周期性的执行任务。它的实现原理是通过`DelayedWorkQueue`来保存等待的任务，`DelayedWorkQueue`是一个无界优先队列，使用数组存储，底层使用堆结构来实现优先队列的功能。
 

docs/thread/ThreadLocal.md

@@ -613,7 +613,7 @@ public class UserAuthenticationService {
 
 这个示例定义了一个UserAuthenticationService类，该类使用ThreadLocal来保存与当前线程关联的用户登录信息。假设用户已经通过身份验证，将用户对象存储在currentUser ThreadLocal变量中。getCurrentUser方法用于检索与当前线程关联的用户信息。由于使用了ThreadLocal，因此不同的线程可以同时登录不同的用户，而不会相互干扰。
 
-## 总结
+## 小结
 
 ThreadLocal 是一个非常有用的工具类，它可以用于保存线程中的变量，这样在同一个线程中的任何地方都可以获取到线程中的变量。但是，ThreadLocal 也是一个非常容易被误用的工具类，如果没有使用好，就可能会造成内存泄漏的问题。
 

docs/thread/Unsafe.md

@@ -655,7 +655,7 @@ private void systemTest() {
 
 这两个方法的应用场景比较少，在`java.nio.Bits`类中，在使用`pageCount`计算所需的内存页的数量时，调用了`pageSize`方法获取内存页的大小。另外，在使用`copySwapMemory`方法拷贝内存时，调用了`addressSize`方法，检测 32 位系统的情况。
 
-## 总结
+## 小结
 
 在本文中，我们首先介绍了 Unsafe 的基本概念、工作原理，并在此基础上，对它的 API 进行了说明与实践。
 

docs/thread/atomic.md

@@ -280,7 +280,7 @@ public class AtomicDemo {
 
 从示例中可以看出，创建`AtomicIntegerFieldUpdater`是通过它提供的静态方法进行创建的，`getAndAdd`方法会将指定的字段加上输入的值，并返回相加之前的值。user 对象中 age 字段原值为 1，加 5 之后变成了 6。
 
-## 总结
+## 小结
 
 Java 中的 java.util.concurrent.atomic 包提供了一系列类，这些类支持原子操作（即线程安全而无需同步）在单个变量上，这大大减少了并发编程的复杂性。
 

docs/thread/cas.md

@@ -244,7 +244,7 @@ pause 指令能让自旋失败时 cpu 睡眠一小段时间再继续自旋，从
 1. 使用`AtomicReference`类保证对象之间的原子性，把多个变量放到一个对象里面进行 CAS 操作；
 2. 使用锁。锁内的临界区代码可以保证只有当前线程能操作。
 
-## 总结
+## 小结
 
 CAS（Compare-and-Swap）是一种被广泛应用在并发控制中的算法，它是一种乐观锁的实现方式。CAS 全称为“比较并交换”，是一种无锁的原子操作。
 

docs/thread/fork-join.md

@@ -379,7 +379,7 @@ import java.util.concurrent.RecursiveTask;
 
 这个示例程序是对 Fork/Join 模型的简化，实际上在真正的 MapReduce 框架中，还涉及到数据划分、映射阶段、归约阶段等更多的步骤。但是通过此示例，大家可以初步了解如何使用 Fork/Join 并行计算框架来处理类似的任务。
 
-## 总结
+## 小结
 
 Fork/Join 并行计算框架主要解决的是分治任务。分治的核心思想是“分而治之”：将一个大的任务拆分成小的子任务去解决，然后再把子任务的结果聚合起来从而得到最终结果。这个过程非常类似于大数据处理中的 MapReduce，所以你可以把 Fork/Join 看作单机版的 MapReduce。
 

docs/thread/map.md

@@ -242,7 +242,7 @@ CopyOnWrite 容器即**写时复制的容器**，当我们往一个容器中添
 
 这样做的好处在于，我们可以在并发的场景下对容器进行"读操作"而不需要"加锁"，从而达到读写分离的目的。从 JDK 1.5 开始 Java 并发包里提供了两个使用 CopyOnWrite 机制实现的并发容器，分别是 [CopyOnWriteArrayList](https://javabetter.cn/thread/CopyOnWriteArrayList.html)（后面会细讲，戳链接直达） 和 CopyOnWriteArraySet（不常用）。
 
-## 总结
+## 小结
 
 本文主要介绍了并发包中的三个重要的容器类，Map、阻塞队列和 CopyOnWrite 容器，Map 用于存储键值对，阻塞队列用于生产者-消费者模型，而 CopyOnWrite 容器用于“读多写少”的并发场景。
 

docs/thread/pianxiangsuo.md

@@ -478,7 +478,7 @@ public static void main(String[] args) throws InterruptedException {
 
 偏向锁给 JVM 增加了巨大的复杂性，只有少数非常有经验的程序员才能理解整个过程，维护成本很高，大大阻碍了开发新特性的进程（换个角度理解，你掌握了，是不是就是那少数有经验的程序员了呢？哈哈）
 
-## 总结
+## 小结
 
 偏向锁可能就这样的走完了它的一生，有些小伙伴可能直接发问，都被 deprecated 了，JDK 都 17 了，还讲这么多干什么？
 

docs/thread/readme.md

@@ -14,7 +14,7 @@ head:
 
 ![](https://cdn.tobebetterjavaer.com/stutymore/readme-readme-fengmian.png)
 
-# 第一节：小册简介
+# 第零节：小册简介
 
 以上就是小册的封面了，自我感觉还不错哈，简洁大方，但包含的信息又足够的丰富：
 

docs/thread/shengchanzhe-xiaofeizhe.md

@@ -788,7 +788,7 @@ public class ProductorConsumer {
 - 异步：对于生产者和消费者来说能够各司其职，生产者只需要关心缓冲区是否还有数据，不需要等待消费者处理完；对于消费者来说，也只需要关注缓冲区的内容，不需要关注生产者，通过异步的方式支持高并发，将一个耗时的流程拆成生产和消费两个阶段，这样生产者因为执行 put 的时间比较短，可以支持高并发
 - 支持分布式：生产者和消费者通过队列进行通讯，所以不需要运行在同一台机器上，在分布式环境中可以通过 redis 的 list 作为队列，而消费者只需要轮询队列中是否有数据。同时还能支持集群的伸缩性，当某台机器宕掉的时候，不会导致整个集群宕掉
 
-## 总结
+## 小结
 
 本文主要讲解了线程的等待/通知机制，包括 wait/notify/notifyAll 方法的使用，以及使用 wait/notifyAll 实现生产者-消费者模型的示例代码。