From 4267766f00177d4cd86b13872d3da97f747d2938 Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 21:41:53 +0800 Subject: [PATCH 001/116] docs: add operating system articles --- README.md | 3 + docs/.vuepress/sidebar/cs-basics.ts | 3 + docs/cs-basics/README.md | 7 +- docs/cs-basics/operating-system/README.md | 27 +- .../operating-system/io-multiplexing.md | 340 ++++++++++++++++++ .../operating-system/virtual-memory.md | 249 +++++++++++++ docs/cs-basics/operating-system/zero-copy.md | 256 +++++++++++++ 7 files changed, 874 insertions(+), 11 deletions(-) create mode 100644 docs/cs-basics/operating-system/io-multiplexing.md create mode 100644 docs/cs-basics/operating-system/virtual-memory.md create mode 100644 docs/cs-basics/operating-system/zero-copy.md diff --git a/README.md b/README.md index 910fc1a7705..0844aba7bc5 100755 --- a/README.md +++ b/README.md @@ -145,6 +145,9 @@ JVM 这部分内容主要参考 [JVM 虚拟机规范-Java8](https://docs.oracle. - [操作系统常见知识点&面试题总结(上)](./docs/cs-basics/operating-system/operating-system-basic-questions-01.md) - [操作系统常见知识点&面试题总结(下)](./docs/cs-basics/operating-system/operating-system-basic-questions-02.md) +- [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./docs/cs-basics/operating-system/virtual-memory.md) +- [I/O 多路复用详解:select、poll、epoll 原理与区别](./docs/cs-basics/operating-system/io-multiplexing.md) +- [零拷贝详解:mmap、sendfile 与 splice](./docs/cs-basics/operating-system/zero-copy.md) - **Linux**: - [后端程序员必备的 Linux 基础知识总结](./docs/cs-basics/operating-system/linux-intro.md) - [Shell 编程基础知识总结](./docs/cs-basics/operating-system/shell-intro.md) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index 3e22e0b397f..3c3a3decf0d 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -110,6 +110,9 @@ export const csBasics = [ children: [ "operating-system-basic-questions-01", "operating-system-basic-questions-02", + { text: "虚拟内存", link: "virtual-memory" }, + { text: "I/O 多路复用", link: "io-multiplexing" }, + { text: "零拷贝", link: "zero-copy" }, { text: "Linux", icon: ICONS.LINUX, diff --git a/docs/cs-basics/README.md b/docs/cs-basics/README.md index f3fc4506c9a..82b862ae6f5 100644 --- a/docs/cs-basics/README.md +++ b/docs/cs-basics/README.md @@ -37,7 +37,7 @@ head: ## 学习重点 - 计算机网络重点理解分层模型、TCP/UDP、HTTP/HTTPS、DNS、ARP、NAT 和常见网络安全问题。 -- 操作系统重点理解进程线程、内存管理、文件系统、Linux 基础和 Shell 使用。 +- 操作系统重点理解进程线程、内存管理、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 基础和 Shell 使用。 - 数据结构重点理解数组、链表、栈、队列、树、图、堆、红黑树和布隆过滤器的特点与适用场景。 - 算法重点理解常见算法思想、复杂度分析、排序、字符串、链表和 LeetCode 高频题。 - 面试中要能把“概念 -> 原理 -> 对比 -> 场景 -> 常见问题”串成完整回答。 @@ -66,7 +66,10 @@ head: - [操作系统专题](./operating-system/):从操作系统基础讲到 Linux 常见问题。 - [操作系统常见面试题总结(上)](./operating-system/operating-system-basic-questions-01.md):覆盖操作系统基础、进程线程、死锁、内存管理等问题。 -- [操作系统常见面试题总结(下)](./operating-system/operating-system-basic-questions-02.md):继续整理文件系统、IO、Linux 等面试考点。 +- [操作系统常见面试题总结(下)](./operating-system/operating-system-basic-questions-02.md):继续整理文件系统、I/O、Linux 等面试考点。 +- [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./operating-system/virtual-memory.md):讲清分页、页表、TLB、缺页中断和页面置换。 +- [I/O 多路复用详解:select、poll、epoll 原理与区别](./operating-system/io-multiplexing.md):讲清 select、poll、epoll 的实现原理、性能差异和适用场景。 +- [零拷贝详解:mmap、sendfile 与 splice](./operating-system/zero-copy.md):讲清传统 I/O、mmap、sendfile、splice 的拷贝路径和工程应用。 - [Linux 基础知识总结](./operating-system/linux-intro.md):掌握 Linux 目录、文件权限、常用命令和系统基础。 - [Shell 编程基础知识总结](./operating-system/shell-intro.md):补齐脚本编写、变量、流程控制和常用命令能力。 diff --git a/docs/cs-basics/operating-system/README.md b/docs/cs-basics/operating-system/README.md index 92ee692bd86..73a40ad25fa 100644 --- a/docs/cs-basics/operating-system/README.md +++ b/docs/cs-basics/operating-system/README.md @@ -1,6 +1,6 @@ --- -title: 操作系统专题:进程线程、内存管理、文件系统、Linux 与 Shell -description: 操作系统面试与学习路线,涵盖进程线程、死锁、内存管理、文件系统、Linux 基础、Shell 编程和常见操作系统面试题。 +title: 操作系统专题:进程线程、虚拟内存、I/O 多路复用、Linux 与 Shell +description: 操作系统面试与学习路线,涵盖进程线程、死锁、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 基础、Shell 编程和常见操作系统面试题。 category: 计算机基础 tag: - 操作系统 @@ -13,10 +13,10 @@ sitemap: head: - - meta - name: keywords - content: 操作系统,操作系统面试题,进程,线程,死锁,内存管理,虚拟内存,文件系统,Linux,Shell,后端面试 + content: 操作系统,操作系统面试题,进程,线程,死锁,内存管理,虚拟内存,零拷贝,I/O多路复用,select,poll,epoll,文件系统,Linux,Shell,后端面试 --- -这份 **操作系统专题** 面向后端学习和面试复习,整理操作系统基础、进程线程、内存管理、文件系统、Linux 和 Shell 相关内容。 +这份 **操作系统专题** 面向后端学习和面试复习,整理操作系统基础、进程线程、内存管理、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 和 Shell 相关内容。 ## 适合谁看 @@ -27,23 +27,30 @@ head: ## 学习重点 -- 操作系统负责管理 CPU、内存、文件、IO 和进程,是理解上层软件运行机制的基础。 +- 操作系统负责管理 CPU、内存、文件、I/O 和进程,是理解上层软件运行机制的基础。 - 进程和线程是并发编程、服务端性能和问题排查的基础概念。 - 死锁、上下文切换、调度、同步互斥是面试高频点。 - 内存管理、虚拟内存、分页、页面置换能帮助理解 JVM、数据库和缓存。 +- 零拷贝、I/O 多路复用能帮助理解 Kafka、RocketMQ、Redis、Nginx、Netty 等高性能组件。 - Linux 和 Shell 是后端开发、部署、排障、自动化脚本的常用能力。 ## 建议阅读顺序 1. [操作系统常见面试题总结(上)](./operating-system-basic-questions-01.md):先建立操作系统基础、进程线程、死锁、内存管理的高频问题清单。 -2. [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续补齐文件系统、IO、Linux 等问题。 -3. [Linux 基础知识总结](./linux-intro.md):掌握目录结构、文件权限、常用命令和基础排障能力。 -4. [Shell 编程基础知识总结](./shell-intro.md):学习变量、条件、循环、函数和常用脚本写法。 +2. [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续补齐文件系统、I/O、Linux 等问题。 +3. [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):把分页、页表、TLB、缺页中断和页面置换串起来。 +4. [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):理解一个线程处理海量连接背后的内核机制。 +5. [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):搞清传统 I/O、mmap、sendfile、splice 的拷贝路径和适用场景。 +6. [Linux 基础知识总结](./linux-intro.md):掌握目录结构、文件权限、常用命令和基础排障能力。 +7. [Shell 编程基础知识总结](./shell-intro.md):学习变量、条件、循环、函数和常用脚本写法。 ## 核心文章 - [操作系统常见面试题总结(上)](./operating-system-basic-questions-01.md):覆盖操作系统基础、进程线程、死锁、内存管理等高频问题。 -- [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续整理文件系统、IO、多路复用、Linux 等知识点。 +- [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续整理文件系统、I/O、多路复用、Linux 等知识点。 +- [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):讲清虚拟地址、物理地址、分页、多级页表、TLB、缺页中断和页面置换算法。 +- [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):讲清网络 I/O 的两个阶段、五种 I/O 模型,以及 select、poll、epoll 的区别。 +- [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):讲清零拷贝到底省掉了什么,以及 Java NIO、Kafka、RocketMQ 中的典型应用。 - [Linux 基础知识总结](./linux-intro.md):讲解 Linux 目录树、文件权限、常用命令、用户和进程管理。 - [Shell 编程基础知识总结](./shell-intro.md):讲解 Shell 变量、条件判断、循环、函数、文本处理和脚本实践。 @@ -54,7 +61,9 @@ head: - 什么是上下文切换?频繁上下文切换有什么影响? - 死锁产生的必要条件是什么?如何预防和避免死锁? - 虚拟内存是什么?分页和分段有什么区别? +- TLB、缺页中断和页面置换分别解决什么问题? - 页面置换算法有哪些?缺页中断是怎么回事? +- 零拷贝为什么快?mmap、sendfile、splice 有什么区别? - 文件系统 inode、硬链接、软链接分别是什么? - select、poll、epoll 有什么区别? - Linux 文件权限如何理解?常用排障命令有哪些? diff --git a/docs/cs-basics/operating-system/io-multiplexing.md b/docs/cs-basics/operating-system/io-multiplexing.md new file mode 100644 index 00000000000..06531c0900d --- /dev/null +++ b/docs/cs-basics/operating-system/io-multiplexing.md @@ -0,0 +1,340 @@ +--- +title: I/O 多路复用详解:select、poll、epoll 原理与区别 +description: I/O 多路复用高频面试题总结,从网络读取的两个阶段讲起,拆解 select、poll、epoll 的实现原理、数据结构、性能差异、LT/ET 触发模式,以及 Redis、Nginx、Java NIO 和 Netty 的应用。 +category: 计算机基础 +tag: + - 操作系统 + - 网络编程 + - Linux +head: + - - meta + - name: keywords + content: I/O多路复用,IO多路复用,select,poll,epoll,Linux epoll,LT,ET,Java NIO,Netty,Redis,Nginx,操作系统面试题 +--- + +写一个 TCP 服务端,最直觉的写法是:主线程 `accept` 一个连接,就丢给一个新线程去 `read`、处理、`write`。连接少的时候这套跑得很好。 + +可一旦连接数冲到上万,问题就来了。在不少 Linux 发行版里,新线程默认会预留数 MB 的栈空间,常见配置是 8 MB(实际值取决于 `ulimit -s`、运行库和线程属性)。一万个连接哪怕栈页是按需提交的,预留的地址空间、真正用到的栈页加上线程元数据叠起来也很可观;更要命的是几千上万个线程挤在几个 CPU 核上,光是线程间的上下文切换就把 CPU 啃掉一大半,真正干活的时间所剩无几。更别提大部分连接其实是空闲的——它们各自占着一个线程,却只是在那儿干等数据。 + +这就是经典的 C10K 问题:**怎么让一个(或少数几个)线程,同时盯着成千上万个连接,谁来数据了就处理谁。** + +答案就是 **I/O 多路复用**。 + +下面按 select、poll、epoll 的顺序往下讲,它们解决的是同一个问题,但一个比一个聪明。 + +## 什么是 I/O 多路复用? + +要讲清楚,得先知道一次网络读操作在内核里其实分成两个阶段: + +1. **等数据就绪**:数据还在网卡、还在路上,内核要等它到达并拷进内核缓冲区。这一步往往很慢。 +2. **拷数据**:数据到了内核缓冲区,再从内核态拷到用户态的应用缓冲区。这一步很快。 + +![网络读取中的两个阶段:先等待网卡数据进入内核缓冲区,再通过 copy_to_user 拷贝到用户缓冲区](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-io-two-phases.png) + +一个连接一个线程的阻塞模型,问题出在第一阶段:线程调用 `recv` 后就卡死在那儿,专门为这一个连接等数据,等的时候什么也干不了。 + +I/O 多路复用换了个思路:把所有要监听的文件描述符(fd)交给内核,让线程阻塞在一个专门的监听系统调用上。只要这批 fd 里有任意一个就绪,这个调用就返回,告诉你谁可以读、谁可以写了,然后你再去处理那几个就绪的 fd。 + +打个比方:一个服务员同时管十张桌子,不是站在第一桌死等客人想好菜,而是来回扫一眼,哪桌举手了就去哪桌。 + +**多路** 指的是多个连接,**复用** 指的是复用同一个线程去处理它们。 + +注意一个容易混淆的点:多路复用本身仍然是**同步 I/O**。`select` 这类调用只告诉你“数据准备好了”,真正的读取还得你自己调 `recv` 去拷数据,这一步该阻塞还是阻塞。它和真正的异步 I/O(内核把数据都拷好了再通知你,比如 Linux 的 io_uring、Windows 的 IOCP)不是一回事。 + +## 多路复用在五种 I/O 模型里的位置 + +UNP 把 Unix 下的 I/O 归成五种模型,搞清楚多路复用站在哪一格,比单看它本身更清楚: + +- **阻塞 I/O**:调 `recv` 后线程一直睡,等数据就绪再加拷贝两个阶段全程卡死。最简单,也最浪费线程。 +- **非阻塞 I/O**:`recv` 没数据立刻返回 `EWOULDBLOCK`,线程不睡,但你得反复轮询去问“好了没”,空转烧 CPU。 +- **I/O 多路复用**:阻塞在 `select`/`poll`/`epoll` 上,一个线程同时等多个 fd,谁就绪处理谁。这就是本文主角。 +- **信号驱动 I/O**:注册 `SIGIO`,数据就绪时内核发信号通知你,平时线程该干嘛干嘛。用得不多。 +- **异步 I/O**:调 `aio_read` 立即返回,内核把“等就绪”和“拷数据”两个阶段全包了,全部完成才通知你。 + +![五种 I/O 模型对比:阻塞 I/O、非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-five-io-models.png) + +关键区别在于谁来完成“把数据从内核缓冲区搬到用户缓冲区”这个动作:前四种模型里,最终都得由应用自己调 `read`/`recv` 来完成这次复制,调用返回后才能用数据,所以都算**同步**(至于这次调用会不会真的睡,要看 fd 是否非阻塞以及当时数据在不在);只有异步 I/O 把等待和复制全交给内核,完成后再通知你。多路复用的价值不在于让单次读取变快,而在于让一个线程把“等”这件事一次性摊到多个连接上。 + +## select 是怎么做的? + +`select` 是最早的实现,几乎所有平台都支持。它的函数签名长这样: + +```c +#include + +int select(int nfds, fd_set *readfds, fd_set *writefds, + fd_set *exceptfds, struct timeval *timeout); +``` + +核心是 `fd_set` 这个数据结构,本质是一个**位图**:每一位对应一个 fd,置 1 表示关心它。配套有四个宏来操作: + +```c +void FD_ZERO(fd_set *set); // 清空所有位 +void FD_SET(int fd, fd_set *set); // 把 fd 对应的位置 1 +void FD_CLR(int fd, fd_set *set); // 把 fd 对应的位清 0 +int FD_ISSET(int fd, fd_set *set); // 检查 fd 对应的位是否为 1 +``` + +一个用 `select` 写的 echo 服务端,主循环大致是这样: + +```c +fd_set rset; +int maxfd = listenfd; + +while (1) { + FD_ZERO(&rset); // 每轮都得重新清空 + FD_SET(listenfd, &rset); // 再把关心的 fd 一个个塞回去 + for (int i = 0; i < n; i++) + if (conns[i] >= 0) FD_SET(conns[i], &rset); + + // 写集合、异常集合不关心,传 NULL;最后一个 NULL 表示一直阻塞 + int ready = select(maxfd + 1, &rset, NULL, NULL, NULL); + + if (FD_ISSET(listenfd, &rset)) { // 监听 fd 就绪,有新连接 + int connfd = accept(listenfd, NULL, NULL); + // 存进 conns[],更新 maxfd + } + for (int i = 0; i < n; i++) // O(N) 挨个问:你就绪了吗? + if (conns[i] >= 0 && FD_ISSET(conns[i], &rset)) { + // 处理这个连接上的读事件 + } +} +``` + +这段代码里藏着 `select` 的几个硬伤,看清楚它们,才明白后面 poll 和 epoll 在改什么。 + +**第一,fd 数量有上限**。在 Linux/glibc 环境里,`fd_set` 位图的大小由 glibc 的常量 `FD_SETSIZE` 决定,默认是 1024,只能安全表示 0~1023 的 fd——这个限制来自用户态 glibc 的固定大小数据结构和 `FD_*` 宏,而不是 Linux 内核本身。对超出范围的 fd 使用这些宏属于未定义行为,也别指望靠重定义 `FD_SETSIZE` 或重新编译内核绕过去。真要盯更多连接,正确做法是换用 poll、epoll。 + +**第二,每次调用都要把位图在用户态和内核态之间来回拷一遍**。调用前你在用户态填好位图,`select` 把它拷进内核;返回时内核改写位图(把没就绪的位清掉),再拷回用户态。内核实际检查和回写的范围由 `nfds` 决定,所以 fd 编号越大、监听越多,这一来一回越费。 + +**第三,位图是“传入即传出”参数(value-result)**。内核返回时会把没就绪的位清零,所以你下一轮必须 `FD_ZERO` + 重新 `FD_SET` 一遍,老的关心列表不能复用。代码里那句“每轮都得重新清空”就是被这个逼出来的。 + +**第四,返回后还得自己 O(N) 遍历**。`select` 只告诉你“有 ready 个 fd 就绪了”,但不告诉你是哪几个,你得拿 `FD_ISSET` 把所有 fd 挨个问一遍。一万个连接哪怕只有一个来数据,你也得问一万次。 + +`timeout` 这个参数倒是有点用:传 NULL 一直阻塞,传一个 0 值的 `timeval` 表示不等立即返回(轮询),传具体值表示最多等多久。 + +## poll 改进了什么? + +`poll` 和 `select` 是同代产物,思路一致,但换掉了数据结构。它不用位图,改用一个 `pollfd` 结构体数组: + +```c +#include + +struct pollfd { + int fd; // 要监听的文件描述符 + short events; // 你关心的事件,调用前填,比如 POLLIN(可读) + short revents; // 实际发生的事件,由内核回填 +}; + +int poll(struct pollfd *fds, nfds_t nfds, int timeout); +``` + +主循环长这样: + +```c +struct pollfd fds[MAX]; +fds[0].fd = listenfd; +fds[0].events = POLLIN; +// 其余 fds[i].fd = connfd; fds[i].events = POLLIN; + +while (1) { + int ready = poll(fds, nfds, -1); // timeout 传 -1 表示一直阻塞 + for (int i = 0; i < nfds; i++) { + if (fds[i].revents & POLLIN) { // 内核把结果写在 revents 里 + // 处理读事件 + } + } +} +``` + +相比 `select`,`poll` 改对了两件事: + +**没有 1024 的硬上限**。监听多少个 fd 取决于你传入的数组多大,不再受 `FD_SETSIZE` 卡死,上限主要看进程能打开的 fd 数。 + +**关心的事件和发生的事件分开了**。`events` 是你填的(输入),`revents` 是内核回填的(输出),两个字段各管各的。这样下一轮不用像 `select` 那样把整个关心列表重置,`events` 保持不动就行。 + +但 `poll` 没解决 `select` 最要命的两个性能问题:每次调用还是要把整个数组从用户态拷到内核态,返回后还是要 O(N) 遍历整个数组才能找出哪些 fd 就绪。连接规模一上去,开销照样是线性增长。 + +说白了,`poll` 是把 `select` 的接口擦干净了,性能模型没变。真正的质变在 epoll。 + +## epoll 为什么是质变? + +`epoll` 是 Linux 专有的,由 Davide Libenzi 实现,在 **2.5.44** 内核引入,glibc 2.3.2 开始提供封装。它把“一个系统调用搞定一切”拆成了三个,各司其职: + +```c +#include + +int epoll_create1(int flags); // 创建 epoll 实例,返回一个 fd(旧接口是 epoll_create(int size)) +int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); // 增删改要监听的 fd +int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout); // 等就绪事件 +``` + +其中 `epoll_ctl` 的 `op` 有三种:`EPOLL_CTL_ADD`(注册)、`EPOLL_CTL_MOD`(修改)、`EPOLL_CTL_DEL`(删除)。事件用 `epoll_event` 描述: + +```c +typedef union epoll_data { + void *ptr; + int fd; + uint32_t u32; + uint64_t u64; +} epoll_data_t; + +struct epoll_event { + uint32_t events; // 事件类型,如 EPOLLIN、EPOLLOUT、EPOLLET + epoll_data_t data; // 用户数据,epoll_wait 返回时原样带回,通常存 fd +}; +``` + +完整用起来是这样: + +```c +int epfd = epoll_create1(0); // 第一步:建实例 + +struct epoll_event ev; +ev.events = EPOLLIN; // 关心可读,默认水平触发 +ev.data.fd = listenfd; +epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev); // 第二步:注册一次就够 + +struct epoll_event events[MAX_EVENTS]; +while (1) { + // 第三步:只返回真正就绪的 fd,n 就是就绪个数 + int n = epoll_wait(epfd, events, MAX_EVENTS, -1); + for (int i = 0; i < n; i++) { // 只遍历就绪的,不扫描全集 + int fd = events[i].data.fd; + if (fd == listenfd) { + int connfd = accept(listenfd, NULL, NULL); + ev.events = EPOLLIN; + ev.data.fd = connfd; + epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev); // 新连接注册进去 + } else { + // 处理 fd 上的读事件 + } + } +} +``` + +对比 `select` 那段代码,差别一眼就看出来:注册 fd 和等事件被拆开了,`epoll_wait` 返回的 `events` 数组里**全是就绪的 fd**,遍历它就行,不用再拿所有 fd 挨个问。 + +这个差别不是接口设计上的小聪明,而是底层数据结构换了。一个 epoll 实例在内核里对应一个 `eventpoll` 结构,里面有两样关键东西: + +- **一棵红黑树(rbr)**:存所有通过 `epoll_ctl` 注册进来的 fd(每个 fd 对应一个 `epitem` 节点)。增删改是 O(log N) 的树操作。fd 只在这里登记一次,之后一直待着,不像 select/poll 每次调用都要把全量列表搬进内核。 +- **一条就绪链表(rdllist)**:一个双向链表,专门存“已经就绪”的 fd。 + +![epoll 内部架构:epoll_ctl 维护 interest list,fd 就绪后通过回调进入 ready list,epoll_wait 返回就绪事件](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-epoll-architecture.png) + +关键在于回调机制。`epoll_ctl` 注册 fd 时,内核会给这个 fd 挂一个回调函数。当网卡来数据、某个 fd 变得可读时,这个回调被触发,把对应的就绪对象挂进就绪链表,并唤醒阻塞在 `epoll_wait` 上的线程。于是 `epoll_wait` 要做的只是看一眼就绪链表空不空——有就把里面的事件拷给用户态,没有就睡觉等回调来唤醒。(补一句:红黑树、就绪链表都是当前内核的实现方式,`epoll` 对用户态承诺的只是“注册集合 + 就绪列表”这层抽象语义,别把树结构当成稳定的 ABI。) + +这就是 epoll 高效的根子:在海量连接、少量活跃的场景下,`epoll_wait` 返回后要遍历的就只是本批次就绪的事件,和“注册的 fd 总量”无关。注册十万个 fd、其中只有三个来数据,`epoll_wait` 就只处理这三个,不用像 select/poll 那样每次扫描全集。但要强调:epoll 的整体成本不只是 `epoll_wait` 返回这一下——注册变更(`epoll_ctl`)、事件回调、并发锁竞争、把就绪事件拷回用户态都有开销;当连接活跃比例接近 100% 时,它相对 select/poll 的优势也会缩小。一句话总结:select 和 poll 每次等待都要把完整监听集合交给内核并线性扫描;epoll 把监听集合长期保存在内核里,等待时只取已经就绪的事件,因此更适合大量 fd、少量活跃连接的场景。 + +数据拷贝也省了。fd 通过 `epoll_ctl` 一次性登记在红黑树上,之后 `epoll_wait` 反复调用都不用再重传整个 fd 列表。 + +这里得纠正一个流传很广的说法:“epoll 之所以快,是因为它用 mmap 在内核和用户态之间共享内存,省掉了拷贝。”这个说法是错的。翻 epoll 的内核实现就能看到,`epoll_wait` 返回时是实打实地用 `__put_user` 把就绪事件拷到用户态的 `events` 数组里,并没有什么 mmap 共享区。epoll 省掉的拷贝是另一回事:是省掉了 select/poll 那种“每次调用都把全量 fd 列表搬进内核”的重复拷贝,而不是省掉返回就绪事件这一次拷贝。这两件事别混为一谈。 + +## 水平触发和边缘触发,区别在哪? + +epoll 支持两种触发模式,这是它比 select/poll 多出来的一个能力,也是面试和实战里最容易踩坑的地方。 + +**水平触发(LT,Level Triggered)** 是默认模式。只要 fd 上还有数据没读完(或者还有空间可写),每次 `epoll_wait` 都会一直通知你。select 和 poll 只有这一种模式。 + +**边缘触发(ET,Edge Triggered)** 要显式加 `EPOLLET` 标志。它只在状态**发生变化**的那一刻通知一次。 + +用一个具体场景说清楚区别(这也是 Linux man page 里的经典例子):假设对端往一个 socket 写了 2 KB 数据。 + +- LT 模式:`epoll_wait` 通知你可读。你只读了 1 KB,缓冲区里还剩 1 KB。下次 `epoll_wait` 还会继续通知你“这儿有数据没读完”,直到你把 2 KB 读干净。 +- ET 模式:`epoll_wait` 通知你一次。你只读了 1 KB 就走了,那剩下的 1 KB——除非对端又写了新数据、状态再次发生变化,`epoll_wait` 不会主动再为它通知你。这 1 KB 可能就长期躺在缓冲区里,连接迟迟得不到处理。 + +![水平触发和边缘触发对比:LT 在数据未读完时会持续通知,ET 只在状态变化时通知一次](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-lt-vs-et.png) + +所以用 ET 必须遵守两条铁律:**fd 设为非阻塞**,并且**循环 `read` 直到返回 `EAGAIN`(或 `EWOULDBLOCK`)**,确保一次把数据彻底读空。典型的 ET 读法是这样: + +```c +// 前提:connfd 已设为非阻塞,且注册时带了 EPOLLET +while (1) { + ssize_t n = read(connfd, buf, sizeof(buf)); + if (n > 0) { + // 处理这批数据,然后继续循环把缓冲区抽干 + } else if (n == 0) { + close(connfd); // 对端关闭连接 + break; + } else { // n < 0 + if (errno == EAGAIN || errno == EWOULDBLOCK) + break; // 数据读完了,这才是正常退出点 + if (errno == EINTR) + continue; // 被信号打断,重试 + close(connfd); // 真出错了 + break; + } +} +``` + +如果 fd 是阻塞的,最后一次没数据的 `read` 会把整个线程卡死在这里——这也是为什么 ET 和非阻塞 fd 必须成对出现。 + +ET 的好处是减少 `epoll_wait` 的唤醒次数,适合追求极致吞吐、又能把读写逻辑写严谨的场景;代价是编程门槛明显更高,漏读 `EAGAIN` 导致连接长期停滞是这类代码最常见的 bug。反过来,如果为了“读干净”在单个活跃 fd 上一直读,又可能饿死其他连接,所以工程上常给每个 fd 设单轮处理预算、配合应用层就绪队列轮转。LT 编程简单、不容易出错,绝大多数业务用 LT 就够了。Nginx 这类对性能敏感的服务才会用 ET。 + +写生产级事件循环时,光会读还不够,还有一圈边角要处理:`epoll_wait` 被信号打断返回 `EINTR` 要重试;ET 下 `accept` 同样得循环到 `EAGAIN`;`EPOLLERR`/`EPOLLHUP`/`EPOLLRDHUP` 要和读写事件一起判断;`read` 返回 0 表示对端关闭了写方向;`write` 可能短写,得自己缓存没发完的数据并按需注册 `EPOLLOUT`;多线程处理同一个 fd 时,考虑用 `EPOLLONESHOT` 配合重新武装(rearm)。 + +## 三者横向对比 + +把前面拆开讲的东西汇总成一张表,方便横向看: + +| 维度 | select | poll | epoll | +| ------------------ | ---------------------------------------------------------------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------- | +| 平台 | 跨平台较好;Unix、Windows 均有(Windows 主要用于 socket) | 主要用于 Unix-like 系统 | Linux 专有(Linux 2.6+) | +| 内核侧管理 | 每次调用临时检查 fd 集合 | 每次调用临时检查 fd 数组 | 长期维护 interest list 和 ready list;Linux 当前实现通常使用红黑树和就绪链表 | +| fd 数量限制 | 受 `FD_SETSIZE` 限制;Linux glibc 通常为 1024,只能安全处理编号 0~1023 的 fd | 不受 `FD_SETSIZE` 限制,但仍受 `RLIMIT_NOFILE` 和内存约束 | 不受 `FD_SETSIZE` 限制,但受文件描述符、内存和 `max_user_watches` 等限制 | +| 每次等待的传参 | 每轮传入完整位图,返回后集合被修改,下轮必须重建 | 每轮传入完整 `pollfd` 数组,内核填写 `revents`(`events` 不用重建) | 监听集合通过 `epoll_ctl` 维护,`epoll_wait` 只接收就绪事件 | +| 查找就绪 fd 的开销 | 扫描到 `nfds - 1`,通常记作 O(N) | 遍历整个数组,O(N) | 等待阶段不扫描完整监听集合,返回成本主要与就绪事件数有关 | +| 触发模式 | 仅 LT | 仅 LT | 默认 LT,也支持 ET(`EPOLLET`) | + +![select、poll 和 epoll 对比:数据结构、fd 限制、每次等待传参、查找就绪 fd 的开销和触发模式](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-select-poll-epoll.png) + +## epoll 不是银弹 + +讲到这儿很容易得出“epoll 全面碾压”的结论,但实战里没这么绝对,有几个边界值得记住。 + +**连接少且都很活跃时,epoll 不一定更快**。epoll 维护红黑树、挂回调、走就绪链表这套机制本身有固定开销。如果你只盯着几十个 fd,而且它们几乎每次都有数据,那么 select/poll 那种“一把梭遍历”反而更直接、更省。epoll 的主场是**海量连接 + 大部分空闲**:几万条长连接挂着,同一时刻只有少数活跃,这时候只盯就绪的那几个才真正划算。 + +**它是 Linux 专有的**。macOS 和 BSD 上对应的是 `kqueue`,Windows 上是 IOCP。要写跨平台的网络程序,一般不会直接调 epoll,而是用 libevent、libuv 这类封装库,让它们在 Linux 上走 epoll、在别的系统上走对应实现。 + +**惊群问题**。多个进程/线程在同一个 listen fd 上等事件时,一个连接到来可能把它们全唤醒,但只有一个能 `accept` 成功,其余白忙一场。Linux 4.5 之后可以用 `EPOLLEXCLUSIVE` 标志缓解,让内核在多个 exclusive waiter 里只唤醒一个、或较少的几个;它并不是在所有部署形态(比如多个 epoll 实例、混用非 exclusive 注册)下都“严格只唤醒一个”的保证。 + +**ET 模式的坑前面说过**:一旦漏读没到 `EAGAIN`,剩余数据可能长期不再触发通知,连接迟迟得不到处理。这不是性能问题,是正确性问题,调试起来还很隐蔽。没把握就老老实实用 LT。 + +## 它们都用在哪儿 + +这套机制不是停在课本上的概念,常见的高性能组件底层都靠它。 + +**Redis** 是单线程事件循环 + I/O 多路复用的典型。它没有为每个客户端开线程,而是用一个线程通过多路复用同时监听大量 socket,谁就绪了就调对应的事件处理器。Redis 自己封装了一层(`ae.c`),在不同平台上分别选 epoll、kqueue 或 select。这也是它单线程还能扛住高并发的关键之一,省掉了多线程的上下文切换和锁竞争。 + +![文件事件处理器(file event handler)](https://oss.javaguide.cn/github/javaguide/database/redis/redis-event-handler.png) + +补充一个常被误解的点:Redis 6.0 引入了多线程,但加的只是网络 I/O 读写和协议解析这部分,命令的实际执行仍然是单线程。多路复用这套事件循环的内核没变,多线程只是把“读 socket、解析请求”这种耗时的活儿分摊到几个线程上,避免它成为单线程的瓶颈。 + +详细介绍推荐你看看这篇文章:[Redis常见面试题总结(上)](https://javaguide.cn/database/redis/redis-questions-01.html)。 + +**Nginx** 是多进程 + epoll,而且用的是 ET 模式,配合非阻塞 socket 把每次唤醒的处理压到最少,这是它能用很少的进程扛住海量连接的底子。 + +**Java NIO** 里的 `Selector` 就是多路复用的 Java 封装。在 Linux 上,`Selector` 底层走的就是 epoll(对应 `EPollSelectorImpl`);换到别的系统会换成对应实现,这层切换对上层代码透明。 + +![Selector 选择器工作示意图](https://oss.javaguide.cn/github/javaguide/java/nio/selector-channel-selectionkey.png) + +Netty 在标准 NIO 之外还额外提供了一套原生 epoll 传输(`EpollEventLoop`),直接对接 epoll、绕开 JDK 那层封装,在 Linux 上能榨出更高的性能。这里要留意版本差异:Netty 4.0 的原生 epoll transport 曾主打边缘触发;到了 Netty 4.2,`EpollMode` 已被标记废弃,并注明 transport 始终使用水平触发。中间 4.1 各小版本的行为以所用版本的源码和 API 为准。 + +另外,关于 Java I/O 模型的针对性详细介绍,可以阅读这篇文章:[Java I/O 模型详解](https://javaguide.cn/java/io/io-model.html)。 + +## 面试里怎么答? + +问“I/O 多路复用解决什么问题”,别答成“让一次 read 更快”。它解决的是“等”的问题:一个线程不用阻塞在单个连接上,而是把一批 fd 交给 `select`、`poll` 或 `epoll`,哪个 fd 就绪了再处理哪个。真正把数据从内核缓冲区拷到用户缓冲区的 `read/recv` 仍然是应用自己调用,所以它属于同步 I/O 模型。 + +`select`、`poll`、`epoll` 的区别可以从三点展开。第一,数据结构不同:`select` 用固定大小的 `fd_set` 位图,Linux glibc 下通常受 1024 限制;`poll` 换成 `pollfd` 数组,绕开了 `FD_SETSIZE`,但数组仍然每次传进内核;`epoll` 把监听集合长期放在内核里,通过 `epoll_ctl` 增删改,`epoll_wait` 只拿就绪事件。 + +第二,性能模型不同。`select` 和 `poll` 每次等待都要传完整集合,返回后还得线性扫描,连接多但活跃少时很亏;`epoll` 适合大量 fd、少量活跃连接,因为等待阶段不用扫描完整监听集合,返回成本主要和本轮就绪事件数相关。不过它不是所有场景都更快,连接很少且都很活跃时,维护回调、红黑树和就绪链表的固定成本也要算进去。 + +第三,`epoll` 的 LT/ET 经常被追问。LT 是默认模式,只要缓冲区还有数据没读完,下次还会通知;ET 只在状态变化时通知一次,所以必须配合非阻塞 fd,并循环读到 `EAGAIN`。面试里能把这句话说清楚,再补上 `EINTR`、短写、`EPOLLHUP/EPOLLERR` 这些生产代码要处理的边角,基本就不是只会背概念了。 + +## 参考 + +- [W. Richard Stevens《UNIX Network Programming》Chapter 6(select/poll 与五种 I/O 模型)](https://notes.shichao.io/unp/ch6/) +- [epoll(7) - Linux manual page](https://man7.org/linux/man-pages/man7/epoll.7.html) +- [epoll_create(2) / epoll_ctl(2) / epoll_wait(2) - Linux manual pages](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) +- [epoll final interface(LWN,记录 epoll 在 2.5.44 引入)](https://lwn.net/Articles/16026/) diff --git a/docs/cs-basics/operating-system/virtual-memory.md b/docs/cs-basics/operating-system/virtual-memory.md new file mode 100644 index 00000000000..40d443501d5 --- /dev/null +++ b/docs/cs-basics/operating-system/virtual-memory.md @@ -0,0 +1,249 @@ +--- +title: 虚拟内存详解:地址转换、TLB、缺页中断与页面置换 +description: 虚拟内存高频面试题总结,从进程隔离讲起,讲清虚拟地址到物理地址的分段、分页、多级页表、TLB、缺页中断、页面置换算法、Belady 异常,以及 mmap、COW、JVM 大页等工程场景。 +category: 计算机基础 +tag: + - 操作系统 + - 内存管理 +head: + - - meta + - name: keywords + content: 虚拟内存,虚拟地址,物理地址,MMU,页表,多级页表,TLB,缺页中断,页面置换算法,CLOCK算法,Belady异常,mmap,COW,操作系统面试题 +--- + +打开任务管理器时,你可能会看到一个很反直觉的现象:每个进程都像在用一大片“自己的内存”,有的进程地址还长得差不多,但它们并不会互相踩坏。浏览器、IDE、数据库同时跑,大家都以为自己拿到的是连续、干净、独占的一块空间。 + +为什么能这样呢?难道是因为程序之间互相信任? + +这其实是操作系统在中间加了一层翻译。程序看到的是虚拟地址,真正落到内存条上的位置由内核和硬件一起决定。 + +虚拟内存要解决的,就是这层翻译怎么做、为什么能隔离进程、内存不够时又怎么把一部分数据暂时挪到磁盘上。 + +## 没有虚拟内存会怎样? + +先看一个最直白的反例。 + +很多人大学里玩过单片机。单片机上没有操作系统,CPU 直接操作内存的物理地址。这种环境下想同时跑两个程序,几乎是个灾难:第一个程序往地址 2000 写了个值,第二个程序刚好也把数据放在 2000,那一写就把对方的数据覆盖了,两个程序双双崩溃。 + +问题的根子在于:两个程序都直接引用了同一套物理地址,谁也躲不开谁。 + +操作系统的办法是加一层隔离:给每个进程发一套独立的“虚拟地址”,让进程只跟自己的虚拟地址打交道,至于这套虚拟地址最后落到物理内存的哪一块,进程根本不需要知道,由操作系统统一安排。 + +于是有了两个概念: + +- 程序里用的地址,叫虚拟地址(Virtual Address)。 +- 真正存在内存条上的地址,叫物理地址(Physical Address)。 + +进程访问虚拟地址时,CPU 里的内存管理单元(MMU)按照映射关系把它翻译成物理地址,再去访问内存。不同进程写的虚拟地址哪怕数值一样,映射到的物理地址也不同,自然就不会打架。 + +![虚拟地址到物理地址的映射过程:不同进程的相同虚拟地址通过 MMU 和页表映射到不同物理页](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-virtual-physical-mapping.png) + +小 G 习惯把虚拟内存的好处归成三条,后面整篇文章其实都在为这三条服务: + +- **进程隔离**:每个进程一套页表,互相看不到对方的物理内存,A 进程没法通过地址访问 B 进程的数据。 +- **突破物理内存大小限制**:程序运行有局部性,用不到的页可以先扔到磁盘上,需要时再换回来,于是进程“感觉到”的内存可以比物理内存大。 +- **统一且连续的地址空间**:进程看到的是一整片连续的虚拟地址,物理上却可以是东一块西一块的碎片,拼接的活儿交给映射表。 + +接下来的核心问题只有一个:虚拟地址到物理地址,这个映射到底怎么做。历史上有两条路线,分段和分页。 + +## 分段是怎么映射的? + +分段(Segmentation)出现得早,思路贴近程序员的直觉。一个程序天然由几类东西组成:代码、数据、栈、堆。它们的访问权限和生命周期都不一样,那就按逻辑切成若干个段。 + +分段下的虚拟地址由两部分构成:段选择子和段内偏移量。段选择子存在段寄存器里,其中最关键的是段号,用来当段表的索引。段表里每一项记着这个段的基地址、段界限(段有多长)和特权级。 + +翻译过程不复杂:拿段号去段表里查到段基地址,再检查段内偏移量有没有超出段界限,合法的话用基地址加偏移量就得到物理地址。举个例子,要访问段 3 偏移 500 的地址,段 3 基地址是 7000,那物理地址就是 7000 + 500 = 7500。 + +![分段地址转换示意图:虚拟地址由段号和段内偏移组成,通过段表查到基地址后计算物理地址](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-segmentation.png) + +分段解决了“程序不用关心物理地址”的问题,但留下两个坑。 + +**第一个是外部内存碎片**。因为每个段的长度不固定,段与段之间很容易抠出一些零碎的空隙。举个例子,物理内存里依次塞进四段:A 占 256 MB、B 占 128 MB、C 占 256 MB、D 占 128 MB。现在释放掉 B 和 D,空闲总量有 256 MB,但这 256 MB 是被 C 隔开的两块 128 MB,最大的连续空闲块还是只有 128 MB。这时想再开一个需要连续 200 MB 的段,就装不下了——总量够,但没有一块连续的 200 MB。 + +**第二个是整理碎片的代价高**。要把零散的空闲拼成连续的一块,得做内存紧凑:把还在用的段挪个位置,重排成连续空间。如果搬移过程还伴随把段换出到磁盘 Swap、再换回来,就会额外引入大块磁盘 I/O。不管哪种方式,变长段这种大粒度的搬移都很重,一旦动到大块头,整机都会卡。 + +说到底,段的粒度太大、又不固定,碎片和整理这两件事都很难收得住。 + +## 分页又是怎么映射的? + +分页(Paging)换了个思路:不按逻辑切,而是把虚拟地址空间和物理地址空间都切成固定大小的小块,每一块叫一页(Page)。Linux 下一页默认是 4 KB。 + +虚拟地址到物理地址通过页表(Page Table)映射,页表存在内存里,由 MMU 负责查表翻译。地址转换分三步: + +- 把虚拟地址拆成页号和页内偏移; +- 用页号去页表里查出对应的物理页号; +- 物理页号拼上页内偏移,得到最终物理地址。 + +![分页地址转换示意图:虚拟地址拆成页号和页内偏移,页表把虚拟页映射到物理页帧](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-paging.png) + +分页是怎么缓解分段那两个毛病的? + +页是固定大小、紧密排列的,物理页之间没有按段长留下的零碎空隙,所以基本**消除了外部碎片**。代价是页内可能有浪费:一个程序哪怕只用了几个字节,也得占满一整页,这部分是**内部碎片**。两害相权,固定页带来的内部碎片可控,比外部碎片好处理得多。 + +管理粒度也变小了。物理内存不够时,操作系统挑那些“最近没被用到”的页换出到磁盘(Swap Out),需要时再换入(Swap In),调入调出的最小单位从一整个变长段缩到了固定大小的页。不过别误以为分页就一定磁盘压力小:真遇到大量主缺页或抖动,频繁的页级 I/O 照样能把系统拖垮。 + +更妙的是,分页让程序不必一次性全部装进内存。先把虚拟页和物理页的映射关系建好,但并不真的把页搬进物理内存,等程序真正访问到某个虚拟页时,再把它加载进来。这就是按需调页(Demand Paging)的基础。 + +## 段页式:两者其实能合体 + +分段和分页不是对立的,可以叠在一起用,叫段页式内存管理。 + +做法是先分段再分页:先把程序切成有逻辑意义的段,再把每个段切成固定大小的页。地址结构因此变成三段:段号、段内页号、页内偏移。每个程序一张段表,每个段再挂一张页表,段表项里存的是该段页表的起始地址。 + +代价是访问内存的次数变多。一次段页式地址转换要走三趟内存:第一趟查段表拿到页表起始地址,第二趟查页表拿到物理页号,第三趟才用物理页号加页内偏移凑出物理地址。 + +这里插一段历史,能解释为什么 Linux 看起来“既分段又分页”。Intel 从 80286 开始用段式管理,到 80386 补上了页式管理,但页式是建立在段式之上的:逻辑地址先经段式映射成线性地址(也就是虚拟地址),线性地址再经页式映射成物理地址。CPU 硬件就是这么设计的,Linux 只能照办。 + +Linux 的对策是让分段形同虚设:把所有段的基地址都设成 0,每个段都覆盖整个 4 GB(32 位下)虚拟空间。这样一来,逻辑地址和线性地址数值上相等,段的概念被架空,只保留访问控制和内存保护的作用。所以严格说,Linux 主要靠分页管理内存。 + +## 单级页表为什么不够用? + +把分页落到真实系统,简单的单级页表会先在空间上崩掉。 + +算一笔账。32 位环境下虚拟地址空间是 4 GB,页大小 4 KB(2^12),那一个进程就需要约 100 万(2^20)个页。每个页表项占 4 字节,整张页表就要 4 × 2^20 = 4 MB。 + +4 MB 看着不大。但要命的是**每个进程都有自己的页表**。100 个进程就是 400 MB 内存全花在存页表上,64 位环境只会更夸张。 + +更别扭的是,单级页表必须把整个虚拟地址空间一次性铺满。原因在于页表的职责是翻译地址,万一某个虚拟地址在页表里找不到对应项,翻译就断了。所以哪怕进程实际只用了一小片地址,那 100 万个页表项也得老老实实全部建出来,绝大多数还都是空的。 + +## 多级页表怎么省空间? + +多级页表(Multi-Level Page Table)的核心招数是:**只为真正用到的地址建二级表,没用到的不建。** + +还是 32 位、4 KB 页的场景。把那 100 多万个页表项的单级页表再分一层:一级页表(页目录)有 1024 项,每一项指向一张二级页表,每张二级页表又有 1024 项。1024 × 1024 刚好覆盖 100 多万个页表项。 + +你可能立刻反驳:这不是多了一层吗,4 KB 的一级表加 4 MB 的二级表,岂不是更费? + +如果真把 4 GB 虚拟地址全映射满,确实更费。但现实里没有进程会用满 4 GB。关键就在这:一级页表必须常驻,它要覆盖全部地址空间,但它只占 4 KB;而二级页表是按需创建的,某个一级表项没被用到,对应的那张二级表就根本不建。 + +算个数。假设只有 20% 的一级表项被用到,那页表总开销就是 4 KB(一级)+ 20% × 4 MB(二级)≈ 0.804 MB,对比单级的 4 MB,省了一大截。省下的这部分,吃的是局部性原理的红利:程序在一段时间内只访问地址空间里的一小块。 + +到了 64 位,两级远远不够。当前 Linux 的通用页表抽象其实是五级,自顶向下是: + +- 全局页目录 PGD(Page Global Directory) +- 第四级目录 P4D(Page 4th Directory) +- 上层页目录 PUD(Page Upper Directory) +- 中间页目录 PMD(Page Middle Directory) +- 页表项 PTE(Page Table Entry) + +![多级页表示意图:PGD、PUD、PMD、PTE 分层索引,只为实际使用的地址范围创建下级页表](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-multi-level-page-table.png) + +在只用四级硬件分页的 x86-64 上,P4D 这一层会被“折叠”掉、不实际占用转换层级,所以你常听到的“四级页表”是这种折叠后的形态,而不是 Linux 里只定义了四级。 + +具体到 x86-64,目前主流是四级分页,用 48 位虚拟地址(寻址 256 TB)。一个 64 位虚拟地址这样拆:高 16 位是符号扩展位,接下来 PGD、PUD、PMD、PTE 各占 9 位(每级正好 512 项,2^9),最低 12 位是页内偏移(对应 4 KB 页)。每个页表项是 8 字节(64 位),512 项 × 8 字节 = 4 KB,每一级页表自己刚好占满一个页,设计得很整齐。 + +需要更大地址空间时,x86-64 提供了五级分页(LA57),把规范线性地址从 48 位扩到 57 位,物理地址最多 52 位。这里要注意两点:一是 Linux 文档把它描述为最多给用户空间 56 位虚拟地址,而且为了兼容那些把指针高位拿去做 tagging 的程序,内核默认不会主动在 47 位以上分配地址,除非应用显式请求;二是时间线别记岔,Linux 从 4.14(2017 年)起支持五级分页,是否启用取决于 CPU 和内核配置,Intel 这边明确支持 57 位虚拟、52 位物理地址的是第三代至强可扩展(Ice Lake 服务器平台,2021 年发布)。普通机器默认还是四级。 + +## TLB(快表)解决了什么? + +多级页表省了空间,却带来时间开销:原来查一次表,现在 64 位下要查四级,每多一级就多一次访存。一次内存访问背后藏着四五次查表访存,太亏了。 + +救场的还是局部性原理:程序在一段时间内反复访问的就那么几个页。那就把最常用的几个页表项,缓存到比内存快得多的硬件里。这块缓存就是 TLB(Translation Lookaside Buffer),中文叫快表、转址旁路缓存。它封装在 CPU 的 MMU 里。 + +有了 TLB,CPU 寻址时先查 TLB: + +- 命中(TLB Hit),直接拿到物理页号,跳过整套多级页表的查找。 +- 未命中(TLB Miss),才老老实实去查内存里的多级页表,查到之后再把这一项塞进 TLB,方便下次。 + +![TLB 缓存地址转换结果的流程:CPU 先查 TLB,命中直接访问内存,未命中再查多级页表并更新 TLB](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-tlb-cache.png) + +因为热点页就那么几个,TLB 命中率通常很高,所以多级页表带来的查表开销,大部分时候被 TLB 吃掉了。 + +## 缺页中断(Page Fault)是怎么走完的? + +按需调页意味着:进程访问某个虚拟页时,这个页不一定在物理内存里。一旦 MMU 发现页表项指示该页不在内存(页表项里有个存在位 / present bit),就触发一次缺页中断,把控制权交给内核的缺页处理程序。 + +大致流程是这样: + +1. CPU 拿着虚拟地址查页表,发现目标页不在物理内存,触发缺页中断(一种硬件异常)。 +2. 进入内核态,缺页处理程序先判断这次访问是否合法。如果访问的是非法地址(比如野指针),就报段错误(Segmentation Fault),进程通常被杀掉。 +3. 合法的话,找一个空闲物理页帧。如果没有空闲帧,就得回收/置换一个“受害者”页:干净的文件页可以直接丢弃(要用时再从原文件读回),脏的文件页要先写回原文件,匿名页则在启用了 Swap 时写入交换空间——会不会真产生磁盘写,取决于页的类型和脏不脏。 +4. 把需要的页从磁盘(Swap 区或文件)读进物理内存,更新页表项,让它指向新的物理页帧。 +5. 返回用户态,重新执行刚才那条触发缺页的指令,这次就能正常访问了。 + +![缺页中断处理流程:MMU 发现页不在内存后进入内核,检查访问合法性、分配或置换页帧、更新页表并重试指令](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-page-fault.png) + +从 Linux 的性能统计角度,缺页主要分两类(`getrusage` 里也只有 `ru_minflt` 和 `ru_majflt`): + +- **次缺页(Minor Page Fault)**:页其实已经在物理内存里了,只是当前进程的页表还没建立映射,比如多个进程共享的库;写时复制(COW)触发的页复制通常也算次缺页,因为它要新建或复制页面,但不用读盘。开销小。 +- **主缺页(Major Page Fault)**:页确实不在内存,必须从磁盘(文件或 Swap)读进来,开销大。 + +至于访问非法地址(比如野指针),它同样会由硬件触发 page-fault 异常进内核,但内核判定非法后一般是给进程发 `SIGSEGV`,这属于错误处理,通常不和 minor/major 并列当成第三种性能统计类别。 + +如果物理内存太紧,系统大部分时间都在换入换出页,CPU 没怎么干正事,全在搬数据,这种恶性状态叫**抖动(Thrashing)**。 + +## 页面置换算法:换谁出去? + +物理内存满了又要装新页,就得挑一个页换出去。挑得好,后面少缺页;挑得差,刚换出去的页转头又要用,白折腾。常见算法有这么几个。 + +**OPT(最优置换)**:换出“未来最长时间内不会被访问”的页。它的缺页次数理论上最少,但需要预知未来,现实里实现不了,主要当衡量其他算法好坏的标尺。 + +**FIFO(先进先出)**:维护一个队列,谁最早进来就先换谁出去。实现简单,但很蠢——一个页待得久不代表以后用不到,可能正是个热点页,结果刚踢走又得加载回来。 + +**LRU(最近最少使用)**:换出“最久没被访问”的页。它赌的是局部性:最近用过的页,接下来大概率还会用。LRU 效果接近 OPT,但代价高:要么给每个页维护时间戳,要么用链表在每次访问时把页移到表头,硬件和软件开销都不小,纯软件实现很难扛住高频访问。 + +**CLOCK(时钟 / 二次机会)**:LRU 的近似实现,用来绕开 LRU 的高成本。给每个页加一个访问位(reference bit)。所有页排成一个环,一根指针像时钟一样转。要换页时,指针指到谁就看它的访问位:是 1,说明最近用过,给它“第二次机会”,把访问位清 0,指针往下走;是 0,就换这一页出去。一个访问位加一圈环形扫描,就廉价地模拟出了“最近有没有被用过”。 + +![CLOCK 页面置换算法示意图:页面按环形队列排列,指针根据访问位 R 判断给第二次机会还是淘汰页面](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-clock-algorithm.png) + +**LFU(最不经常使用)**:给每个页记访问次数,换出访问次数最少的页。它赌的是访问频率而非访问时间。问题是早期被频繁访问、后来不用的页,计数很高却赖着不走,所以实际中常配合计数衰减来用。 + +横向对比一下: + +| 算法 | 换出依据 | 实现成本 | 效果 | 能不能落地 | +| ----- | ----------------- | ----------------- | -------------------- | ---------------- | +| OPT | 未来最久不用 | 无法实现 | 理论最优 | 只作基准 | +| FIFO | 进入时间最早 | 很低 | 一般,可能误伤热点页 | 能 | +| LRU | 最久未访问 | 高(时间戳/链表) | 接近 OPT | 纯软件较吃力 | +| CLOCK | 访问位 + 环形扫描 | 低 | 接近 LRU | 能,主流近似方案 | +| LFU | 访问次数最少 | 中(需计数) | 看场景 | 能,常配衰减 | + +提一句别误会:上面这些是教科书算法,用来理解置换策略的思路。真实的 Linux 内核并不是直接在 OPT/FIFO/LRU/CLOCK 里挑一个,而是用活跃/非活跃双 LRU 链表、workingset、refault 检测这套近似机制,文件页和匿名页的回收策略也不一样,还受 NUMA、cgroup、内存水位影响。所以“Linux 用的就是 CLOCK”这种话不能直接下结论。 + +## Belady 异常:加内存反而更慢? + +直觉上,物理内存的页帧越多,缺页应该越少。但 FIFO 会打脸:**有时候增加页帧数,缺页次数反而变多了**,这就是 Belady 异常(Belady's Anomaly),由 László Bélády 在 1960 年代发现。 + +用经典的访问串就能复现。访问序列 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5,跑 FIFO: + +- 3 个页帧时,缺页 9 次。 +- 4 个页帧时,缺页 10 次。 + +帧多了一个,缺页反而多了一次,违反直觉。 + +根因在于 FIFO 不满足**栈性质(stack property)**:n 个页帧时驻留的页集合,不一定是 n+1 个页帧时驻留页集合的子集。一旦这个包含关系断了,加帧就可能踢错页。 + +满足栈性质的算法叫栈算法,它们对每个页的置换优先级与帧数无关,所以从数学上免疫 Belady 异常。OPT 和 LRU 都是栈算法,可以证明帧数增加时缺页只会减少或不变,不会反增。FIFO 不满足这个性质,所以会出问题。至于 LFU 会不会出现 Belady 异常,取决于它的频率统计方式和相同频率时的 tie-break 规则,不能笼统归进“免疫”那一类。 + +CLOCK 也别想当然:经典的二次机会/CLOCK 是 LRU 的近似,但并不具备 LRU 那种严格的栈性质(极端情况下所有访问位都是 1 时它会退化成 FIFO),所以不能因为它“近似 LRU”就推出它必然免疫 Belady 异常。稳妥的结论是:FIFO 存在会触发 Belady 异常的访问序列,OPT 和 LRU 一定不会,CLOCK、LFU 这类要看具体定义,别简单背成“近似 LRU 就一定免疫”。 + +记住一个结论就够用了:Belady 异常是 FIFO 这类非栈算法的毛病,遇到“加内存性能反降”的诡异现象,先怀疑置换策略,而不是怀疑内存条坏了。 + +## 这些概念在工程里怎么用? + +虚拟内存不是只活在操作系统课本里,往上层走几步就能撞见它。 + +**mmap 与零拷贝**:`mmap()` 把文件直接映射到进程的虚拟地址空间,读文件变成访问内存。映射建立时并不真的把文件读进来,等你访问到某一页才触发缺页、按页加载,这正是按需调页。它省掉了一次从内核缓冲区到用户缓冲区的拷贝,是零拷贝方案里常用的一招。 + +**Redis 的内存与碎片**:Redis 是纯内存数据库,但它申请的内存最终也要落到物理页上。内存分配器(默认 jemalloc)按固定大小档位(size class)分配,会有空间浪费。它和分页里“不足一页也占一页”在“分配粒度大于实际用量”这点上很像,但一个发生在用户态分配器、一个发生在操作系统分页层,产生位置和治理方式都不同,不能直接当成同一种碎片。Redis 持久化时 fork 出子进程做快照,靠的也是写时复制(Copy-On-Write)——父子进程先共享同一批物理页,谁写谁才触发页复制,背后还是页表那套机制。 + +**JVM 的堆**:JVM 向操作系统申请的堆,也是一片虚拟地址空间。大堆会拉大页表要覆盖的范围,配大页(HugePage / 2 MB 大页)能减少页表项数量、缓解 TLB 压力,对降低 GC 期间的访存开销有帮助。GC 扫描对象时反复跳来跳去、访问局部性差,更直接的代价是 cache miss 和 TLB miss 增多;只有当相关页还没驻留、被回收过,或系统本身内存吃紧时,才会进一步表现为缺页。这也是大堆调优要盯 TLB 的原因。 + +往下是硬件的页表和 TLB,往上是数据库、JVM、零拷贝,中间这层虚拟内存,是把它们串起来的公共地基。 + +## 面试里怎么答? + +如果面试官问“为什么需要虚拟内存”,别只背“为了隔离”。可以这样答:虚拟内存先把进程看到的地址和真实物理地址隔开,让每个进程都像在独占一片连续内存;MMU 再配合页表把虚拟地址翻译成物理地址。这样做有三个直接收益:进程之间互不踩内存,程序不用关心物理内存摆放位置,操作系统还能按需分配、换页和做 COW。 + +如果继续追问“分页解决了什么”,重点放在分段和分页的差别上。分段按逻辑模块切,长度不固定,容易产生外部碎片,整理起来也重;分页把虚拟地址空间和物理内存都切成固定大小的页,页表记录“虚拟页号 → 物理页帧”的映射,基本消除了外部碎片,但会有少量内部碎片。多级页表的作用不是让查找更快,而是让没用到的地址空间不用真的建页表,靠空间换结构。 + +问到 TLB 和缺页中断时,可以按这条线说:CPU 先查 TLB,命中就直接拿到物理页号;没命中再走多级页表。页表项如果显示页不在内存,就触发缺页异常,内核判断访问是否合法,合法才分配页帧、必要时回收旧页、从文件或 Swap 调入页面,最后更新页表并重新执行那条指令。minor fault 通常不用读盘,major fault 要读盘,非法访问则会走到 `SIGSEGV`。 + +页面置换算法不用背一堆名词,抓住评价标准就行:换出去的页后面越晚用越好。OPT 最优但做不到,LRU 接近 OPT 但实现成本高,CLOCK 用访问位给 LRU 做近似,FIFO 简单但可能出现 Belady 异常。真实 Linux 不是照搬某个教科书算法,而是用活跃/非活跃 LRU、workingset、refault 等机制做近似回收。 + +## 参考资料 + +- [小林 coding:《为什么要有虚拟内存?》](https://www.xiaolincoding.com/os/3_memory/vmem.html) +- [IBM Think:What is virtual memory?](https://www.ibm.com/think/topics/virtual-memory) +- [OSDev Wiki:Paging(x86-64 四级 / 五级分页结构)](https://wiki.osdev.org/Paging) +- [GeeksforGeeks:Belady's Anomaly in Page Replacement Algorithms](https://www.geeksforgeeks.org/operating-systems/beladys-anomaly-in-page-replacement-algorithms/) diff --git a/docs/cs-basics/operating-system/zero-copy.md b/docs/cs-basics/operating-system/zero-copy.md new file mode 100644 index 00000000000..df28c752240 --- /dev/null +++ b/docs/cs-basics/operating-system/zero-copy.md @@ -0,0 +1,256 @@ +--- +title: 零拷贝详解:mmap、sendfile 与 splice +description: 零拷贝高频面试题总结,讲清传统 read/write、mmap、sendfile、splice 的拷贝路径、上下文切换、SG-DMA、Java NIO、Kafka 和 RocketMQ 的应用场景。 +category: 计算机基础 +tag: + - 操作系统 + - Linux + - 高性能 +head: + - - meta + - name: keywords + content: 零拷贝,mmap,sendfile,splice,SG-DMA,Page Cache,Java NIO,FileChannel,transferTo,Kafka,RocketMQ,操作系统面试题 +--- + +面试里有个很常见的套路:先问你“Kafka 为什么快”“RocketMQ 为什么扛得住堆积”,等你答出顺序写、Page Cache、零拷贝之后,面试官顺势往下挖:“零拷贝具体省掉了哪几次拷贝?”“mmap 和 sendfile 有什么区别?”“splice 又是干嘛的?” + +到这一步,很多人就开始打太极了。能背出“零拷贝就是不经过用户态”的不少,能把四次拷贝、两次 DMA、几次上下文切换的账算清楚的不多。 + +小 G 这篇就把这本账捋一遍:传统 I/O 到底拷了几次,零拷贝的“零”到底零在哪,mmap、sendfile、splice 三条路线各自省了什么、又各自有什么代价。 + +## 先说清楚这本账的前提 + +后面“几次拷贝、几次切换”的数字都是在一个简化模型下算的,脱离前提就不准。先把假设摆明: + +- 场景是把一个普通文件通过 TCP socket 发出去,且数据初始不在 Page Cache 里(需要真正读盘)。 +- 不涉及 TLS 加密、压缩、格式转换这类要在用户态碰数据的处理。 +- 设备支持常见的 DMA 与 scatter-gather。 +- 数到的“拷贝次数”只算数据本身(payload),不含描述符、元数据。 +- 下文说的“上下文切换”,准确讲是**用户态和内核态之间的模式切换**(一次系统调用进出各算一次),它和线程被调度器换上换下的“线程上下文切换”不是一回事;只有系统调用真的阻塞、线程被换出时,才会额外发生线程上下文切换。 + +Page Cache 命中、走 TLS、硬件不支持 SG-DMA,这些数字都会变。模型是用来理解机制的,不是放之四海皆准的常数。 + +## 传统 read/write 到底拷了几次 + +先看一个最常见的场景:一个文件下载接口,服务端要把磁盘上的文件,通过已经建立好的 socket 发给客户端。最直接的写法就是一个 read 加一个 write: + +```c +while ((n = read(file_fd, buf, BUF_SIZE)) > 0) + write(socket_fd, buf, n); +``` + +看着只有两行,底层却折腾得不轻。一次完整的“读磁盘 + 发网络”,CPU 和 DMA 一共要搬四趟数据,用户态和内核态之间还要来回切四次。 + +![传统 read/write 的数据拷贝路径:磁盘到内核缓冲区、内核到用户缓冲区、用户到 Socket 缓冲区、Socket 到网卡](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-traditional-read-write.png) + +把这两行拆开看,read 这一半发生了什么: + +1. 应用进程调用 read,发起系统调用,**上下文从用户态切到内核态**(第 1 次切换)。 +2. DMA 控制器把数据从磁盘读进内核读缓冲区(第 1 次拷贝,DMA 拷贝)。 +3. CPU 把内核读缓冲区的数据拷到用户缓冲区(第 2 次拷贝,CPU 拷贝),**上下文切回用户态**(第 2 次切换),read 返回。 + +write 这一半是对称的: + +4. 应用进程调用 write,发起系统调用,**上下文切到内核态**(第 3 次切换)。 +5. CPU 把用户缓冲区的数据拷到 socket 缓冲区(第 3 次拷贝,CPU 拷贝)。 +6. DMA 把 socket 缓冲区的数据拷到网卡(第 4 次拷贝,DMA 拷贝),**上下文切回用户态**(第 4 次切换),write 返回。 + +数一下:**4 次模式切换,4 次数据拷贝**,其中 2 次是 DMA 拷贝、2 次是 CPU 拷贝。(严格说,`write` 把数据复制进 socket 发送缓冲区后通常就返回了,网卡的排队、分段和 DMA 发送是协议栈异步完成的,并不需要等 DMA 真正发完才切回用户态。这里把它画进一次调用里,只是为了把账算齐。) + +这里插一句 DMA(Direct Memory Access,直接内存访问)。它是设备控制器或系统里的 DMA 引擎提供的能力,能在外设和内存之间直接搬数据,全程基本不用 CPU 盯着(现代硬件里它通常集成在设备控制器、SoC 或芯片组中,未必是一块独立芯片)。磁盘到内核缓冲区、socket 缓冲区到网卡这种纯体力活交给它,CPU 就能腾出手算别的,所以 DMA 拷贝并不烧 CPU。 + +真正难受的是那两次 **CPU 拷贝**。数据从内核读缓冲区拷到用户缓冲区,再从用户缓冲区原样拷回 socket 缓冲区,可我们这个下载接口压根没碰过它的内容,数据只是路过用户空间打了个转。CPU 全程在做无意义的搬运,外加四次切换的寄存器保存恢复开销。高并发、大文件场景下,这部分浪费会被放大得很明显。 + +零拷贝要省的,就是这部分。 + +## 零拷贝的“零”,零的是哪个拷贝 + +先纠正一个常见误解:零拷贝不是真的一次拷贝都没有。 + +数据从磁盘到网卡,物理上的搬运绕不开。准确说,**零拷贝省掉的是 CPU 拷贝,以及随之减少的上下文切换**;那两次 DMA 拷贝(磁盘到内核、内核到网卡)是硬件的事,谁也省不掉。 + +所以零拷贝更精确的定义是:在 I/O 操作中让 CPU 不再参与数据在内存之间的复制,从而减少 CPU 拷贝和用户态/内核态切换的次数。它是一类技术的统称,下面三条路线都是在围着“怎么干掉 CPU 拷贝”做文章。 + +## 路线一:mmap + write + +第一个思路来自虚拟内存。现代操作系统用虚拟地址替代物理地址,这里有个关键特性:**多个虚拟地址可以指向同一块物理内存**。 + +mmap 用的正是这一点。它的函数签名长这样: + +```c +void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); +``` + +其中 fd 是要映射的文件描述符,length 是映射长度,offset 是文件偏移。调用之后,内核读缓冲区会和用户空间的一段虚拟地址映射到同一块物理内存上。换句话说,内核缓冲区和用户缓冲区“共享”了同一份数据,不再各存一份。 + +于是原来的 read + write 就变成了 mmap + write。这里要先破除一个常见误区:**`mmap` 调用本身只是建立文件到一段虚拟地址的映射,并不会立刻把文件读进内存**。真正的读盘发生在后面访问到尚未驻留的映射页、触发缺页中断时,由内核从 Page Cache(没有就从磁盘)按页加载。流程大致是: + +1. 应用进程调用 `mmap`,内核建立文件到虚拟地址区间的映射,进出内核态各一次,调用返回。此时还没有任何文件数据被搬进来。 +2. 后续访问这段映射区(典型是把它当作 `write` 的数据源),首次碰到未驻留的页就触发缺页中断;若 Page Cache 里没有该页,DMA 把数据从磁盘读进 Page Cache(DMA 拷贝)。 +3. 页表建立映射后,这段内核 Page Cache 页同时映射进了用户地址空间,两边共享同一份物理内存。 +4. 应用调用 `write`,CPU 把这份数据从内核 Page Cache 拷进 socket 缓冲区(CPU 拷贝)——因为共享物理内存,省掉了传统方式里“内核到用户、再回内核”那次多余的 CPU 拷贝。 +5. DMA 把 socket 缓冲区的数据发往网卡(DMA 拷贝),`write` 返回。 + +![mmap + write 的数据拷贝路径:Page Cache 与 mmap 映射区共享物理内存,再复制到 Socket 缓冲区](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-mmap-write.png) + +算账(缓存未命中、走完整路径时):大致 **2 次 DMA + 1 次 CPU 拷贝**;切换上 `mmap` 一次、`write` 一次,外加首次访问的缺页处理。和传统方式比,mmap 干掉的是“内核到用户”那次 CPU 拷贝。 + +所以“mmap + write 固定是 4 次切换、3 次拷贝”只能当教学简化模型——Page Cache 命中与否、缺页发生在哪,都会让真实数字浮动。 + +mmap 还有个附带好处:用户进程不必再维护一份和 Page Cache 内容重复的用户态读缓冲区,省掉了这块额外的缓冲和复制。至于到底省多少物理内存,取决于处理窗口、缓冲区大小和访问模式,不能一概而论说“省一半”。 + +不过 mmap 不是没有坑。映射本身有成本,建立和拆除页表、处理缺页中断都要花时间,文件很小的时候,这点开销摊下来可能比老老实实 read/write 还慢,所以 mmap 更适合大文件、反复读写。还有个更隐蔽的雷:如果你映射的文件被另一个进程截断(truncate),你再去访问被截掉的那段映射区,会直接吃一个 SIGBUS 信号,程序当场挂掉。这类问题在生产环境里排查很费劲,用 mmap 时得心里有数。 + +## 路线二:sendfile + +mmap 省了一次 CPU 拷贝,但它仍然绕不开 `mmap` 和 `write` 两类系统调用;如果只是把文件原样发出去,能不能用一次系统调用把内核内的数据传输做完? + +Linux 2.1 内核引入的 sendfile 就是干这个的: + +```c +ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count); +``` + +- in_fd:数据来源,必须是支持 mmap 式读取的对象(通常是普通文件),不能是 socket。 +- out_fd:数据去向,在 Linux 2.6.33 之前只能是 socket,之后可以是任意文件。具体限制要绑定内核版本看。 +- offset:从文件哪个位置开始读,传 NULL 表示用文件当前偏移。 +- count:传输多少字节。 + +它的语义是:在两个文件描述符之间直接传数据,整个过程都在内核里完成,数据完全不经过用户空间。流程缩短成: + +1. 应用进程调用 sendfile,**切到内核态**(第 1 次模式切换)。 +2. DMA 把数据从磁盘拷到内核读缓冲区(DMA 拷贝)。 +3. CPU 把内核读缓冲区的数据拷到 socket 缓冲区(CPU 拷贝)。 +4. DMA 把 socket 缓冲区的数据拷到网卡(DMA 拷贝),**切回用户态**(第 2 次模式切换),sendfile 返回。 + +算账:**2 次模式切换,3 次数据拷贝(2 次 DMA + 1 次 CPU)**。 + +对比 mmap,sendfile 的核心优势是把文件到 socket 的转发收进一次系统调用里,通常少了一轮用户态/内核态来回;代价是它比 mmap“死板”:数据全程在内核里走,用户态根本看不到也碰不到这份数据。如果你需要在传输前改一改文件内容,sendfile 帮不上忙,这种场景只能用 mmap。 + +走到这里还剩一次 CPU 拷贝(内核读缓冲区到 socket 缓冲区)。能不能连这一次也干掉? + +## 路线三:sendfile + SG-DMA(真正的零拷贝) + +Linux 2.4 给 sendfile 做了升级,关键是引入了 SG-DMA(scatter/gather DMA,分散/聚集 DMA)。这项硬件能力让 DMA 可以直接从内核读缓冲区把数据搬到网卡,不必先经过 socket 缓冲区。 + +升级后的流程: + +1. 应用进程调用 sendfile,**切到内核态**(第 1 次模式切换)。 +2. DMA 把数据从磁盘拷到内核读缓冲区(DMA 拷贝)。 +3. CPU 不再拷贝数据本身,只把这份数据在内核缓冲区里的**描述信息**(内存地址 + 偏移量长度)写进 socket 缓冲区。 +4. SG-DMA 根据这些描述信息,直接把数据从内核读缓冲区搬到网卡(DMA 拷贝),**切回用户态**(第 2 次模式切换),sendfile 返回。 + +![sendfile + SG-DMA 的数据拷贝路径:Socket 缓冲区只保存描述信息,网卡通过 SG-DMA 直接读取内核缓冲区](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-sendfile-sg-dma.png) + +算账:**2 次模式切换,2 次数据拷贝,且两次都是 DMA 拷贝,payload 的 CPU 拷贝为 0**。 + +这才是名副其实的零拷贝:全程没有任何一次靠 CPU 搬运 payload,磁盘到网卡完全由 DMA 完成。第 3 步 CPU 写的那点描述信息只是几个字节的元数据,不算数据拷贝。不过能不能真走到这条路径有前提:网卡得支持 scatter-gather、内核版本够、协议栈中途不需要碰数据。一旦开启用户态 TLS 加密、要做格式转换,内核就得真正读到 payload,这条 0 CPU 拷贝的路就走不通了。 + +## 路线四:splice + +sendfile 已经很好了,但它有个硬限制:in_fd 得是支持 mmap 式读取的对象(通常是普通文件),不能是 socket,out_fd 早期也只能是 socket。如果想在两个 socket 之间、或者更一般的两个描述符之间做零拷贝转发,sendfile 就不够用了。 + +Linux 2.6.17 内核引入的 splice(由 Jens Axboe 提交,需要 glibc 2.5 支持)补上了这块。它的思路是借道**管道(pipe)**: + +```c +ssize_t splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, + size_t len, unsigned int flags); +``` + +splice 要求 fd_in 和 fd_out 中**至少有一个是管道**。它为什么要绑着管道?因为 Linux 的管道底层是一组**引用计数的页指针**:管道缓冲区里存的不是数据本身,而是指向内核内存页的指针,外加每页的引用计数。所谓“把数据从管道挪到另一端”,多数情况下只是复制指针、给对应的页引用计数加一,不真正搬动 payload。要提醒的是,`SPLICE_F_MOVE` 只是给内核的一个提示,并非硬保证——遇到某些文件系统、设备或缓冲区形态无法直接移动页时,内核仍可能退化成真正的复制。 + +用 splice 实现文件到 socket 的传输,得**两步走、两次系统调用**: + +```c +splice(file_fd, NULL, pipe_w, NULL, len, SPLICE_F_MOVE); // 文件 → 管道写端 +splice(pipe_r, NULL, socket_fd, NULL, len, SPLICE_F_MOVE); // 管道读端 → socket +``` + +![splice 的数据转发路径:文件页先挂到管道缓冲区,再从管道转发到 Socket](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-splice-flow.png) + +第一次把 Page Cache 里的页挂到管道缓冲区上,第二次把这些页指针当作网络包的分片发往 socket。数据全程不进用户空间,CPU 不搬运 payload。但要看清楚:这是**两次 `splice` 调用**,进出内核态各算一次,合计大约 4 次模式切换,并不是有些文章说的“和 sendfile 一样只有一次系统调用、两次切换”。实际工程里两个 fd 还得设非阻塞、配合 epoll,并处理短传输和 `EAGAIN`。 + +splice 和前面几位的区别可以这么理解: + +- **比 sendfile 通用**:sendfile 更专注于内核内 fd 到 fd 的传输(典型是文件到 socket);splice 借助管道,能在更广的描述符之间转发数据,包括 socket 到 socket。有些内核版本内部会复用相关实现,但两者是独立的系统调用,参数限制和演进各不相同,别简单理解成严格的父子继承关系。 +- **和 mmap 取向相反**:mmap 把数据映射到用户空间,让你能改;splice 的全部意义就在于数据压根不碰用户空间,你看不见也改不了。 + +补一个版本细节:在 Linux 2.6.30 及更早,fd_in 和 fd_out 必须恰好有一个是管道;从 2.6.31 开始,两端可以都是管道。 + +## 四种方式横向对比 + +把上面四条路线放一起看,账就一目了然了: + +| 方式 | CPU payload 拷贝 | DMA 拷贝 | 模式切换 | 典型系统调用 | +| -------------------------- | ------------------------ | -------- | -------------------------------------- | ---------------------- | +| 传统 read + write | 2 | 2 | 4 | read + write | +| mmap + write | 1 | 2 | 映射后发送通常至少 2,首次访问另有缺页 | mmap 一次 + write 多次 | +| sendfile | 0 或 1(取决于发送路径) | 通常 2 | 2 | sendfile | +| splice(文件→管道→socket) | 通常可避免 | 通常 2 | 4 | splice 两次 | + +![传统 read/write、mmap + write、sendfile + SG-DMA 和 splice 的拷贝次数与模式切换对比](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-four-ways-comparison.png) + +(mmap 那行的拷贝/切换次数随 Page Cache 命中与缺页时机浮动,不宜钉成固定值;sendfile 在网卡支持 SG-DMA 时,CPU payload 拷贝降到 0。) + +两个结论: + +**第一,2 次 DMA 拷贝在所有方式里都省不掉。** 因为它们是硬件完成的,分别对应“磁盘到内核”和“内核到网卡”这两段物理搬运。很多朋友会误以为零拷贝优化的是 DMA,实际省的是 CPU 拷贝和模式切换。 + +**第二,选哪条路,先看数据要不要被应用碰一下。** 传输前要改内容,用 mmap 更顺手;只是把文件原样发出去,sendfile 更合适,网卡支持 SG-DMA 时还能把 CPU payload 拷贝压到 0。splice 的位置更靠后:只有文件到 socket 之外的 fd 转发需求,比如 socket 到 socket,才值得把管道这层搬出来,同时也要接受两次系统调用的成本。 + +零拷贝也不是开关一拧就永远赚。开了 TLS、要压缩、要做格式转换,payload 迟早要进用户态处理;内容过滤、加水印、限速也是同一类问题。文件很小或者访问很随机时,映射、缺页、管道这些固定开销可能反而更显眼。 + +mmap 还要小心文件被 truncate 后访问旧映射触发 SIGBUS;零拷贝发送量很大时,Page Cache 被挤占、内存回收变重,也会把收益吃掉一部分。 + +## Java 里怎么用零拷贝 + +Java NIO 把这两条主线都封装了,对应关系很清楚。 + +**MappedByteBuffer 对应 mmap。** 通过 FileChannel.map 拿到一个 MappedByteBuffer,底层调用的就是 Linux 的 mmap,把文件(或文件的一部分)映射进内存,之后直接操作内存就行,不用再走 read/write 系统调用: + +```java +FileChannel channel = FileChannel.open( + Paths.get("./data.bin"), + StandardOpenOption.READ, StandardOpenOption.WRITE); +// 把文件映射到内存,底层是 mmap +MappedByteBuffer buffer = channel.map( + FileChannel.MapMode.READ_WRITE, 0, channel.size()); +``` + +**FileChannel.transferTo / transferFrom 可能用到 sendfile。** 注意是“可能”:Java API 只承诺把字节送到目标 Channel,并不保证用哪个系统调用。在支持的平台上,当目标是 socket 时,JDK 可能走 `sendfile` 这类内核传输路径;目标是普通文件或别的 Channel 时,又可能走别的路径,甚至退化成用户态复制。所以下面这个示例把目标写成 `SocketChannel`,才更贴近零拷贝的场景: + +```java +FileChannel source = FileChannel.open( + Paths.get("./in.dat"), StandardOpenOption.READ); +// socketChannel 是一条已连接的 SocketChannel +// 文件 → socket,JDK 在支持的平台上可能使用零拷贝优化(如 sendfile) +source.transferTo(0, source.size(), socketChannel); +``` + +这里有个容易踩的坑:`transferTo` 不保证一次就传完,调用方必须根据返回值循环处理剩余数据。底层若走 Linux `sendfile`,单次上限是 `0x7ffff000`(约 2 GB)字节;但 Java 层暴露的具体上限、以及到底走没走零拷贝路径,都要结合 JDK 版本和目标平台验证——比如 Windows 上的行为就和 Linux 不完全一致。 + +## Kafka 和 RocketMQ 各用了哪一种 + +零拷贝最常被拿来解释 Kafka、RocketMQ 为什么快,但这两家选的路线其实不一样,背后是各自读写模式的差异。 + +**Kafka 消费端用零拷贝发送。** 消费者来拉消息时,Kafka 要把日志段文件(log segment)从磁盘发到网络,这是典型的“只转发、不修改内容”,于是它用 `FileChannel.transferTo` 把日志直接从 Page Cache 送进 socket,数据不进 JVM 堆。再叠加生产端的顺序写和 Page Cache,高吞吐就是这么攒出来的。(顺带一提,Kafka 的索引文件用的是 mmap。)但零拷贝不是无条件生效:一旦需要做消息格式转换、解压重压缩,或开启了 TLS 要在用户态加密,payload 就得被读出来处理,这条路径会退化——能不能用零拷贝,要结合 Kafka、JDK 和操作系统版本判断。 + +**RocketMQ 主要走 mmap。** RocketMQ 的 CommitLog 用 MappedByteBuffer 做内存映射来读写文件,这也是它把 CommitLog 设计成固定大小文件的原因之一,固定大小便于映射管理。选 mmap 而不是 sendfile,是因为它的读写模式需要更灵活地操作映射出来的这段内存,而不只是把文件原样转发出去。 + +一句话区分:**单纯转发选 sendfile,需要操作映射内存选 mmap**,这正好呼应前面那条“要不要改数据”的判断标准。 + +## 延伸:Rust 的 zerocopy crate 是另一回事 + +搜"zerocopy"很容易搜到 Google 维护的一个 Rust 库 [google/zerocopy](https://github.com/google/zerocopy),由 Google 工程师持续维护,下载量很大、活跃度没问题。它的版本号更新很快(写作时已到 0.8.x 系列),这里就不钉死某个具体数字了,以 crates.io 和 GitHub Release 为准。 + +但要提醒一句:**这个 crate 和本文讲的操作系统零拷贝不是一个概念**,别混淆。OS 层面的零拷贝说的是 I/O 过程中减少 CPU 在内核/用户缓冲区之间的数据搬运;而 Rust 的 zerocopy crate 解决的是**类型安全的内存转换**,在字节序列和结构体之间做安全转换(safe transmutation),不必拷贝、也不写 unsafe。两者都叫"zero copy",一个在讲系统调用和 DMA,一个在讲语言层面的内存布局与类型安全,别在面试里混为一谈。 + +## 面试里怎么答? + +面试里问“零拷贝是什么”,先把“零”说准:它不是没有任何拷贝,磁盘到内存、内存到网卡这两段 DMA 搬运通常还在;零拷贝主要省的是 CPU 在内核缓冲区和用户缓冲区之间搬 payload 的那几次,以及随之减少的模式切换。 + +传统 `read + write` 可以按 4 次拷贝来讲:磁盘到内核缓冲区是 DMA,内核到用户缓冲区是 CPU,用户缓冲区到 Socket 缓冲区还是 CPU,Socket 缓冲区到网卡是 DMA。这里最浪费的是两次 CPU 拷贝,因为应用并没有改数据,只是让数据经过用户空间转了一圈。 + +几种方案的回答顺序可以这么排:`mmap + write` 让用户空间和 Page Cache 映射同一批物理页,省掉“内核到用户”那次 CPU 拷贝,但还要 `write` 到 Socket 缓冲区;`sendfile` 把文件到 socket 的转发放进一次系统调用,数据不进用户态;配合 SG-DMA 时,Socket 缓冲区只放描述信息,payload 可以直接由 DMA 从内核缓冲区送到网卡;`splice` 则借助 pipe 传递页引用,更适合一般 fd 之间的转发,但通常要两次系统调用。 + +如果面试官把话题拉到 Kafka、RocketMQ,答案也不要混。Kafka 消费端把日志段文件原样发给消费者,适合走 `FileChannel.transferTo` 这类 sendfile 路线;RocketMQ 的 CommitLog 需要更灵活地读写映射内存,所以更常和 mmap 绑定。再补一句边界:TLS、压缩、格式转换、内容过滤这些场景需要应用真正处理 payload,零拷贝路径就会退化。 From a3443118bd931c9e73b474573451e7c28289e927 Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 21:43:06 +0800 Subject: [PATCH 002/116] docs: group operating system sidebar --- docs/.vuepress/sidebar/cs-basics.ts | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index 3c3a3decf0d..d85903d4e02 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -108,15 +108,24 @@ export const csBasics = [ prefix: "operating-system/", icon: ICONS.OS, children: [ - "operating-system-basic-questions-01", - "operating-system-basic-questions-02", - { text: "虚拟内存", link: "virtual-memory" }, - { text: "I/O 多路复用", link: "io-multiplexing" }, - { text: "零拷贝", link: "zero-copy" }, { - text: "Linux", - icon: ICONS.LINUX, - children: ["linux-intro", "shell-intro"], + text: "面试题", + icon: ICONS.INTERVIEW, + children: [ + "operating-system-basic-questions-01", + "operating-system-basic-questions-02", + ], + }, + { + text: "面试必考", + icon: ICONS.STAR, + children: [ + { text: "虚拟内存", link: "virtual-memory" }, + { text: "I/O 多路复用", link: "io-multiplexing" }, + { text: "零拷贝", link: "zero-copy" }, + { text: "Linux", link: "linux-intro" }, + { text: "Shell", link: "shell-intro" }, + ], }, ], }, From df53b0db7c0c8a771e37c6a9031bab0f55c5510d Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 21:45:31 +0800 Subject: [PATCH 003/116] docs: refine operating system sidebar --- docs/.vuepress/sidebar/cs-basics.ts | 26 +++++++++++++++++++------- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index d85903d4e02..a680714d8c3 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -112,19 +112,31 @@ export const csBasics = [ text: "面试题", icon: ICONS.INTERVIEW, children: [ - "operating-system-basic-questions-01", - "operating-system-basic-questions-02", + { + text: "⭐️操作系统常见面试题总结(上)", + link: "operating-system-basic-questions-01", + }, + { + text: "⭐️操作系统常见面试题总结(下)", + link: "operating-system-basic-questions-02", + }, ], }, { text: "面试必考", icon: ICONS.STAR, children: [ - { text: "虚拟内存", link: "virtual-memory" }, - { text: "I/O 多路复用", link: "io-multiplexing" }, - { text: "零拷贝", link: "zero-copy" }, - { text: "Linux", link: "linux-intro" }, - { text: "Shell", link: "shell-intro" }, + { text: "虚拟内存详解", link: "virtual-memory" }, + { text: "I/O 多路复用详解", link: "io-multiplexing" }, + { text: "零拷贝详解", link: "zero-copy" }, + ], + }, + { + text: "Linux", + icon: ICONS.LINUX, + children: [ + { text: "Linux 基础知识总结", link: "linux-intro" }, + { text: "Shell 编程基础知识总结", link: "shell-intro" }, ], }, ], From d11a9b6bf1a45f056fff1818d3f26f37c255c8d9 Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 21:52:09 +0800 Subject: [PATCH 004/116] docs: highlight operating system must-read articles --- docs/.vuepress/sidebar/cs-basics.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index a680714d8c3..35081e5ceae 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -126,9 +126,9 @@ export const csBasics = [ text: "面试必考", icon: ICONS.STAR, children: [ - { text: "虚拟内存详解", link: "virtual-memory" }, - { text: "I/O 多路复用详解", link: "io-multiplexing" }, - { text: "零拷贝详解", link: "zero-copy" }, + { text: "⭐️虚拟内存详解", link: "virtual-memory" }, + { text: "⭐️I/O 多路复用详解", link: "io-multiplexing" }, + { text: "⭐️零拷贝详解", link: "zero-copy" }, ], }, { From 62044a35e7183fc7ff37e868cdcf6f3306d117b1 Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 21:56:28 +0800 Subject: [PATCH 005/116] docs: add os io interview questions --- .../operating-system-basic-questions-02.md | 84 ++++++++++++++++++- 1 file changed, 82 insertions(+), 2 deletions(-) diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md index 2b1a849913b..ae492b568ef 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md @@ -1,13 +1,13 @@ --- title: 操作系统常见面试题总结(下) -description: 最新操作系统高频面试题总结(下):虚拟内存映射、内存碎片/伙伴系统、TLB+页缺失处理、分页分段对比、页面置换算法详解、文件系统&磁盘调度,附图表+⭐️重点标注,一文掌握OS内存/文件考点,快速通关后端面试! +description: 最新操作系统高频面试题总结(下):虚拟内存映射、内存碎片/伙伴系统、TLB+页缺失处理、分页分段对比、页面置换算法、零拷贝、I/O 多路复用、文件系统&磁盘调度,附图表+⭐️重点标注,一文掌握 OS 内存/I/O/文件考点,快速通关后端面试! category: 计算机基础 tag: - 操作系统 head: - - meta - name: keywords - content: 操作系统面试题,虚拟内存详解,分页 vs 分段,页面置换算法,内存碎片,伙伴系统,TLB快表,页缺失,文件系统基础,磁盘调度算法,硬链接 vs 软链接 + content: 操作系统面试题,虚拟内存详解,分页 vs 分段,页面置换算法,内存碎片,伙伴系统,TLB快表,页缺失,零拷贝,mmap,sendfile,splice,I/O多路复用,select,poll,epoll,文件系统基础,磁盘调度算法,硬链接 vs 软链接 --- @@ -341,6 +341,86 @@ LRU 算法是实际使用中应用的比较多,也被认为是最接近 OPT 总之,局部性原理是计算机体系结构设计的重要原则之一,也是许多优化算法的基础。在分页机制中,利用时间局部性和空间局部性,采用缓存和预取技术,可以提高页面的命中率,从而提高内存访问效率。 +### 面试中如何回答虚拟内存? + +面试里问虚拟内存,不要只背“隔离进程”。可以按这条线回答:**虚拟内存把进程看到的地址和真实物理地址隔开,再由 MMU、页表和 TLB 完成地址翻译**。 + +进程访问的是虚拟地址(VA),真正落到内存条上的是物理地址(PA)。每个进程都有自己的虚拟地址空间和页表,所以不同进程即使使用相同的虚拟地址,也可以映射到不同的物理页,从而实现进程隔离。 + +![虚拟地址到物理地址的映射过程:不同进程的相同虚拟地址通过 MMU 和页表映射到不同物理页](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-virtual-physical-mapping.png) + +分页机制把虚拟地址空间和物理内存都切成固定大小的页,通过页表记录“虚拟页号 -> 物理页帧”的映射。这样基本消除了分段容易产生的外部碎片,也让物理内存可以离散分配;代价是页表本身会占空间,所以现代系统会用多级页表按需创建下级页表。 + +TLB 可以理解为页表项缓存。CPU 先查 TLB,命中就直接拿到物理页号;未命中才去查多级页表,并把结果回填到 TLB。如果页表项显示页面不在内存,就会触发缺页中断,内核再判断访问是否合法,合法则分配页帧、必要时换出旧页、从文件或 Swap 调入页面,最后更新页表并重新执行那条指令。 + +![TLB 缓存地址转换结果的流程:CPU 先查 TLB,命中直接访问内存,未命中再查多级页表并更新 TLB](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-tlb-cache.png) + +页面置换算法可以抓住一句话:**换出去的页,最好是后面最晚再用到的页**。OPT 是理论最优但无法实现,LRU 接近 OPT 但实现成本高,CLOCK 用访问位近似 LRU,FIFO 简单但可能出现 Belady 异常。 + +详细介绍:[虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md) + +## I/O + +### 什么是 I/O 多路复用? + +I/O 多路复用解决的不是“单次读写更快”,而是**一个线程如何同时等待多个文件描述符(fd)的就绪事件**。 + +一次网络读取通常分成两个阶段:先等数据从网卡到达并进入内核缓冲区,再把数据从内核缓冲区拷贝到用户缓冲区。阻塞 I/O 的问题在第一阶段:一个线程调用 `recv` 后,如果这个连接没数据,线程就只能卡在那里等。 + +![网络读取中的两个阶段:先等待网卡数据进入内核缓冲区,再通过 copy_to_user 拷贝到用户缓冲区](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-io-two-phases.png) + +I/O 多路复用把一批 fd 交给内核,让线程阻塞在 `select`、`poll` 或 `epoll` 这类系统调用上。只要其中任意 fd 就绪,调用就返回,应用再去处理对应的连接。这样一个线程就能管理成千上万个连接,特别适合大量连接空闲、少量连接活跃的场景,比如 Redis、Nginx、Netty 这类高性能网络程序。 + +需要注意:I/O 多路复用仍然属于**同步 I/O**。内核只是通知“可以读/可以写了”,真正的 `read`/`recv` 还得应用自己调用,数据从内核缓冲区拷到用户缓冲区这一步并没有被省掉。 + +详细介绍:[I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md) + +### select、poll 和 epoll 有什么区别? + +结论:`select` 和 `poll` 每次等待都要把完整监听集合交给内核,并在返回后线性扫描;`epoll` 把监听集合长期维护在内核里,`epoll_wait` 主要返回已经就绪的事件,更适合“连接很多但活跃连接较少”的场景。 + +`select` 使用固定大小的 `fd_set` 位图,Linux glibc 下通常受 `FD_SETSIZE` 限制,只能安全处理编号 0~1023 的 fd。每次调用前都要重新设置监听集合,返回后还要遍历位图找出哪些 fd 就绪。 + +`poll` 把位图换成了 `pollfd` 数组,绕开了 `FD_SETSIZE` 的限制,但本质上还是每次把完整数组传入内核,返回后遍历整个数组检查 `revents`。所以连接数量很大、活跃比例很低时,扫描成本仍然明显。 + +`epoll` 通过 `epoll_ctl` 维护监听集合,通过 `epoll_wait` 获取就绪事件。内核会维护 interest list 和 ready list,fd 就绪后进入 ready list,应用等待时只取这批就绪事件。它还支持 LT(水平触发)和 ET(边缘触发):LT 只要缓冲区还有数据就会反复通知;ET 只在状态变化时通知一次,必须配合非阻塞 fd,并循环读到 `EAGAIN`。 + +![select、poll 和 epoll 对比:数据结构、fd 限制、每次等待传参、查找就绪 fd 的开销和触发模式](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/io-multiplexing-select-poll-epoll.png) + +不过,epoll 不是所有场景都更快。如果连接数量很少,或者所有连接都很活跃,`epoll_ctl`、回调、就绪链表等维护成本也要算进去。它的主场是海量长连接、大部分时间空闲的服务端程序。 + +详细介绍:[I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md) + +### 什么是零拷贝? + +零拷贝不是完全没有拷贝,而是**尽量避免 CPU 在内核缓冲区和用户缓冲区之间搬运数据**,从而减少 CPU 拷贝和用户态/内核态切换。 + +以传统 `read + write` 文件发送为例,数据通常要经历 4 次拷贝:磁盘到内核缓冲区是 DMA 拷贝,内核缓冲区到用户缓冲区是 CPU 拷贝,用户缓冲区到 Socket 缓冲区还是 CPU 拷贝,Socket 缓冲区到网卡是 DMA 拷贝。这里最浪费的是中间两次 CPU 拷贝,因为应用并没有修改数据,只是让数据到用户空间绕了一圈。 + +![传统 read/write 的数据拷贝路径:磁盘到内核缓冲区、内核到用户缓冲区、用户到 Socket 缓冲区、Socket 到网卡](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-traditional-read-write.png) + +零拷贝的思路就是让数据尽量留在内核路径里转发。比如 `sendfile` 可以把文件数据从 Page Cache 直接送到 Socket;如果网卡支持 SG-DMA,Socket 缓冲区里甚至可以只放描述信息,payload 由 DMA 从内核缓冲区直接送到网卡。 + +零拷贝很适合文件原样转发、大文件传输、消息队列日志发送这类场景。Kafka 消费端把日志段文件发送给消费者时,就很适合走 `FileChannel.transferTo` 这类 sendfile 路线。 + +详细介绍:[零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md) + +### mmap、sendfile 和 splice 有什么区别? + +结论:**要改数据,用 mmap;只是文件到 Socket 原样转发,用 sendfile;更一般的 fd 之间转发,再考虑 splice**。 + +`mmap + write` 利用虚拟内存映射,把文件映射到进程地址空间。应用访问这段内存时,实际访问的是 Page Cache 对应的物理页,省掉了传统 `read` 中“内核缓冲区 -> 用户缓冲区”的那次 CPU 拷贝。不过后续 `write` 到 Socket 缓冲区通常还会有一次 CPU 拷贝。它适合需要在发送前读取、修改、解析数据的场景。 + +`sendfile` 更适合“文件 -> Socket”的原样发送。数据不进入用户态,系统调用次数也更少;在支持 SG-DMA 的网卡上,还能把 CPU payload 拷贝降到 0。静态文件服务器、Kafka 日志段发送这类场景很典型。 + +`splice` 借助 pipe 在内核中移动页引用,适合更一般的描述符之间转发,比如 socket 到 socket、文件到管道再到 socket。它的限制是路径里通常要有 pipe,而且文件到 socket 往往需要两次 `splice` 调用,代码复杂度和系统调用次数都要考虑。 + +![传统 read/write、mmap + write、sendfile + SG-DMA 和 splice 的拷贝次数与模式切换对比](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/zero-copy-four-ways-comparison.png) + +零拷贝也有失效场景:TLS 加密、压缩、格式转换、内容过滤、水印处理等都需要应用真正处理 payload,数据就很难一直停留在内核路径里。小文件或随机访问下,映射、缺页、管道的固定成本也可能盖过收益。 + +详细介绍:[零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md) + ## 文件系统 ### 文件系统主要做了什么? From a005d808ccb03b1e4deaee44cb982a9a87b003ee Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 21:58:57 +0800 Subject: [PATCH 006/116] docs: refine virtual memory interview question title --- .../operating-system/operating-system-basic-questions-02.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md index ae492b568ef..01c1b26f9c4 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md @@ -341,7 +341,7 @@ LRU 算法是实际使用中应用的比较多,也被认为是最接近 OPT 总之,局部性原理是计算机体系结构设计的重要原则之一,也是许多优化算法的基础。在分页机制中,利用时间局部性和空间局部性,采用缓存和预取技术,可以提高页面的命中率,从而提高内存访问效率。 -### 面试中如何回答虚拟内存? +### 虚拟内存是如何实现地址转换和进程隔离的? 面试里问虚拟内存,不要只背“隔离进程”。可以按这条线回答:**虚拟内存把进程看到的地址和真实物理地址隔开,再由 MMU、页表和 TLB 完成地址翻译**。 From 0d6d4e0bcc92911550e1e821b9e05f95b31072c2 Mon Sep 17 00:00:00 2001 From: Guide Date: Wed, 10 Jun 2026 22:22:44 +0800 Subject: [PATCH 007/116] docs: improve os memory interview answers --- .../operating-system-basic-questions-02.md | 131 +++++++++--------- 1 file changed, 69 insertions(+), 62 deletions(-) diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md index 01c1b26f9c4..400945b33fd 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md @@ -76,18 +76,20 @@ head: #### 什么是虚拟内存?有什么用? -**虚拟内存(Virtual Memory)** 是计算机系统内存管理非常重要的一个技术,本质上来说它只是逻辑存在的,是一个假想出来的内存空间,主要作用是作为进程访问主存(物理内存)的桥梁并简化内存管理。 +**虚拟内存(Virtual Memory)** 是操作系统提供的一层内存抽象。程序看到的是连续、私有的虚拟地址空间,真正的数据放在物理内存的哪些位置,由操作系统和硬件共同决定。 + +简单来说,虚拟内存把“程序使用的地址”和“内存条上的真实地址”隔开了。进程访问虚拟地址时,CPU 中的 MMU 会根据页表等映射关系,把虚拟地址转换成物理地址,再去访问真正的内存。 ![虚拟内存作为进程访问主存的桥梁](https://oss.javaguide.cn/xingqiu/virtual-memory.png) 总结来说,虚拟内存主要提供了下面这些能力: -- **隔离进程**:物理内存通过虚拟地址空间访问,虚拟地址空间与进程一一对应。每个进程都认为自己拥有了整个物理内存,进程之间彼此隔离,一个进程中的代码无法更改正在由另一进程或操作系统使用的物理内存。 -- **提升物理内存利用率**:有了虚拟地址空间后,操作系统只需要将进程当前正在使用的部分数据或指令加载入物理内存。 -- **简化内存管理**:进程都有一个一致且私有的虚拟地址空间,程序员不用和真正的物理内存打交道,而是借助虚拟地址空间访问物理内存,从而简化了内存管理。 +- **隔离进程**:每个进程都有自己的虚拟地址空间和页表。不同进程即使使用相同的虚拟地址,也可以映射到不同的物理页,彼此不会直接踩内存。 +- **提升物理内存利用率**:操作系统不需要把进程的全部代码和数据一次性装进物理内存,只把当前真正会用到的页加载进来。 +- **简化内存管理**:进程看到的是一片连续的虚拟地址空间,物理内存可以是离散的页帧,复杂的拼接工作交给页表和 MMU。 - **多个进程共享物理内存**:进程在运行过程中,会加载许多操作系统的动态库。这些库对于每个进程而言都是公用的,它们在内存中实际只会加载一份,这部分称为共享内存。 - **提高内存使用安全性**:控制进程对物理内存的访问,隔离不同进程的访问权限,提高系统的安全性。 -- **提供更大的可使用内存空间**:可以让程序拥有超过系统物理内存大小的可用内存空间。这是因为当物理内存不够用时,可以利用磁盘充当,将物理内存页(通常大小为 4 KB)保存到磁盘文件(会影响读写速度),数据或代码页会根据需要在物理内存与磁盘之间移动。 +- **提供更大的可使用内存空间**:当物理内存不够用时,可以把暂时不用的页换出到磁盘,需要时再换回来。这样程序感知到的可用内存空间可以超过实际物理内存,不过频繁换页会明显拖慢系统。 #### 没有虚拟内存有什么问题? @@ -106,11 +108,11 @@ head: 也就是说,我们编程开发的时候实际就是在和虚拟地址打交道。比如在 C 语言中,指针里面存储的数值就可以理解成为内存里的一个地址,这个地址也就是我们说的虚拟地址。 -操作系统一般通过 CPU 芯片中的一个重要组件 **MMU(Memory Management Unit,内存管理单元)** 将虚拟地址转换为物理地址,这个过程被称为 **地址翻译/地址转换(Address Translation)**。 +操作系统一般通过 CPU 芯片中的一个重要组件 **MMU(Memory Management Unit,内存管理单元)** 将虚拟地址转换为物理地址,这个过程被称为 **地址翻译/地址转换(Address Translation)**。在现代系统里,这个转换通常依赖页表完成,TLB 会缓存最近使用过的地址转换结果,减少查页表的开销。 ![地址翻译过程](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/physical-virtual-address-translation.png) -通过 MMU 将虚拟地址转换为物理地址后,再通过总线传到物理内存设备,进而完成相应的物理内存读写请求。 +通过 MMU 将虚拟地址转换为物理地址后,CPU 再访问对应的物理内存位置,完成读写请求。也正是因为有这层转换,不同进程里数值相同的虚拟地址,最终可以落到完全不同的物理页上。 MMU 将虚拟地址翻译为物理地址的主要机制有两种:**分段机制** 和 **分页机制**。 @@ -131,11 +133,11 @@ MMU 将虚拟地址翻译为物理地址的主要机制有 3 种: ### 分段机制 -**分段机制(Segmentation)** 以段(一段 **连续** 的物理内存)的形式管理/分配物理内存。应用程序的虚拟地址空间被分为大小不等的段,段是有实际意义的,每个段定义了一组逻辑信息,例如有主程序段 MAIN、子程序段 X、数据段 D 及栈段 S 等。 +**分段机制(Segmentation)** 按程序的逻辑结构来划分地址空间,比如代码段、数据段、堆、栈等。每个段的长度可以不同,段本身有明确的语义,也可以配合权限控制。 #### 段表有什么用?地址翻译过程是怎样的? -分段管理通过 **段表(Segment Table)** 映射虚拟地址和物理地址。 +分段管理通过 **段表(Segment Table)** 映射虚拟地址和物理地址。段表项通常会记录段基址、段界限(段的长度)、访问权限等信息。 分段机制下的虚拟地址由两部分组成: @@ -146,11 +148,12 @@ MMU 将虚拟地址翻译为物理地址的主要机制有 3 种: 1. MMU 首先解析得到虚拟地址中的段号; 2. 通过段号去该应用程序的段表中取出对应的段信息(找到对应的段表项); -3. 从段信息中取出该段的起始地址(物理地址)加上虚拟地址中的段内偏移量得到最终的物理地址。 +3. 检查段内偏移量是否超过段界限,检查访问权限是否合法; +4. 合法的话,用段基址加上段内偏移量得到最终的物理地址。 -![分段机制下的地址翻译过程](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/segment-virtual-address-composition.png) +![分段地址转换示意图:虚拟地址由段号和段内偏移组成,通过段表查到基地址后计算物理地址](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-segmentation.png) -段表中还存有诸如段长(可用于检查虚拟地址是否超出合法范围)、段类型(该段的类型,例如代码段、数据段等)等信息。 +举个例子,要访问段 3、偏移量 500 的地址,如果段 3 的基地址是 7000,且偏移量没有越界,那么最终物理地址就是 7000 + 500 = 7500。 **通过段号一定要找到对应的段表项吗?得到最终的物理地址后对应的物理内存一定存在吗?** @@ -161,7 +164,7 @@ MMU 将虚拟地址翻译为物理地址的主要机制有 3 种: #### 分段机制为什么会导致内存外部碎片? -分段机制容易出现外部内存碎片,即在段与段之间留下碎片空间(不足以映射给虚拟地址空间中的段)。从而造成物理内存资源利用率的降低。 +分段机制容易出现外部内存碎片,根本原因是**段的长度不固定,并且每个段通常需要一块连续的物理内存**。进程不断创建和释放段后,物理内存里会留下很多零散空洞;这些空洞总量可能够用,但单个空洞不够大,仍然无法分配给新的大段。 举个例子:假设可用物理内存为 5G 的系统使用分段机制分配内存。现在有 4 个进程,每个进程的内存占用情况如下: @@ -170,60 +173,64 @@ MMU 将虚拟地址翻译为物理地址的主要机制有 3 种: - 进程 3:3~4.5G(第 3 段) - 进程 4:4.5~5G(第 4 段) -此时,我们关闭了进程 1 和进程 4,则第 1 段和第 4 段的内存会被释放,空闲物理内存还有 1.5G。由于这 1.5G 物理内存并不是连续的,导致没办法将空闲的物理内存分配给一个需要 1.5G 物理内存的进程。 +此时,我们关闭了进程 1 和进程 4,则第 1 段和第 4 段的内存会被释放,空闲物理内存还有 1.5 GB。由于这 1.5 GB 物理内存并不是连续的,导致没办法将空闲的物理内存分配给一个需要 1.5 GB 连续物理内存的进程。 ![分段机制导致外部内存碎片](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/segment-external-memory-fragmentation.png) +外部碎片可以通过内存紧凑来缓解,也就是把还在使用的段搬到一起,腾出连续空间。但搬移大段的代价很高,如果还伴随换出、换入磁盘,系统会明显变慢。 + ### 分页机制 -**分页机制(Paging)** 把主存(物理内存)分为连续等长的物理页,应用程序的虚拟地址空间也被划分为连续等长的虚拟页。现代操作系统广泛采用分页机制。 +**分页机制(Paging)** 把虚拟地址空间和物理内存都切成固定大小的块。虚拟地址空间里的块叫虚拟页,物理内存里的块叫物理页或者页帧。Linux 下,一页通常是 4 KB。 **注意:这里的页是连续等长的,不同于分段机制下不同长度的段。** -在分页机制下,应用程序虚拟地址空间中的任意虚拟页可以被映射到物理内存中的任意物理页上,因此可以实现物理内存资源的离散分配。分页机制按照固定页大小分配物理内存,使得物理内存资源易于管理,可有效避免分段机制中外部内存碎片的问题。 +在分页机制下,应用程序虚拟地址空间中的任意虚拟页可以映射到物理内存中的任意物理页帧上,因此物理内存可以离散分配。分页按照固定页大小管理内存,基本消除了分段机制中的外部内存碎片;代价是最后一页可能装不满,产生少量内部碎片。 + +分页还有一个很重要的能力:支持按需调页。程序并不需要一启动就把所有页装进物理内存,只有真正访问到某个虚拟页时,操作系统才把对应数据加载进来。 #### 页表有什么用?地址翻译过程是怎样的? -分页管理通过 **页表(Page Table)** 映射虚拟地址和物理地址。我这里画了一张基于单级页表进行地址翻译的示意图。 +分页管理通过 **页表(Page Table)** 映射虚拟地址和物理地址。页表项记录虚拟页号和物理页帧号的对应关系,还会记录访问位、脏位、权限位、存在位等状态信息。我这里画了一张基于单级页表进行地址翻译的示意图。 ![单级页表](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/page-table.png) -在分页机制下,每个进程都会有一个对应的页表。 +在分页机制下,每个进程都会有自己的页表。正因为页表是进程私有的,不同进程相同的虚拟页号可以映射到不同的物理页帧,从而实现地址空间隔离。 分页机制下的虚拟地址由两部分组成: -- **页号**:通过虚拟页号可以从页表中取出对应的物理页号; -- **页内偏移量**:物理页起始地址+页内偏移量=物理内存地址。 +- **页号**:通过虚拟页号可以从页表中取出对应的物理页帧号; +- **页内偏移量**:物理页帧起始地址 + 页内偏移量 = 物理内存地址。 具体的地址翻译过程如下: 1. MMU 首先解析得到虚拟地址中的虚拟页号; -2. 通过虚拟页号去该应用程序的页表中取出对应的物理页号(找到对应的页表项); -3. 用该物理页号对应的物理页起始地址(物理地址)加上虚拟地址中的页内偏移量得到最终的物理地址。 +2. 通过虚拟页号去该进程的页表中取出对应的物理页帧号(找到对应的页表项); +3. 用物理页帧号对应的起始地址加上虚拟地址中的页内偏移量,得到最终的物理地址。 -![分页机制下的地址翻译过程](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/paging-virtual-address-composition.png) +![分页地址转换示意图:虚拟地址拆成页号和页内偏移,页表把虚拟页映射到物理页帧](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-paging.png) -页表中还存有诸如访问标志(标识该页面有没有被访问过)、脏数据标识位等信息。 +如果页表项不存在,或者存在位表示该页还不在物理内存中,就会触发缺页异常,由内核决定是加载页面、建立映射,还是判定为非法访问。 -**通过虚拟页号一定要找到对应的物理页号吗?找到了物理页号得到最终的物理地址后对应的物理页一定存在吗?** +**通过虚拟页号一定能找到对应的物理页帧号吗?找到了物理页帧号得到最终的物理地址后,对应的物理页一定存在吗?** 不一定!可能会存在 **页缺失**。也就是说,物理内存中没有对应的物理页或者物理内存中有对应的物理页但虚拟页还未和物理页建立映射(对应的页表项不存在)。关于页缺失的内容,后面会详细介绍到。 #### 单级页表有什么问题?为什么需要多级页表? -以 32 位的环境为例,虚拟地址空间范围共有 2^32(4G)。假设一个页的大小是 2^12(4KB),那页表项共有 4G / 4K = 2^20 个。每个页表项为一个地址,占用 4 字节,`(2^20 * 2^2) / (1024 * 1024) = 4MB`。也就是说一个程序啥都不干,页表大小就得占用 4M。 +以 32 位环境为例,虚拟地址空间范围共有 2^32(4 GB)。假设一页大小是 2^12(4 KB),那就需要 4 GB / 4 KB = 2^20 个页表项。每个页表项占用 4 字节,整张单级页表大约就是 4 MB。也就是说,一个进程即使只用了一小段虚拟地址空间,单级页表也要为整个 4 GB 地址空间预留页表项。 -系统运行的应用程序多起来的话,页表的开销还是非常大的。而且,绝大部分应用程序可能只能用到页表中的几项,其他的白白浪费了。 +系统运行的进程多起来后,这部分开销就很明显。更要命的是,绝大多数进程只会使用虚拟地址空间中的一小部分,单级页表里的大量页表项其实都是空的。 -为了解决这个问题,操作系统引入了 **多级页表**,多级页表对应多个页表,每个页表与前一个页表相关联。32 位系统一般为二级页表,64 位系统一般为四级页表。 +为了解决这个问题,操作系统引入了 **多级页表**。多级页表的核心思路是:顶层页表覆盖整个虚拟地址空间,下级页表按需创建;某段虚拟地址完全没用到,就不需要为它创建下级页表。 -这里以二级页表为例进行介绍:二级列表分为一级页表和二级页表。一级页表共有 1024 个页表项,一级页表又关联二级页表,二级页表同样共有 1024 个页表项。二级页表中的一级页表项是一对多的关系,二级页表按需加载(只会用到很少一部分二级页表),进而节省空间占用。 +这里以二级页表为例进行介绍:一级页表共有 1024 个页表项,每个一级页表项可以指向一张二级页表;每张二级页表同样有 1024 个页表项。只有某个一级页表项覆盖的地址范围真的被使用时,才需要创建对应的二级页表。 -假设只需要 2 个二级页表,那两级页表的内存占用情况为:4KB(一级页表占用) + 4KB \* 2(二级页表占用) = 12KB。 +假设只需要 2 个二级页表,那两级页表的内存占用情况为:4 KB(一级页表占用) + 4 KB \* 2(二级页表占用) = 12 KB。 -![多级页表](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/multilevel-page-table.png) +![多级页表示意图:PGD、PUD、PMD、PTE 分层索引,只为实际使用的地址范围创建下级页表](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-multi-level-page-table.png) -多级页表属于时间换空间的典型场景,利用增加页表查询的次数减少页表占用的空间。 +多级页表属于典型的空间优化:用更多层级和更多次查表,换取更小的页表内存占用。实际系统会配合 TLB 缓存常用页表项,所以多级页表的额外查表开销不会每次都完整发生。 #### TLB 有什么用?使用 TLB 之后的地址翻译流程是怎样的? @@ -231,7 +238,7 @@ MMU 将虚拟地址翻译为物理地址的主要机制有 3 种: ![加入 TLB 之后的地址翻译](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/physical-virtual-address-translation-mmu.png) -在主流的 AArch64 和 x86-64 体系结构下,TLB 属于 MMU(Memory Management Unit,内存管理单元)内部的单元,本质上就是一块高速缓存(Cache),缓存了虚拟页号到物理页号的映射关系,你可以将其简单看作是存储着键(虚拟页号)值(物理页号)对的哈希表。 +在主流的 AArch64 和 x86-64 体系结构下,TLB 属于 MMU(Memory Management Unit,内存管理单元)内部的单元,本质上就是一块高速缓存(Cache),缓存了虚拟页号到物理页帧号的映射关系,你可以将其简单看作是存储着键(虚拟页号)值(物理页帧号)对的哈希表。 使用 TLB 之后的地址翻译流程是这样的: @@ -240,21 +247,21 @@ MMU 将虚拟地址翻译为物理地址的主要机制有 3 种: 3. 如果不能查到对应的物理页的话,还是需要去查询主存中的页表,同时将页表中的该映射表项添加到 TLB 中,这种情况称为 TLB 未命中(TLB miss)。 4. 当 TLB 填满后,又要登记新页时,就按照一定的淘汰策略淘汰掉快表中的一个页。 -![使用 TLB 之后的地址翻译流程](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/page-table-tlb.png) +![TLB 缓存地址转换结果的流程:CPU 先查 TLB,命中直接访问内存,未命中再查多级页表并更新 TLB](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-tlb-cache.png) -由于页表也在主存中,因此在没有 TLB 之前,每次读写内存数据时 CPU 要访问两次主存。有了 TLB 之后,对于存在于 TLB 中的页表数据只需要访问一次主存即可。 +由于页表也在主存中,因此在没有 TLB 之前,CPU 访问一个虚拟地址,往往要先访问内存查页表,再访问真正的数据;多级页表下查表次数还会更多。有了 TLB 之后,命中时可以跳过页表查询,直接拿到物理页帧号,地址转换会快很多。 -TLB 的设计思想非常简单,但命中率往往非常高,效果很好。这就是因为被频繁访问的页就是其中的很小一部分。 +TLB 的设计思想非常简单,但命中率往往很高,效果很好。这依赖的还是局部性原理:程序在一段时间内频繁访问的页通常只是少数几个。 看完了之后你会发现快表和我们平时经常在开发系统中使用的缓存(比如 Redis)很像,的确是这样的,操作系统中的很多思想、很多经典的算法,你都可以在我们日常开发使用的各种工具或者框架中找到它们的影子。 #### 换页机制有什么用? -换页机制的思想是当物理内存不够用的时候,操作系统选择将一些物理页的内容放到磁盘上去,等要用到的时候再将它们读取到物理内存中。也就是说,换页机制利用磁盘这种较低廉的存储设备扩展的物理内存。 +换页机制的思想是:当物理内存不够用时,操作系统选择一些暂时不常用的物理页,把它们换出到磁盘;等进程再次访问这些页时,再把它们换回物理内存。也就是说,换页机制利用磁盘这种更低成本的存储设备,从逻辑上扩展了可用内存。 这也就解释了一个日常使用电脑常见的问题:为什么操作系统中所有进程运行所需的物理内存即使比真实的物理内存要大一些,这些进程也是可以正常运行的,只是运行速度会变慢。 -这同样是一种时间换空间的策略,你用 CPU 的计算时间,页的调入调出花费的时间,换来了一个虚拟的更大的物理内存空间来支持程序的运行。 +这同样是一种时间换空间的策略,用页的调入调出时间,换来更大的可用内存空间。代价也很明确:一旦频繁发生主缺页和磁盘换页,系统会明显变慢,严重时会出现抖动(Thrashing),CPU 大部分时间都耗在换页上。 #### 什么是页缺失? @@ -262,16 +269,18 @@ TLB 的设计思想非常简单,但命中率往往非常高,效果很好。 > 页缺失(Page Fault,又名硬错误、硬中断、分页错误、寻页缺失、缺页中断、页故障等)指的是当软件试图访问已映射在虚拟地址空间中,但是目前并未被加载在物理内存中的一个分页时,由 MMU 所发出的中断。 -常见的页缺失有下面这两种: +常见的页缺失可以从性能统计角度分成下面两类: + +- **主缺页(Major Page Fault,也常被叫作硬缺页)**:目标页不在物理内存中,需要从磁盘文件或 Swap 读取页面,开销较大。 +- **次缺页(Minor Page Fault,也常被叫作软缺页)**:目标页其实已经在物理内存中,只是当前进程还没建立对应页表映射,比如共享库映射、写时复制(COW)触发的新映射等,通常不需要读盘。 -- **硬性页缺失(Hard Page Fault)**:物理内存中没有对应的物理页。于是,Page Fault Handler 会指示 CPU 从已经打开的磁盘文件中读取相应的内容到物理内存,而后交由 MMU 建立相应的虚拟页和物理页的映射关系。 -- **软性页缺失(Soft Page Fault)**:物理内存中有对应的物理页,但虚拟页还未和物理页建立映射。于是,Page Fault Handler 会指示 MMU 建立相应的虚拟页和物理页的映射关系。 +发生上面这两类缺页时,应用程序访问的虚拟地址通常是合法的,只是页面暂时不在内存,或者映射关系还没建立。如果访问的是非法地址,比如野指针或越权访问,硬件同样会触发 page fault 进入内核,但内核一般会向进程发送 `SIGSEGV`,这属于错误处理,不应和主缺页、次缺页混为一类。 -发生上面这两种缺页错误的时候,应用程序访问的是有效的物理内存,只是出现了物理页缺失或者虚拟页和物理页的映射关系未建立的问题。如果应用程序访问的是无效的物理内存的话,还会出现 **无效缺页错误(Invalid Page Fault)**。 +![缺页中断处理流程:MMU 发现页不在内存后进入内核,检查访问合法性、分配或置换页帧、更新页表并重试指令](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-page-fault.png) #### 常见的页面置换算法有哪些? -当发生硬性页缺失时,如果物理内存中没有空闲的物理页面可用的话。操作系统就必须将物理内存中的一个物理页淘汰出去,这样就可以腾出空间来加载新的页面了。 +当发生主缺页时,如果物理内存中没有空闲的物理页面可用,操作系统就必须将物理内存中的一个物理页淘汰出去,这样就可以腾出空间来加载新的页面。 用来选择淘汰哪一个物理页的规则叫做 **页面置换算法**,我们可以把页面置换算法看成是淘汰物理页的规则。 @@ -281,24 +290,24 @@ TLB 的设计思想非常简单,但命中率往往非常高,效果很好。 ![常见的页面置换算法](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/image-20230409113009139.png) -1. **最佳页面置换算法(OPT,Optimal)**:优先选择淘汰的页面是以后永不使用的,或者是在最长时间内不再被访问的页面,这样可以保证获得最低的缺页率。但由于人们目前无法预知进程在内存下的若干页面中哪个是未来最长时间内不再被访问的,因而该算法无法实现,只是理论最优的页面置换算法,可以作为衡量其他置换算法优劣的标准。 -2. **先进先出页面置换算法(FIFO,First In First Out)**:最简单的一种页面置换算法,总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面进行淘汰。该算法易于实现和理解,一般只需要通过一个 FIFO 队列即可满足需求。不过,它的性能并不是很好。 -3. **最近最久未使用页面置换算法(LRU,Least Recently Used)**:LRU 算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间 T,当须淘汰一个页面时,选择现有页面中其 T 值最大的,即最近最久未使用的页面予以淘汰。LRU 算法是根据各页之前的访问情况来实现,因此是易于实现的。OPT 算法是根据各页未来的访问情况来实现,因此是不可实现的。 -4. **最少使用页面置换算法(LFU,Least Frequently Used)**:和 LRU 算法比较像,不过该置换算法选择的是之前一段时间内使用最少的页面作为淘汰页。 -5. **时钟页面置换算法(Clock)**:可以认为是一种最近未使用算法,即逐出的页面都是最近没有使用的那个。 +1. **最佳页面置换算法(OPT,Optimal)**:优先淘汰未来最长时间不会再被访问的页面,理论上缺页率最低。但它需要预知未来,现实中无法实现,通常作为衡量其他算法的基准。 +2. **先进先出页面置换算法(FIFO,First In First Out)**:总是淘汰最早进入内存的页面,实现简单,但容易误伤热点页,并且可能出现 Belady 异常。 +3. **最近最久未使用页面置换算法(LRU,Least Recently Used)**:淘汰最久没有被访问的页面。它利用的是时间局部性,效果接近 OPT,但精确实现需要维护时间戳或链表,成本较高。 +4. **最少使用页面置换算法(LFU,Least Frequently Used)**:淘汰一段时间内访问次数最少的页面。它关注访问频率,但容易让早期频繁访问、后来不再使用的页面长期留在内存中,因此实际使用时常配合计数衰减。 +5. **时钟页面置换算法(Clock)**:也叫二次机会算法,是 LRU 的一种低成本近似实现。它给每个页面维护一个访问位,页面排成环形队列;访问位为 1 时先清零并跳过,访问位为 0 时才淘汰。 + +![CLOCK 页面置换算法示意图:页面按环形队列排列,指针根据访问位 R 判断给第二次机会还是淘汰页面](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-clock-algorithm.png) **FIFO 页面置换算法性能为何不好?** -主要原因主要有二: +主要原因有二: 1. **经常访问或者需要长期存在的页面会被频繁调入调出**:较早调入的页往往是经常被访问或者需要长期存在的页,这些页会被反复调入和调出。 2. **存在 Belady 现象**:被置换的页面并不是进程不会访问的,有时就会出现分配的页面数增多但缺页率反而提高的异常现象。出现该异常的原因是因为 FIFO 算法只考虑了页面进入内存的顺序,而没有考虑页面访问的频率和紧迫性。 **哪一种页面置换算法实际用的比较多?** -LRU 算法是实际使用中应用的比较多,也被认为是最接近 OPT 的页面置换算法。 - -不过,需要注意的是,实际应用中这些算法会被做一些改进,就比如 InnoDB Buffer Pool(InnoDB 缓冲池,MySQL 数据库中用于管理缓存页面的机制)就改进了传统的 LRU 算法,使用了一种称为 "Adaptive LRU" 的算法(同时结合了 LRU 和 LFU 算法的思想)。 +LRU 及其近似算法在实际系统中应用较多,因为它比较符合程序的局部性规律。不过,真实系统通常不会原样照搬教科书算法,而是做大量工程化改造。比如 Linux 内核不是简单地在 OPT/FIFO/LRU/CLOCK 里挑一个,而是使用活跃/非活跃 LRU、workingset、refault 检测等机制做近似回收;InnoDB Buffer Pool 也对传统 LRU 做了改进,避免预读和全表扫描把热点页挤出去。 ### 分页机制和分段机制有哪些共同点和区别? @@ -309,11 +318,11 @@ LRU 算法是实际使用中应用的比较多,也被认为是最接近 OPT **区别**: -- 分页机制以页面为单位进行内存管理,而分段机制以段为单位进行内存管理。页的大小是固定的,由操作系统决定,通常为 2 的幂次方。而段的大小不固定,取决于我们当前运行的程序。 -- 页是物理单位,即操作系统将物理内存划分成固定大小的页面,每个页面的大小通常是 2 的幂次方,例如 4KB、8KB 等等。而段则是逻辑单位,是为了满足程序对内存空间的逻辑需求而设计的,通常根据程序中数据和代码的逻辑结构来划分。 -- 分段机制容易出现外部内存碎片,即在段与段之间留下碎片空间(不足以映射给虚拟地址空间中的段)。分页机制解决了外部内存碎片的问题,但仍然可能会出现内部内存碎片。 -- 分页机制采用了页表来完成虚拟地址到物理地址的映射,页表通过一级页表和二级页表来实现多级映射;而分段机制则采用了段表来完成虚拟地址到物理地址的映射,每个段表项中记录了该段的起始地址和长度信息。 -- 分页机制对程序没有任何要求,程序只需要按照虚拟地址进行访问即可;而分段机制需要程序员将程序分为多个段,并且显式地使用段寄存器来访问不同的段。 +- **划分依据不同**:分页按固定大小切分地址空间和物理内存,页是内存管理的物理粒度;分段按程序的逻辑结构切分,比如代码段、数据段、堆、栈,段是更贴近程序语义的逻辑单位。 +- **大小是否固定不同**:页大小固定,常见为 4 KB;段大小不固定,取决于程序中对应逻辑区域的大小。 +- **碎片问题不同**:分段容易产生外部碎片,因为每个段需要连续空间;分页基本消除了外部碎片,但最后一页可能装不满,会产生少量内部碎片。 +- **地址结构不同**:分页地址通常由页号和页内偏移组成,通过页表完成映射;分段地址由段号和段内偏移组成,通过段表完成映射。 +- **工程使用不同**:现代通用操作系统主要依赖分页管理内存。以 x86 为例,硬件历史上支持分段和分页,但 Linux 基本把段基址设为 0,让分段“弱化”为权限和兼容机制,实际内存管理主要靠分页完成。 ### 段页机制 @@ -321,10 +330,10 @@ LRU 算法是实际使用中应用的比较多,也被认为是最接近 OPT 在段页式机制下,地址翻译的过程分为两个步骤: -1. **段式地址映射(虚拟地址 --> 线性地址)**: +1. **段式地址映射(虚拟地址 -> 线性地址)**: - 虚拟地址 = 段选择符(段号)+ 段内偏移。 - 根据段号查段表,找到段基址,加上段内偏移得到线性地址。 -2. **页式地址映射(线性地址 --> 物理地址)**: +2. **页式地址映射(线性地址 -> 物理地址)**: - 线性地址 = 页号 + 页内偏移。 - 根据页号查页表,找到物理页框号,加上页内偏移得到物理地址。 @@ -351,9 +360,7 @@ LRU 算法是实际使用中应用的比较多,也被认为是最接近 OPT 分页机制把虚拟地址空间和物理内存都切成固定大小的页,通过页表记录“虚拟页号 -> 物理页帧”的映射。这样基本消除了分段容易产生的外部碎片,也让物理内存可以离散分配;代价是页表本身会占空间,所以现代系统会用多级页表按需创建下级页表。 -TLB 可以理解为页表项缓存。CPU 先查 TLB,命中就直接拿到物理页号;未命中才去查多级页表,并把结果回填到 TLB。如果页表项显示页面不在内存,就会触发缺页中断,内核再判断访问是否合法,合法则分配页帧、必要时换出旧页、从文件或 Swap 调入页面,最后更新页表并重新执行那条指令。 - -![TLB 缓存地址转换结果的流程:CPU 先查 TLB,命中直接访问内存,未命中再查多级页表并更新 TLB](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-tlb-cache.png) +TLB 可以理解为页表项缓存。CPU 先查 TLB,命中就直接拿到物理页帧号;未命中才去查多级页表,并把结果回填到 TLB。如果页表项显示页面不在内存,就会触发缺页中断,内核再判断访问是否合法,合法则分配页帧、必要时换出旧页、从文件或 Swap 调入页面,最后更新页表并重新执行那条指令。 页面置换算法可以抓住一句话:**换出去的页,最好是后面最晚再用到的页**。OPT 是理论最优但无法实现,LRU 接近 OPT 但实现成本高,CLOCK 用访问位近似 LRU,FIFO 简单但可能出现 Belady 异常。 From 8b95e8bcfa95bed08752c919e96838ee6042bcd5 Mon Sep 17 00:00:00 2001 From: Guide Date: Thu, 11 Jun 2026 09:19:11 +0800 Subject: [PATCH 008/116] docs: optimize java and os articles --- README.md | 2 + README_EN.md | 91 ++-- README_JA.md | 24 +- .../cs-basics/operating-system/linux-intro.md | 39 +- .../operating-system-basic-questions-01.md | 10 +- .../operating-system-basic-questions-02.md | 4 +- .../cs-basics/operating-system/shell-intro.md | 48 +- .../operating-system/virtual-memory.md | 2 +- docs/cs-basics/operating-system/zero-copy.md | 2 +- docs/java/concurrent/virtual-thread.md | 514 +++++++++++++----- ...30\345\214\226\345\273\272\350\256\256.md" | 199 +++++++ 11 files changed, 669 insertions(+), 266 deletions(-) create mode 100644 "\346\223\215\344\275\234\347\263\273\347\273\237\344\270\223\351\242\230\344\274\230\345\214\226\345\273\272\350\256\256.md" diff --git a/README.md b/README.md index 0844aba7bc5..f3c74438816 100755 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +**[English](./README_EN.md)** | **[日本語](./README_JA.md)** | **简体中文** + - 推荐在线阅读(体验更好,速度更快):[javaguide.cn](https://javaguide.cn/) - 面试突击版本(只保留重点,附带精美 PDF 下载):[interview.javaguide.cn](https://interview.javaguide.cn/) diff --git a/README_EN.md b/README_EN.md index ec1366de844..d5aa5de2fa1 100644 --- a/README_EN.md +++ b/README_EN.md @@ -1,39 +1,30 @@ -Recommended to read through online reading platforms for better experience and faster speed! Link: [javaguide.cn](https://javaguide.cn/). +**English** | **[日本語](./README_JA.md)** | **[简体中文](./README.md)** -
+Recommended to read online for a better experience and faster speed: [javaguide.cn](https://javaguide.cn/) -[![logo](https://oss.javaguide.cn/github/javaguide/csdn/1c00413c65d1995993bf2b0daf7b4f03.png)](https://github.com/Snailclimb/JavaGuide) +## AI Application Development Interview Guide -[GitHub](https://github.com/Snailclimb/JavaGuide) | [Gitee](https://gitee.com/SnailClimb/JavaGuide) +An open-source guide for backend developers on AI application development, AI programming practices, and interviews, covering core technologies and engineering practices such as LLM, Agent, RAG, MCP, Claude Code, Codex, and more. Benchmarking JavaGuide! If it helps, welcome to Star! -Snailclimb%2FJavaGuide | Trendshift +- **Project URL**: [https://github.com/Snailclimb/AIGuide](https://github.com/Snailclimb/AIGuide) +- **Online Reading**: [https://javaguide.cn/ai/](https://javaguide.cn/ai/) -
+## Backend Interview Preparation -> - **Interview Edition**: Candidates preparing for Java interviews can consider the **[《Java Interview Guide》](./docs/zhuanlan/java-mian-shi-zhi-bei.md)** (high quality, specially designed for interviews, to be used with JavaGuide). -> - **Knowledge Planet**: Exclusive interview mini-books/one-on-one communication/resume modification/exclusive job-seeking guide, welcome to join **[JavaGuide Knowledge Planet](./docs/about-the-author/zhishixingqiu-two-years.md)** (click the link to view the detailed introduction of the planet, make sure you really need it before joining). -> - **Usage Suggestion**: Experienced interviewers always dig into technical issues along the project experience. Definitely do not memorize technical articles! For detailed learning suggestions, please refer to: [JavaGuide Usage Suggestion](./docs/javaguide/use-suggestion.md). -> - **Seek a Star**: If you find the content of JavaGuide helpful, please give a free Star, which is the greatest encouragement to me. Thank you all for walking together and striving together! Github link: [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide). -> - **Reprint Notice**: All the following articles are original creations of JavaGuide unless stated otherwise at the beginning. Please indicate the source when reprinting. If malicious plagiarism/copying is discovered, legal weapons will be used to safeguard our rights. Let's together maintain a good technical creation environment! - -
- -
- - - -## Project-related - -- [Project Introduction](https://javaguide.cn/javaguide/intro.html) -- [Usage Suggestion](https://javaguide.cn/javaguide/use-suggestion.html) -- [Contribution Guide](https://javaguide.cn/javaguide/contribution-guideline.html) -- [FAQ](https://javaguide.cn/javaguide/faq.html) +- [⭐Java Backend Interview Preparation Plan (Covering General Backend System)](./docs/interview-preparation/backend-interview-plan.md) (Must-see :+1:) +- [How to Efficiently Prepare for Java Interviews?](./docs/interview-preparation/teach-you-how-to-prepare-for-the-interview-hand-in-hand.md) +- [Key Summary of Java Backend Interviews](./docs/interview-preparation/key-points-of-interview.md) +- [Java Learning Roadmap (Latest, 4w+ Words)](./docs/interview-preparation/java-roadmap.md) +- [Programmer Resume Writing Guide](./docs/interview-preparation/resume-guide.md) +- [Project Experience Guide](./docs/interview-preparation/project-experience-guide.md) +- [How to Deal with Interview Nervousness?](./docs/interview-preparation/how-to-handle-interview-nerves.md) +- [What to Do Without Internship Experience in Campus Recruitment? How to Write About Internship Experience?](./docs/interview-preparation/internship-experience.md) ## Java ### Basics -**Knowledge Points/Interview Questions Summary** : (Must-see:+1:): +**Knowledge Points/Interview Questions Summary** (Must-see:+1:): - [Summary of Common Java Basics Knowledge Points & Interview Questions (Part 1)](./docs/java/basis/java-basic-questions-01.md) - [Summary of Common Java Basics Knowledge Points & Interview Questions (Part 2)](./docs/java/basis/java-basic-questions-02.md) @@ -64,11 +55,6 @@ Recommended to read through online reading platforms for better experience and f - [ArrayList Core Source Code + Expansion Mechanism Analysis](./docs/java/collection/arraylist-source-code.md) - [LinkedList Core Source Code Analysis](./docs/java/collection/linkedlist-source-code.md) - [HashMap Core Source Code + Underlying Data Structure Analysis](./docs/java/collection/hashmap-source-code.md) - -# Java Collection & Concurrency Series - -## Collection - - [ConcurrentHashMap Core Source Code + Underlying Data Structure Analysis](./docs/java/collection/concurrent-hash-map-source-code.md) - [LinkedHashMap Core Source Code Analysis](./docs/java/collection/linkedhashmap-source-code.md) - [CopyOnWriteArrayList Core Source Code Analysis](./docs/java/collection/copyonwritearraylist-source-code.md) @@ -85,7 +71,7 @@ Recommended to read through online reading platforms for better experience and f ### Concurrency -**Knowledge Points/Interview Questions Summary** : (Must-read :+1:) +**Knowledge Points/Interview Questions Summary** (Must-read :+1:) - [Common Java Concurrency Knowledge Points & Interview Questions Summary (Part 1)](./docs/java/concurrent/java-concurrent-questions-01.md) - [Common Java Concurrency Knowledge Points & Interview Questions Summary (Part 2)](./docs/java/concurrent/java-concurrent-questions-02.md) @@ -105,7 +91,7 @@ Recommended to read through online reading platforms for better experience and f ### JVM (Must-read :+1:) -The JVM part mainly refers to the [JVM Specification - Java 8](https://docs.oracle.com/javase/specs/jvms/se8/html/index.html) and Zhong Zhiming's book [《Deep Understanding of Java Virtual Machine (3rd Edition)》](https://book.douban.com/subject/34907497/) (strongly recommend to read it several times!). +The JVM part mainly refers to the [JVM Specification - Java 8](https://docs.oracle.com/javase/specs/jvms/se8/html/index.html) and Zhou Zhiming's book [《Deep Understanding of Java Virtual Machine (3rd Edition)》](https://book.douban.com/subject/34907497/) (strongly recommend to read it several times!). - **[Java Memory Area](./docs/java/jvm/memory-area.md)** - **[JVM Garbage Collection](./docs/java/jvm/jvm-garbage-collection.md)** @@ -129,8 +115,10 @@ The JVM part mainly refers to the [JVM Specification - Java 8](https://docs.orac - [Java 18 New Features Overview](./docs/java/new-features/java18.md) - [Java 19 New Features Overview](./docs/java/new-features/java19.md) - [Java 20 New Features Overview](./docs/java/new-features/java20.md) - -# Overview of Java 21, 22, 23, 24, and 25 New Features +- [Java 21 New Features Overview](./docs/java/new-features/java21.md) +- [Java 22 & 23 New Features Overview](./docs/java/new-features/java22-23.md) +- [Java 24 New Features Overview](./docs/java/new-features/java24.md) +- [Java 25 New Features Overview](./docs/java/new-features/java25.md) ## Computer Fundamentals @@ -150,7 +138,7 @@ The JVM part mainly refers to the [JVM Specification - Java 8](https://docs.orac - [Summary of Common Computer Network Knowledge Points & Interview Questions (Part 2)](./docs/cs-basics/network/other-network-questions2.md) - [Summary of Professor Xie Xiren's "Computer Network" Content (Supplementary)](./docs/cs-basics/network/computer-network-xiexiren-summary.md) -**Important Concept Explanations**: +**Important Knowledge Points Explanation**: - [Detailed Explanation of the OSI and TCP/IP Network Layer Models (Basics)](./docs/cs-basics/network/osi-and-tcp-ip-model.md) - [Summary of Common Application Layer Protocols (Application Layer)](./docs/cs-basics/network/application-layer-protocol.md) @@ -159,7 +147,11 @@ The JVM part mainly refers to the [JVM Specification - Java 8](https://docs.orac - [Common HTTP Status Codes (Application Layer)](./docs/cs-basics/network/http-status-codes.md) - [Detailed Explanation of the DNS Domain Name System (Application Layer)](./docs/cs-basics/network/dns.md) - [TCP Three-Way Handshake and Four-Way Termination (Transport Layer)](./docs/cs-basics/network/tcp-connection-and-disconnection.md) +- [What's the Difference Between TCP Keepalive and HTTP Keep-Alive? (Transport Layer)](./docs/cs-basics/network/tcp-keepalive-vs-http-keepalive.md) - [TCP Transmission Reliability Guarantee (Transport Layer)](./docs/cs-basics/network/tcp-reliability-guarantee.md) +- [If You Can Ping Through, Does TCP Definitely Connect? (Transport Layer)](./docs/cs-basics/network/can-ping-but-tcp-may-not-connect.md) +- [Can TCP and UDP Use the Same Port? (Transport Layer)](./docs/cs-basics/network/can-tcp-and-udp-use-the-same-port.md) +- [What's the Maximum Number of TCP Connections a Host Can Maintain? (Transport Layer)](./docs/cs-basics/network/maximum-number-of-tcp-connections-per-host.md) - [Detailed Explanation of the ARP Protocol (Network Layer)](./docs/cs-basics/network/arp.md) - [Detailed Explanation of the NAT Protocol (Network Layer)](./docs/cs-basics/network/nat.md) - [Summary of Common Network Attack Means (Security)](./docs/cs-basics/network/network-attack-means.md) @@ -208,14 +200,13 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo **Knowledge Points/Interview Questions Summary:** -# MySQL Common Knowledge Points & Interview Questions Summary (Must-Read :+1:) - -- [MySQL Common Knowledge Points & Interview Questions Summary](./docs/database/mysql/mysql-questions-01.md) +- **[MySQL Common Knowledge Points & Interview Questions Summary](./docs/database/mysql/mysql-questions-01.md)** (Must-read :+1:) - [MySQL High-Performance Optimization Specification Recommendations](./docs/database/mysql/mysql-high-performance-optimization-specification-recommendations.md) **Important Knowledge Points:** - [MySQL Index Details](./docs/database/mysql/mysql-index.md) +- [Summary of MySQL Index Invalidation Scenarios](./docs/database/mysql/mysql-index-invalidation.md) - [Detailed Explanation of MySQL Transaction Isolation Levels (with Pictures)](./docs/database/mysql/transaction-isolation-level.md) - [Detailed Explanation of MySQL's Three Logs (binlog, redo log, and undo log)](./docs/database/mysql/mysql-logs.md) - [InnoDB Storage Engine's Implementation of MVCC](./docs/database/mysql/innodb-implementation-of-mvcc.md) @@ -223,12 +214,12 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo - [Detailed Explanation of MySQL Query Cache](./docs/database/mysql/mysql-query-cache.md) - [MySQL Query Execution Plan Analysis](./docs/database/mysql/mysql-query-execution-plan.md) - [Are MySQL Auto-Increment Primary Keys Always Continuous?](./docs/database/mysql/mysql-auto-increment-primary-key-continuous.md) -- [Suggestions on Storing Time-Related Data in Databases](./docs/database/mysql/some-thoughts-on-database-storage-time.md) +- [Suggestions on Storing Time-Related Data in MySQL](./docs/database/mysql/some-thoughts-on-database-storage-time.md) - [Index Invalidation Caused by Implicit Conversion in MySQL](./docs/database/mysql/index-invalidation-caused-by-implicit-conversion.md) ### Redis -**Knowledge Points/Interview Questions Summary** (Must-Read :+1:): +**Knowledge Points/Interview Questions Summary** (Must-read:+1:): - [Redis Common Knowledge Points & Interview Questions Summary (Part 1)](./docs/database/redis/redis-questions-01.md) - [Redis Common Knowledge Points & Interview Questions Summary (Part 2)](./docs/database/redis/redis-questions-02.md) @@ -278,8 +269,8 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo ## System Design -- [Common System Design Interview Questions Summary](./docs/system-design/system-design-questions.md) -- [Common Design Pattern Interview Questions Summary](./docs/system-design/design-pattern.md) +- [⭐Common System Design Interview Questions Summary](./docs/system-design/system-design-questions.md) +- [⭐Common Design Pattern Interview Questions Summary](https://interview.javaguide.cn/system-design/design-pattern.html) ### Basics @@ -291,13 +282,13 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo ### Common Frameworks -#### Spring/SpringBoot (Must-Read :+1:) +#### Spring/SpringBoot (Must-read :+1:) -**Knowledge Points/Interview Questions Summary**: +**Knowledge Points/Interview Questions Summary** : - [Summary of Common Spring Knowledge Points and Interview Questions](./docs/system-design/framework/spring/spring-knowledge-and-questions-summary.md) - [Summary of Common SpringBoot Knowledge Points and Interview Questions](./docs/system-design/framework/spring/springboot-knowledge-and-questions-summary.md) -- [Summary of Common Spring/SpringBoot Annotations](./docs/system-design/framework/spring/spring-common-annotations.md) +- [Summary of Common Spring/Spring Boot Annotations](./docs/system-design/framework/spring/spring-common-annotations.md) - [SpringBoot Beginner's Guide](https://github.com/Snailclimb/springboot-guide) **Detailed Explanation of Important Knowledge Points**: @@ -327,6 +318,7 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo - [Summary of Sensitive Word Filtering Solutions](./docs/system-design/security/sentive-words-filter.md) - [Summary of Data Desensitization Solutions](./docs/system-design/security/data-desensitization.md) - [Why Both Front-end and Back-end Need to Perform Data Validation](./docs/system-design/security/data-validation.md) +- [Why Can Passwords Only Be Reset When Forgotten, Not Told the Original Password?](./docs/system-design/security/why-password-reset-instead-of-retrieval.md) ### Scheduled Tasks @@ -338,11 +330,14 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo ## Distributed System +- [⭐High-Frequency Distributed System Interview Questions](https://interview.javaguide.cn/distributed-system/distributed-system.html) + ### Theory, Algorithms, and Protocols - [Interpretation of CAP Theory and BASE Theory](https://javaguide.cn/distributed-system/protocol/cap-and-base-theorem.html) - [Interpretation of Paxos Algorithm](https://javaguide.cn/distributed-system/protocol/paxos-algorithm.html) - [Interpretation of Raft Algorithm](https://javaguide.cn/distributed-system/protocol/raft-algorithm.html) +- [Interpretation of ZAB Protocol](https://javaguide.cn/distributed-system/protocol/zab.html) - [Detailed Explanation of Gossip Protocol](https://javaguide.cn/distributed-system/protocol/gossip-protocol.html) - [Detailed Explanation of Consistent Hashing Algorithm](https://javaguide.cn/distributed-system/protocol/consistent-hashing.html) @@ -370,8 +365,6 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo ### Distributed Lock -# Distributed Locks - - [Introduction to Distributed Locks](https://javaguide.cn/distributed-system/distributed-lock.html) - [Summary of Common Distributed Lock Implementation Solutions](https://javaguide.cn/distributed-system/distributed-lock-implementations.html) @@ -449,4 +442,6 @@ Deploying multiple instances of the same service to avoid single point of failur If you want to stay up-to-date with my latest articles and share my valuable content, you can follow my official public account. -![JavaGuide Official Public Account](https://oss.javaguide.cn/github/javaguide/gongzhonghaoxuanchuan.png) +JavaGuide Official Public Account + + diff --git a/README_JA.md b/README_JA.md index 1ca8bc8626e..b715a9cfb74 100644 --- a/README_JA.md +++ b/README_JA.md @@ -1,26 +1,6 @@ -より快適でスピーディーな体験のため、オンライン閲覧プラットフォームでの閲覧をおすすめします!リンク: [javaguide.cn](https://javaguide.cn/)。 - -
- -[![logo](https://oss.javaguide.cn/github/javaguide/csdn/1c00413c65d1995993bf2b0daf7b4f03.png)](https://github.com/Snailclimb/JavaGuide) - -[GitHub](https://github.com/Snailclimb/JavaGuide) | [Gitee](https://gitee.com/SnailClimb/JavaGuide) - -Snailclimb%2FJavaGuide | Trendshift +**[English](./README_EN.md)** | **日本語** | **[简体中文](./README.md)** -
- -> - **面接版**: Java の面接対策をしている方は、**[《Java 面接ガイド》](./docs/zhuanlan/java-mian-shi-zhi-bei.md)**(高品質で、面接向けに特化して設計されており、JavaGuide と併用するのがおすすめです)を検討してみてください。 -> - **知識惑星(Knowledge Planet)**: 限定の面接ミニ書籍/1 対 1 のコミュニケーション/履歴書の添削/限定の就職活動ガイドなど、**[JavaGuide 知識惑星](./docs/about-the-author/zhishixingqiu-two-years.md)** への参加を歓迎します(リンクをクリックすると惑星の詳しい紹介を確認できます。本当に必要かどうかを見極めてから参加してください)。 -> - **使い方の提案**: 経験豊富な面接官は、プロジェクト経験に沿って技術的な問題を深掘りしてくるものです。技術記事を丸暗記するのは絶対にやめましょう!詳しい学習の提案については [JavaGuide 使い方の提案](./docs/javaguide/use-suggestion.md) を参照してください。 -> - **Star のお願い**: JavaGuide の内容が役に立ったと感じたら、ぜひ無料の Star をお願いします。それが私にとって最大の励みになります。共に歩み、共に努力してくれる皆さん、ありがとうございます!Github リンク: [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)。 -> - **転載に関する注意**: 以下のすべての記事は、冒頭に特に断りがない限り、JavaGuide のオリジナル作品です。転載の際は出典を明記してください。悪質な盗用・コピーが発見された場合は、法的手段を用いて権利を守ります。皆で良質な技術創作環境を維持していきましょう! - -
- -
- - +より快適でスピーディーな体験のため、オンライン閲覧プラットフォームでの閲覧をおすすめします!リンク: [javaguide.cn](https://javaguide.cn/)。 ## プロジェクト関連 diff --git a/docs/cs-basics/operating-system/linux-intro.md b/docs/cs-basics/operating-system/linux-intro.md index 69a9fab9d6c..535a9f25e3e 100644 --- a/docs/cs-basics/operating-system/linux-intro.md +++ b/docs/cs-basics/operating-system/linux-intro.md @@ -48,10 +48,15 @@ Linux 的发行版本可以大体分为两类: - **商业公司维护的发行版本**:比如 Red Hat 公司维护支持的 Red Hat Enterprise Linux (RHEL)。 - **社区组织维护的发行版本**:比如基于 Red Hat Enterprise Linux(RHEL)的 CentOS、基于 Debian 的 Ubuntu。 -对于初学者学习 Linux,推荐选择 CentOS,原因如下: +对于初学者学习 Linux,不建议再无条件选择 CentOS。CentOS Linux 8 已在 2021 年底停止维护,CentOS Linux 7 也已在 2024 年 6 月结束生命周期;现在的 CentOS Stream 是 RHEL 的上游持续交付分支,定位和过去“稳定的 RHEL 兼容重构版”不一样。 -- CentOS 免费且开放源代码。 -- CentOS 基于 RHEL,功能与 RHEL 高度一致,安全稳定、性能优秀。 +更稳妥的选择是: + +- 想学习企业服务器环境、RHEL 生态:优先选择 Rocky Linux 或 AlmaLinux。 +- 想快速上手、资料多、桌面和服务器都常见:选择 Ubuntu LTS。 +- 想要稳定、轻量、贴近社区发行版:选择 Debian。 + +如果你的公司环境仍在使用 CentOS,可以按实际环境学习对应版本;但新装学习环境时,更推荐选择仍在维护的发行版。 ## Linux 文件系统 @@ -69,7 +74,7 @@ inode 是 Linux/Unix 文件系统的基础。那 inode 到底是什么?有什 通过以下五点可以概括 inode 到底是什么: -1. 硬盘以扇区(Sector)为最小物理存储单位,而操作系统和文件系统以块(Block)为单位进行读写,块由多个扇区组成。文件数据存储在这些块中。现代硬盘扇区通常为 4KB,与一些常见块大小相同,但操作系统也支持更大的块大小,以提升大文件读写性能。文件元信息(例如权限、大小、修改时间以及数据块位置)存储在 inode(索引节点)中。每个文件都有唯一的 inode。inode 本身不存储文件数据,而是存储指向数据块的指针,操作系统通过这些指针找到并读取文件数据。固态硬盘(SSD)虽然没有物理扇区,但使用逻辑块,其概念与传统硬盘的块类似。 +1. 硬盘以扇区(Sector)为最小物理存储单位,而操作系统和文件系统通常以块(Block)为单位进行读写,块由多个扇区组成。传统磁盘扇区常见大小是 512 字节,现代磁盘也常见 4 KB 物理扇区(例如 512e/4Kn 设备);文件系统块大小也常见 4 KB,但两者不是一个概念。文件数据存储在这些块中,文件元信息(例如权限、大小、修改时间以及数据块位置)存储在 inode(索引节点)中。每个文件都有唯一的 inode。inode 本身不存储文件数据,而是存储指向数据块的指针,操作系统通过这些指针找到并读取文件数据。固态硬盘(SSD)虽然没有传统机械磁盘意义上的物理扇区,但仍然对外暴露逻辑块接口。 2. inode 是一种固定大小的数据结构,其大小在文件系统创建时就确定了,并且在文件的生命周期内保持不变。 3. inode 的访问速度非常快,因为系统可以直接通过 inode 号码定位到文件的元数据信息,无需遍历整个文件系统。 4. inode 的数量是有限的,每个文件系统只能包含固定数量的 inode。这意味着当文件系统中的 inode 用完时,无法再创建新的文件或目录,即使磁盘上还有可用空间。因此,在创建文件系统时,需要根据文件和目录的预期数量来合理分配 inode 的数量。 @@ -82,7 +87,7 @@ inode 是 Linux/Unix 文件系统的基础。那 inode 到底是什么?有什 - **inode**:记录文件的属性信息,可以使用 `stat` 命令查看 inode 信息。 - **block**:实际文件的内容,如果一个文件大于一个块时候,那么将占用多个 block,但是一个块只能存放一个文件。(因为数据是由 inode 指向的,如果有两个文件的数据存放在同一个块中,就会乱套了) -![文件inode信息](./images/文件inode信息.png) +![stat 命令查看文件 inode 信息](./images/文件inode信息.png) 可以看出,Linux/Unix 操作系统使用 inode 区分不同的文件。这样做的好处是,即使文件名被修改或删除,文件的 inode 号码不会改变,从而可以避免一些因文件重命名、移动或删除导致的错误。同时,inode 也可以提供更高的文件系统性能,因为 inode 的访问速度非常快,可以直接通过 inode 号码定位到文件的元数据信息,无需遍历整个文件系统。 @@ -187,7 +192,7 @@ Linux 使用一种称为目录树的层次结构来组织文件和目录。目 - `ls`:显示目录中的文件和子目录的列表。例如:`ls /home`,显示 `/home` 目录下的文件和子目录列表。 - `ll`:`ll` 是 `ls -l` 的别名,ll 命令可以看到该目录下的所有目录和文件的详细信息。 - `mkdir [选项] 目录名`:创建新目录(增)。例如:`mkdir -m 755 my_directory`,创建一个名为 `my_directory` 的新目录,并将其权限设置为 755,其中所有者拥有读、写、执行权限,所属组和其他用户只有读、执行权限,无法修改目录内容(如创建或删除文件)。如果希望所有用户(包括所属组和其他用户)对目录都拥有读、写、执行权限,则应设置权限为 `777`,即:`mkdir -m 777 my_directory`。 -- `find [路径] [表达式]`:在指定目录及其子目录中搜索文件或目录(查),非常强大灵活。例如:① 列出当前目录及子目录下所有文件和文件夹:`find .`;② 在 `/home` 目录下查找以 `.txt` 结尾的文件名:`find /home -name "*.txt"`,忽略大小写:`find /home -i name "*.txt"`;③ 当前目录及子目录下查找所有以 `.txt` 和 `.pdf` 结尾的文件:`find . \( -name "*.txt" -o -name "*.pdf" \)` 或 `find . -name "*.txt" -o -name "*.pdf"`。 +- `find [路径] [表达式]`:在指定目录及其子目录中搜索文件或目录(查),非常强大灵活。例如:① 列出当前目录及子目录下所有文件和文件夹:`find .`;② 在 `/home` 目录下查找以 `.txt` 结尾的文件名:`find /home -name "*.txt"`,忽略大小写:`find /home -iname "*.txt"`;③ 当前目录及子目录下查找所有以 `.txt` 和 `.pdf` 结尾的文件:`find . \( -name "*.txt" -o -name "*.pdf" \)` 或 `find . -name "*.txt" -o -name "*.pdf"`。 - `pwd`:显示当前工作目录的路径。 - `rmdir [选项] 目录名`:删除空目录(删)。例如:`rmdir -p my_directory`,删除名为 `my_directory` 的空目录,并且会递归删除 `my_directory` 的空父目录,直到遇到非空目录或根目录。 - `rm [选项] 文件或目录名`:删除文件/目录(删)。例如:`rm -r my_directory`,删除名为 `my_directory` 的目录,`-r`(recursive,递归)表示会递归删除指定目录及其所有子目录和文件。 @@ -243,11 +248,11 @@ Linux 中的打包文件一般是以 `.tar` 结尾的,压缩的命令一般是 示例:在随意某个目录下 `ls -l` -![](./images/Linux权限命令.png) +![Linux 文件权限命令示例](./images/Linux权限命令.png) 第一列的内容的信息解释如下: -![](./images/Linux权限解读.png) +![Linux 文件权限字段解读](./images/Linux权限解读.png) > 下面将详细讲解文件的类型、Linux 中权限以及文件有所有者、所在组、其它组具体是什么? @@ -299,16 +304,21 @@ Linux 中的打包文件一般是以 `.tar` 结尾的,压缩的命令一般是 **`chmod u=rwx,g=rw,o=r aaa.txt`** 或者 **`chmod 764 aaa.txt`** -![](./images/修改文件权限.png) +![chmod 修改 Linux 文件权限示例](./images/修改文件权限.png) **补充一个比较常用的东西:** 假如我们装了一个 zookeeper,我们每次开机到要求其自动启动该怎么办? -1. 新建一个脚本 zookeeper。 -2. 为新建的脚本 zookeeper 添加可执行权限,命令是:`chmod +x zookeeper`。 -3. 把 zookeeper 这个脚本添加到开机启动项里面,命令是:`chkconfig --add zookeeper`。 -4. 如果想看看是否添加成功,命令是:`chkconfig --list`。 +现在主流 Linux 发行版基本使用 systemd 管理服务,推荐做法是编写一个 `zookeeper.service` 单元文件,然后使用下面的命令设置开机自启: + +```bash +sudo systemctl enable zookeeper +sudo systemctl start zookeeper +sudo systemctl status zookeeper +``` + +如果修改了 service 文件,需要先执行 `sudo systemctl daemon-reload` 让 systemd 重新加载配置。`chkconfig --add zookeeper`、`chkconfig --list` 属于 SysV init 时代的做法,只有在较老的发行版或兼容环境中才会用到。 ### 用户管理 @@ -348,6 +358,7 @@ Linux 系统是一个多用户多任务的分时操作系统,任何一个要 - `sar [选项] [时间间隔] [重复次数]`:用于收集、报告和分析系统的性能统计信息,包括系统的 CPU 使用、内存使用、磁盘 I/O、网络活动等详细信息。它的特点是可以连续对系统取样,获得大量的取样数据。取样数据和分析的结果都可以存入文件,使用它时消耗的系统资源很小。 - `ps [选项]`:用于查看系统中的进程信息,包括进程的 ID、状态、资源使用情况等。`ps -ef`/`ps -aux`:这两个命令都是查看当前系统正在运行进程,两者的区别是展示格式不同。如果想要查看特定的进程可以使用这样的格式:`ps aux|grep redis`(查看包括 redis 字符串的进程),也可使用 `pgrep redis -a`。 - `systemctl [命令] [服务名称]`:用于管理系统的服务和单元,可以查看系统服务的状态、启动、停止、重启等。 +- `journalctl [选项]`:用于查看 systemd 日志,排查服务启动失败、系统错误非常常用。例如:`journalctl -u nginx -f` 实时查看 nginx 服务日志,`journalctl -xe` 查看最近的系统错误上下文。 ### 网络通信 @@ -377,7 +388,7 @@ Linux 系统是一个多用户多任务的分时操作系统,任何一个要 - 用户级别环境变量:`~/.bashrc`、`~/.bash_profile`。 - 系统级别环境变量:`/etc/bashrc`、`/etc/environment`、`/etc/profile`、`/etc/profile.d`。 -上述配置文件执行先后顺序为:`/etc/environment` --> `/etc/profile` --> `/etc/profile.d` --> `~/.bash_profile` --> `/etc/bashrc` --> `~/.bashrc` +环境变量配置文件的加载顺序不是固定一条线,取决于当前 shell 是登录 shell、非登录交互 shell,还是非交互 shell。以 Bash 为例,登录 shell 通常会读取 `/etc/profile`,再读取用户目录下第一个存在且可读的 `~/.bash_profile`、`~/.bash_login` 或 `~/.profile`;交互式非登录 shell 通常读取 `~/.bashrc`。很多发行版会在 `~/.bash_profile` 中手动加载 `~/.bashrc`,所以你实际看到的加载链路还会受发行版默认配置影响。 如果要修改系统级别环境变量文件,需要管理员具备对该文件的写入权限。 diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md index f530bed8195..c44c65c0762 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md @@ -18,14 +18,14 @@ head: 开始本文的内容之前,我们先聊聊为什么要学习操作系统。 -- **从对个人能力方面提升来说**:操作系统中的很多思想、很多经典的算法,你都可以在我们日常开发使用的各种工具或者框架中找到它们的影子。比如说我们开发的系统使用的缓存(比如 Redis)和操作系统的高速缓存就很像。CPU 中的高速缓存有很多种,不过大部分都是为了解决 CPU 处理速度和内存处理速度不对等的问题。我们还可以把内存看作外存的高速缓存,程序运行的时候我们把外存的数据复制到内存,由于内存的处理速度远远高于外存,这样提高了处理速度。同样地,我们使用的 Redis 缓存就是为了解决程序处理速度和访问常规关系型数据库速度不对等的问题。高速缓存一般会按照局部性原理(2-8 原则)根据相应的淘汰算法保证缓存中的数据是经常会被访问的。我们平常使用的 Redis 缓存很多时候也会按照 2-8 原则去做,很多淘汰算法都和操作系统中的类似。既说了 2-8 原则,那就不得不提命中率了,这是所有缓存概念都通用的。简单来说也就是你要访问的数据有多少能直接在缓存中直接找到。命中率高的话,一般表明你的缓存设计比较合理,系统处理速度也相对较快。 +- **从对个人能力方面提升来说**:操作系统中的很多思想、很多经典的算法,你都可以在我们日常开发使用的各种工具或者框架中找到它们的影子。比如说我们开发的系统使用的缓存(比如 Redis)和操作系统的高速缓存就很像。CPU 中的高速缓存有很多种,不过大部分都是为了解决 CPU 处理速度和内存处理速度不对等的问题。我们还可以把内存看作外存的高速缓存,程序运行的时候我们把外存的数据复制到内存,由于内存的处理速度远远高于外存,这样提高了处理速度。同样地,我们使用的 Redis 缓存就是为了解决程序处理速度和访问常规关系型数据库速度不对等的问题。高速缓存通常会利用局部性原理:程序在一段时间内访问的数据往往集中在一小部分区域,这和二八原则有些相似,但两者不是同一个概念。很多淘汰算法都和操作系统中的类似。说到缓存,那就不得不提命中率了,这是所有缓存概念都通用的。简单来说也就是你要访问的数据有多少能直接在缓存中直接找到。命中率高的话,一般表明你的缓存设计比较合理,系统处理速度也相对较快。 - **从面试角度来说**:尤其是校招,对于操作系统方面知识的考察是非常非常多的。 **简单来说,学习操作系统能够提高自己思考的深度以及对技术的理解力,并且,操作系统方面的知识也是面试必备。** ## 操作系统基础 -![](https://oss.javaguide.cn/2020-8/image-20200807161118901.png) +![操作系统基础知识导图](https://oss.javaguide.cn/2020-8/image-20200807161118901.png) ### 什么是操作系统? @@ -169,7 +169,7 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 这是我用 AI 绘制的一张图片,可以说是非常形象了: -![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/process-and-thread-difference-wechat-factory-as-an-example.png) +![用微信工厂类比进程和线程的区别](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/wechat-factory-process-thread.png) 下图是 Java 内存区域,我们从 JVM 的角度来说一下线程和进程之间的关系吧! @@ -211,7 +211,7 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 2. **读写锁(Read-Write Lock)**:允许多个线程同时读取共享资源,但只有一个线程可以对共享资源进行写操作。 3. **信号量(Semaphore)**:它允许同一时刻多个线程访问同一资源,但是需要控制同一时刻访问此资源的最大线程数量。 4. **屏障(Barrier)**:屏障是一种同步原语,用于等待多个线程到达某个点再一起继续执行。当一个线程到达屏障时,它会停止执行并等待其他线程到达屏障,直到所有线程都到达屏障后,它们才会一起继续执行。比如 Java 中的 `CyclicBarrier` 是这种机制。 -5. **事件(Event)**:Wait/Notify:通过通知操作的方式来保持多线程同步,还可以方便的实现多线程优先级的比较操作。 +5. **条件变量(Condition Variable)/事件通知**:线程在条件不满足时等待,其他线程在条件变更后通知等待线程继续执行。它通常需要和互斥锁配合使用,避免“通知先发生、等待后发生”导致的丢通知问题。Java 中的 `Object.wait()/notify()`、`Condition.await()/signal()` 都属于这类思路。 ### PCB 是什么?包含哪些信息? @@ -301,7 +301,7 @@ PCB 主要包含下面几部分的内容: 这时,线程 1 等着线程 2 释放锁 B,而线程 2 等着线程 1 释放锁 A,双方都持有对方需要的资源,并等待对方释放,就形成了一个“死结”。 - +![死锁展示](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/deadlock-conditions-robots.png) ### 产生死锁的四个必要条件是什么? diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md index 400945b33fd..22c27b3160e 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md @@ -62,7 +62,7 @@ head: ![伙伴系统内存浪费问题](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/buddy-system-memory-waste.png) -对于内部内存碎片的问题,Linux 采用 **SLAB** 进行解决。由于这部分内容不是本篇文章的重点,这里就不详细介绍了。 +对于小对象频繁分配带来的内部内存碎片和性能问题,Linux 还会使用 **SLAB/SLUB** 这类分配器优化。它们会把常用内核对象缓存起来,按对象类型复用已经初始化过的内存块,减少重复分配、初始化和释放的成本。由于这部分内容不是本篇文章的重点,这里点到为止。 #### 非连续内存管理 @@ -489,6 +489,8 @@ I/O 多路复用把一批 fd 交给内核,让线程阻塞在 `select`、`poll` 5. **边扫描边观察算法(LOOK)**:SCAN 算法中磁头到了磁盘的边界才改变移动方向,这样可能会做很多无用功,因为磁头移动方向上可能已经没有请求需要处理了。LOOK 算法对 SCAN 算法进行了改进,如果磁头移动方向上已经没有别的请求,就可以立即改变磁头移动方向,依此往复。也就是边扫描边观察指定方向上还有无请求,因此叫 LOOK。 6. **均衡循环扫描算法(C-LOOK)**:C-SCAN 只有到达磁盘边界时才能改变磁头移动方向,并且磁头返回时也需要返回到磁盘起点,这样可能会做很多无用功。C-LOOK 算法对 C-SCAN 算法进行了改进,如果磁头移动的方向上已经没有磁道访问请求了,就可以立即让磁头返回,并且磁头只需要返回到有磁道访问请求的位置即可。 +举个简单例子:假设磁头当前在 50 号磁道,请求序列是 82、170、43、140、24。FCFS 会按请求到达顺序处理,磁头移动路径可能很长;SSTF 会先找离 50 最近的 43,再逐步选择最近请求,平均寻道距离通常更短,但远处请求可能一直被推迟;SCAN/LOOK 则会固定一个扫描方向,沿途处理请求,更像电梯上下运行,公平性更好。 + ## 参考 - 《计算机操作系统—汤小丹》第四版 diff --git a/docs/cs-basics/operating-system/shell-intro.md b/docs/cs-basics/operating-system/shell-intro.md index ff219fee2fd..53485d3aecd 100644 --- a/docs/cs-basics/operating-system/shell-intro.md +++ b/docs/cs-basics/operating-system/shell-intro.md @@ -335,16 +335,16 @@ Shell 编程支持下面几种运算符: ### 算数运算符 -| **运算符** | **说明** | **举例** | -| ---------- | -------- | ------------------------------------------ | -| **+** | 加法 | `expr $a + $b` | -| **-** | 减法 | `expr $a - $b` | -| **\*** | 乘法 | `expr $a \* $b` (注意星号需要转义) | -| **/** | 除法 | `expr $b / $a` | -| **%** | 取余 | `expr $b % $a` | -| **=** | 赋值 | `a=$b` 将变量 b 的值赋给 a | -| **==** | 相等 | `[ $a == $b ]` 用于数字比较,相同返回 true | -| **!=** | 不相等 | `[ $a != $b ]` 用于数字比较,不同返回 true | +| **运算符** | **说明** | **举例** | +| ---------- | -------- | ------------------------------------------------ | +| **+** | 加法 | `expr $a + $b` | +| **-** | 减法 | `expr $a - $b` | +| **\*** | 乘法 | `expr $a \* $b` (注意星号需要转义) | +| **/** | 除法 | `expr $b / $a` | +| **%** | 取余 | `expr $b % $a` | +| **=** | 赋值 | `a=$b` 将变量 b 的值赋给 a | +| **==** | 相等 | `[ "$a" == "$b" ]` 用于字符串比较,相同返回 true | +| **!=** | 不相等 | `[ "$a" != "$b" ]` 用于字符串比较,不同返回 true | **推荐使用 bash 内置算术扩展**: @@ -467,21 +467,21 @@ fi ### 布尔运算符 -| **运算符** | **说明** | **举例** | -| ---------- | -------------------------------------------------------------------- | ------------------------------------------ | -| **!** | 将表达式的结果取反。如果表达式为 true,则返回 false;否则返回 true。 | `[ ! false ]` 返回 true。 | -| **-o** | 有一个表达式为 true,则返回 true。 | `[ $a -lt 20 -o $b -gt 100 ]` 返回 true。 | -| **-a** | 两个表达式都为 true 才会返回 true。 | `[ $a -lt 20 -a $b -gt 100 ]` 返回 false。 | +| **运算符** | **说明** | **举例** | +| ---------- | -------------------------------------------------------------------- | ---------------------------------------------- | +| **!** | 将表达式的结果取反。如果表达式为 true,则返回 false;否则返回 true。 | `[ ! false ]` 返回 true。 | +| **-o** | 有一个表达式为 true,则返回 true。 | `[ "$a" -lt 20 -o "$b" -gt 100 ]` 返回 true。 | +| **-a** | 两个表达式都为 true 才会返回 true。 | `[ "$a" -lt 20 -a "$b" -gt 100 ]` 返回 false。 | ### 字符串运算符 | **运算符** | **说明** | **举例** | | ---------- | --------------------------------- | ----------------------------- | -| **=** | 检测两个字符串是否**相等** | `[ $a = $b ]` | -| **!=** | 检测两个字符串是否**不相等** | `[ $a != $b ]` | -| **-z** | 检测字符串长度是否为 **0** (zero) | `[ -z $a ]` 为空返回 true | +| **=** | 检测两个字符串是否**相等** | `[ "$a" = "$b" ]` | +| **!=** | 检测两个字符串是否**不相等** | `[ "$a" != "$b" ]` | +| **-z** | 检测字符串长度是否为 **0** (zero) | `[ -z "$a" ]` 为空返回 true | | **-n** | 检测字符串长度是否**不为 0** | `[ -n "$a" ]` 不为空返回 true | -| **str** | 直接检测字符串是否为空 | `[ $a ]` 不为空返回 true | +| **str** | 直接检测字符串是否为空 | `[ "$a" ]` 不为空返回 true | 简单示例: @@ -489,7 +489,7 @@ fi #!/bin/bash a="abc"; b="efg"; -if [[ $a = $b ]] +if [[ "$a" = "$b" ]] then echo "a 等于 b" else @@ -872,6 +872,8 @@ cat huge_file.txt | grep "pattern" | head -n 10 ## 生产环境最佳实践 +这一节偏进阶,面向已经能写基础 Shell 脚本、开始把脚本放进定时任务、部署流程或线上排障流程里的读者。初学者可以先掌握前面的变量、条件、循环、函数和基础规范,再回来补这部分。 + ### 脚本安全性 **1. 始终使用严格模式**: @@ -964,9 +966,9 @@ retry_with_backoff() { local delay=$(( base_delay * (1 << (attempt - 1)) )) delay=$(( delay > max_delay ? max_delay : delay )) local jitter=$((RANDOM % 1000)) # 0-999ms 随机抖动 - delay=$(( delay * 1000 + jitter )) - echo "请求失败,${delay}ms 后重试 (第 $attempt 次)" >&2 - sleep "${delay}e-6" + delay=$(( delay + (jitter + 999) / 1000 )) + echo "请求失败,约 ${delay}s 后重试 (第 $attempt 次)" >&2 + sleep "$delay" fi ((attempt++)) diff --git a/docs/cs-basics/operating-system/virtual-memory.md b/docs/cs-basics/operating-system/virtual-memory.md index 40d443501d5..2ca529f7ded 100644 --- a/docs/cs-basics/operating-system/virtual-memory.md +++ b/docs/cs-basics/operating-system/virtual-memory.md @@ -38,7 +38,7 @@ head: ![虚拟地址到物理地址的映射过程:不同进程的相同虚拟地址通过 MMU 和页表映射到不同物理页](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-virtual-physical-mapping.png) -小 G 习惯把虚拟内存的好处归成三条,后面整篇文章其实都在为这三条服务: +Guide 习惯把虚拟内存的好处归成三条,后面整篇文章其实都在为这三条服务: - **进程隔离**:每个进程一套页表,互相看不到对方的物理内存,A 进程没法通过地址访问 B 进程的数据。 - **突破物理内存大小限制**:程序运行有局部性,用不到的页可以先扔到磁盘上,需要时再换回来,于是进程“感觉到”的内存可以比物理内存大。 diff --git a/docs/cs-basics/operating-system/zero-copy.md b/docs/cs-basics/operating-system/zero-copy.md index df28c752240..c2b5a94412b 100644 --- a/docs/cs-basics/operating-system/zero-copy.md +++ b/docs/cs-basics/operating-system/zero-copy.md @@ -16,7 +16,7 @@ head: 到这一步,很多人就开始打太极了。能背出“零拷贝就是不经过用户态”的不少,能把四次拷贝、两次 DMA、几次上下文切换的账算清楚的不多。 -小 G 这篇就把这本账捋一遍:传统 I/O 到底拷了几次,零拷贝的“零”到底零在哪,mmap、sendfile、splice 三条路线各自省了什么、又各自有什么代价。 +Guide 这篇就把这本账捋一遍:传统 I/O 到底拷了几次,零拷贝的“零”到底零在哪,mmap、sendfile、splice 三条路线各自省了什么、又各自有什么代价。 ## 先说清楚这本账的前提 diff --git a/docs/java/concurrent/virtual-thread.md b/docs/java/concurrent/virtual-thread.md index c4dee66c5ec..9bd47eb1212 100644 --- a/docs/java/concurrent/virtual-thread.md +++ b/docs/java/concurrent/virtual-thread.md @@ -1,6 +1,6 @@ --- title: 虚拟线程常见问题总结 -description: Java 21虚拟线程详解:全面解析Virtual Threads虚拟线程原理、与平台线程区别、Project Loom项目、适用IO密集型场景、使用注意事项与最佳实践。 +description: Java 21 虚拟线程详解:梳理 Virtual Threads 的定位、调度原理、与平台线程的区别、适用场景、创建方式、性能边界、Spring Boot 接入方式和实践注意事项。 category: Java tag: - Java并发 @@ -10,232 +10,444 @@ head: content: Java虚拟线程,Virtual Threads,Project Loom,Java 21新特性,轻量级线程,协程,虚拟线程原理 --- -> 本文部分内容来自 [Lorin](https://github.com/Lorin-github) 的[PR](https://github.com/Snailclimb/JavaGuide/pull/2190)。 +一个 Web 请求进来,代码要查数据库、调远程接口、读写文件。按传统的同步写法,这个请求会占住一个平台线程,哪怕大部分时间都在等 I/O。 -虚拟线程在 Java 21 正式发布,这是一项重量级的更新。 +线程池能缓解线程创建成本,但不能改变一个事实:平台线程数量仍然受操作系统线程数量、内存和调度成本限制。当并发请求继续增加时,线程池里的线程会被排队任务占满,吞吐量很快卡住。 + +虚拟线程就是为这个问题来的。它让我们继续用简单的同步阻塞代码,同时让等待 I/O 的任务不再长期占着昂贵的平台线程。 ## 什么是虚拟线程? -虚拟线程(Virtual Thread)是 JDK 而不是 OS 实现的轻量级线程(Lightweight Process,LWP),由 JVM 调度。许多虚拟线程共享同一个操作系统线程,虚拟线程的数量可以远大于操作系统线程的数量。 +虚拟线程(Virtual Thread)是 Java 21 正式引入的一种轻量级线程,也是 `java.lang.Thread` 的一种实现。它由 JDK 管理和调度,而不是直接和某个操作系统线程一一绑定。 -## 虚拟线程和平台线程有什么关系? +平台线程(Platform Thread)通常是对操作系统线程的薄封装。一个平台线程运行时,会在整个生命周期内占用一个操作系统线程。虚拟线程不一样:它运行 Java 代码时需要挂载到某个平台线程上;当它执行可挂起的阻塞操作时,JDK 可以把它从平台线程上卸载下来,让这个平台线程去执行别的虚拟线程。 + +因此,虚拟线程的数量可以远大于平台线程数量。官方文档里用虚拟内存做类比:操作系统把大量虚拟地址映射到有限物理内存,Java 运行时则把大量虚拟线程映射到较少的平台线程。 -在引入虚拟线程之前,`java.lang.Thread` 包已经支持所谓的平台线程(Platform Thread),也就是没有虚拟线程之前,我们一直使用的线程。JVM 调度程序通过平台线程(载体线程)来管理虚拟线程,一个平台线程可以在不同的时间执行不同的虚拟线程(多个虚拟线程挂载在一个平台线程上),当虚拟线程被阻塞或等待时,平台线程可以切换到执行另一个虚拟线程。 +虚拟线程的几个关键点: -虚拟线程、平台线程和系统内核线程的关系图如下所示(图源:[How to Use Java 19 Virtual Threads](https://medium.com/javarevisited/how-to-use-java-19-virtual-threads-c16a32bad5f7)): +- 虚拟线程仍然是 `Thread`,支持 `ThreadLocal`、中断、异常栈、调试和 JFR 观测。 +- 虚拟线程适合大量阻塞等待的任务,比如 HTTP 调用、数据库查询、消息队列访问、文件或网络 I/O。 +- 虚拟线程不是更快的 CPU 执行单元,不会让一段纯计算代码跑得更快。 +- 虚拟线程很便宜,通常应该“每个任务一个虚拟线程”,而不是像平台线程一样池化复用。 + +## 虚拟线程和平台线程有什么关系? + +在 Java 里,虚拟线程、平台线程和操作系统线程大致是这样的关系: ![虚拟线程、平台线程和系统内核线程的关系](https://oss.javaguide.cn/github/javaguide/java/new-features/virtual-threads-platform-threads-kernel-threads-relationship.png) -关于平台线程和系统内核线程的对应关系多提一点:在 Windows 和 Linux 等主流操作系统中,Java 线程采用的是一对一的线程模型,也就是一个平台线程对应一个系统内核线程。Solaris 系统是一个特例,HotSpot VM 在 Solaris 上支持多对多和一对一。具体可以参考 R 大的回答: [JVM 中的线程模型是用户级的么?](https://www.zhihu.com/question/23096638/answer/29617153)。 +在 Windows、Linux 等主流操作系统中,HotSpot JVM 的平台线程通常采用一对一线程模型,也就是一个平台线程对应一个操作系统线程。虚拟线程引入后,JDK 在平台线程之上又加了一层调度: + +- 虚拟线程是任务的承载者,业务代码看到的 `Thread.currentThread()` 返回的是虚拟线程本身。 +- 平台线程是虚拟线程的载体(Carrier Thread),负责真正执行虚拟线程里的 Java 代码。 +- 操作系统仍然只调度平台线程,不知道虚拟线程的存在。 + +一个虚拟线程开始执行时,会被 JDK 调度器挂载(mount)到某个平台线程上。执行到阻塞 I/O、`BlockingQueue.take()`、`Future.get()` 等支持挂起的阻塞点时,虚拟线程可以卸载(unmount),平台线程被释放出来继续执行其他虚拟线程。等阻塞操作就绪后,虚拟线程再被提交回调度器,挂载到某个平台线程上继续执行。 + +这个挂载和卸载过程对业务代码是透明的。你写的仍然是普通同步代码: + +```java +String body = httpClient.send(request, BodyHandlers.ofString()).body(); +Result result = repository.query(body); +return service.handle(result); +``` + +如果这些调用内部发生阻塞,虚拟线程可以挂起自己;如果换成平台线程,这个线程会一直占住对应的操作系统线程。 + +## Project Loom 和虚拟线程是什么关系? + +Project Loom 是 OpenJDK 中改进 Java 并发模型的项目,虚拟线程是 Loom 最重要的成果之一。虚拟线程先后在 JDK 19、JDK 20 中预览,最终通过 [JEP 444](https://openjdk.org/jeps/444) 在 JDK 21 转正。 + +Loom 不只是加了一个轻量级线程 API。它还推动了 JDK 阻塞 I/O、调试、JFR、线程转储等配套能力的调整,让传统的 thread-per-request 编程风格在高并发 I/O 场景下重新变得可扩展。 + +这也是虚拟线程和普通“协程库”的一个重要区别:虚拟线程被纳入了 Java 平台的线程模型。调试器、Profiler、JFR、线程 dump 都能以线程为单位理解它,而不是把业务调用链拆成一堆回调阶段。 -## 虚拟线程有什么优点和缺点? +## 虚拟线程解决了什么问题? -### 优点 +很多服务端程序天然适合“一个请求一个线程”的模型。它的好处很明显:代码顺序执行,异常可以沿着调用栈抛出,调试器能一步步跟进去,线程 dump 也能看到请求卡在哪里。 -- **非常轻量级**:可以在单个线程中创建成百上千个虚拟线程而不会导致过多的线程创建和上下文切换。 -- **简化异步编程**: 虚拟线程可以简化异步编程,使代码更易于理解和维护。它可以将异步代码编写得更像同步代码,避免了回调地狱(Callback Hell)。 -- **减少资源开销**: 由于虚拟线程是由 JVM 实现的,它能够更高效地利用底层资源,例如 CPU 和内存。虚拟线程的上下文切换比平台线程更轻量,因此能够更好地支持高并发场景。 +问题在于平台线程太贵。 -### 缺点 +假设一个接口平均耗时 50ms,系统要达到 2000 QPS,按 Little's Law 粗略估算,需要同时处理约 100 个请求。如果接口平均耗时变成 500ms,同样 2000 QPS 就需要约 1000 个并发请求。每个请求都占一个平台线程时,线程数量很容易先于 CPU、网络带宽、数据库连接等资源成为瓶颈。 -- **不适用于计算密集型任务**: 虚拟线程适用于 I/O 密集型任务,但不适用于计算密集型任务,因为密集型计算始终需要 CPU 资源作为支持。 -- **与某些第三方库不兼容**: 虽然虚拟线程设计时考虑了与现有代码的兼容性,但某些依赖平台线程特性的第三方库可能不完全兼容虚拟线程。 +异步编程、Reactive 编程可以把线程从等待 I/O 中释放出来,但代价也很明显:调用链被拆成回调、`CompletableFuture` 链或响应式流水线,异常处理、调试、火焰图和线程上下文都会变复杂。 + +虚拟线程试图保留同步代码的可读性,同时降低阻塞等待时占用平台线程的成本。它提升的主要是吞吐能力和并发承载能力,不是单个请求的执行速度。 + +## 虚拟线程适合哪些场景? + +虚拟线程最适合下面这类任务: + +- 并发任务数量很多,通常是成千上万级别。 +- 任务大部分时间在等待 I/O,比如数据库、Redis、HTTP/RPC、消息队列、文件和网络读写。 +- 现有代码主要是同步阻塞模型,不想为了扩展性改成复杂的异步链。 +- 希望保留传统调用栈,方便调试、压测分析和线上排查。 + +典型场景包括: + +- Spring MVC / Servlet 接口中调用数据库和外部 HTTP 服务。 +- 后台任务批量调用第三方接口。 +- 网关或聚合服务并发调用多个下游服务。 +- 消息消费逻辑中包含阻塞式数据库写入或远程调用。 + +虚拟线程不适合把 CPU 密集型任务“变快”。如果任务主要是在算哈希、压缩图片、排序大数组、跑复杂规则引擎,线程数量超过 CPU 核心数之后,吞吐通常不会继续提高。CPU 密集型工作仍然应该关注算法、数据结构、批处理、并行流、专门的计算线程池或本地化优化。 ## 如何创建虚拟线程? -官方提供了以下四种方式创建虚拟线程: +JDK 21 中常见的创建方式有四种。 -1. 使用 `Thread.startVirtualThread()` 创建 -2. 使用 `Thread.ofVirtual()` 创建 -3. 使用 `ThreadFactory` 创建 -4. 使用 `Executors.newVirtualThreadPerTaskExecutor()`创建 +### 使用 `Thread.startVirtualThread()` -**1、使用 `Thread.startVirtualThread()` 创建** +适合启动一个很简单的虚拟线程: ```java -public class VirtualThreadTest { - public static void main(String[] args) { - CustomThread customThread = new CustomThread(); - Thread.startVirtualThread(customThread); +public class VirtualThreadDemo { + public static void main(String[] args) throws InterruptedException { + Thread thread = Thread.startVirtualThread(() -> { + System.out.println(Thread.currentThread()); + }); + + thread.join(); } } +``` + +需要注意的是,虚拟线程是守护线程。如果 `main` 方法不等待它结束,JVM 可能直接退出,导致任务还没来得及执行完。 + +### 使用 `Thread.ofVirtual()` + +`Thread.ofVirtual()` 返回一个 `Thread.Builder.OfVirtual`,可以设置线程名,也可以选择创建后立即启动或先不启动: + +```java +public class VirtualThreadDemo { + public static void main(String[] args) throws InterruptedException { + Thread unstarted = Thread.ofVirtual() + .name("order-query") + .unstarted(() -> System.out.println("query order")); + + unstarted.start(); + unstarted.join(); + + Thread started = Thread.ofVirtual() + .name("payment-query") + .start(() -> System.out.println("query payment")); -static class CustomThread implements Runnable { - @Override - public void run() { - System.out.println("CustomThread run"); + started.join(); } } ``` -**2、使用 `Thread.ofVirtual()` 创建** +### 使用 `ThreadFactory` + +如果你希望统一线程命名,或者把线程工厂交给框架使用,可以通过 `ThreadFactory` 创建虚拟线程: ```java -public class VirtualThreadTest { - public static void main(String[] args) { - CustomThread customThread = new CustomThread(); - // 创建不启动 - Thread unStarted = Thread.ofVirtual().unstarted(customThread); - unStarted.start(); - // 创建直接启动 - Thread.ofVirtual().start(customThread); +import java.util.concurrent.ThreadFactory; + +public class VirtualThreadDemo { + public static void main(String[] args) throws InterruptedException { + ThreadFactory factory = Thread.ofVirtual() + .name("worker-", 0) + .factory(); + + Thread thread = factory.newThread(() -> { + System.out.println(Thread.currentThread().getName()); + }); + + thread.start(); + thread.join(); } } -static class CustomThread implements Runnable { - @Override - public void run() { - System.out.println("CustomThread run"); +``` + +### 使用 `Executors.newVirtualThreadPerTaskExecutor()` + +业务开发中最常见的是这种方式。它会为每个提交的任务创建一个新的虚拟线程: + +```java +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +public class VirtualThreadDemo { + public static void main(String[] args) throws Exception { + try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { + Future future = executor.submit(() -> { + return "hello virtual thread"; + }); + + System.out.println(future.get()); + } } } ``` -**3、使用 `ThreadFactory` 创建** +这里的 `ExecutorService` 不是传统意义上的线程池。它不会维护一组固定虚拟线程来复用,而是每个任务一个新的虚拟线程。`try-with-resources` 结束时会调用 `close()`,等待已提交任务完成。 + +## 虚拟线程要不要池化? + +不要池化虚拟线程。 + +线程池的主要目标是复用昂贵的平台线程,并顺便限制并发。虚拟线程本身不是稀缺资源,池化它们通常没有意义,还会把“每个任务一个线程”的模型重新绕回旧思路。 + +如果你的真实目标是限制访问某个资源的并发量,应该限制资源,而不是限制虚拟线程数量。比如某个老系统最多只能承受 20 个并发请求,可以用 `Semaphore` 控制并发: ```java -public class VirtualThreadTest { - public static void main(String[] args) { - CustomThread customThread = new CustomThread(); - ThreadFactory factory = Thread.ofVirtual().factory(); - Thread thread = factory.newThread(customThread); - thread.start(); +import java.util.concurrent.Semaphore; + +public class OldServiceClient { + private static final Semaphore LIMIT = new Semaphore(20); + + public String call() throws InterruptedException { + LIMIT.acquire(); + try { + return doCall(); + } finally { + LIMIT.release(); + } } -} -static class CustomThread implements Runnable { - @Override - public void run() { - System.out.println("CustomThread run"); + private String doCall() { + return "ok"; } } ``` -**4、使用`Executors.newVirtualThreadPerTaskExecutor()`创建** +如果瓶颈是数据库连接,那就调整连接池大小;如果瓶颈是下游接口限流,那就做限流、熔断和重试退避。虚拟线程能让等待变便宜,但不能让数据库连接、下游容量、CPU 和内存变无限。 + +## 虚拟线程和平台线程性能对比 + +先给结论:虚拟线程不是“跑得更快的线程”,而是“可以创建很多、阻塞成本更低的线程”。它通常能提升 I/O 密集型服务的吞吐,但不会降低一次数据库查询或一次 HTTP 调用本身的耗时。 + +下面这个例子模拟 10,000 个阻塞 1 秒的任务: ```java -public class VirtualThreadTest { +import java.time.Duration; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.stream.IntStream; + +public class VirtualThreadCompareDemo { public static void main(String[] args) { - CustomThread customThread = new CustomThread(); - ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor(); - executor.submit(customThread); - } -} -static class CustomThread implements Runnable { - @Override - public void run() { - System.out.println("CustomThread run"); + long start = System.currentTimeMillis(); + + try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { + IntStream.range(0, 10_000).forEach(i -> { + executor.submit(() -> { + Thread.sleep(Duration.ofSeconds(1)); + return i; + }); + }); + } + + System.out.println("cost: " + (System.currentTimeMillis() - start) + "ms"); } } ``` -## 虚拟线程和平台线程性能对比 +如果把它换成 `Executors.newFixedThreadPool(200)`,同一时间最多只有 200 个任务在执行,10,000 个任务会被分批处理。按每批 1 秒粗略估计,总耗时接近 50 秒。虚拟线程版本可以让这 10,000 个任务几乎同时进入等待状态,平台线程在等待期间被释放出来,总耗时更接近单个任务的等待时间。 -通过多线程和虚拟线程的方式处理相同的任务,对比创建的系统线程数和处理耗时。 +这个例子只能说明虚拟线程对“阻塞等待”友好,不是严谨基准测试。真实服务要看数据库连接池、HTTP 客户端连接池、下游限流、GC、对象分配、锁竞争、容器 CPU 配额等因素。 -**说明**:统计创建的系统线程中部分为后台线程(比如 GC 线程),两种场景下都一样,所以并不影响对比。 +## 虚拟线程的底层原理是什么? -**测试代码**: +可以把虚拟线程的执行过程拆成三件事:调度、挂载/卸载、栈管理。 -```java -public class VirtualThreadTest { - static List list = new ArrayList<>(); - public static void main(String[] args) { - // 开启线程 统计平台线程数 - ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1); - scheduledExecutorService.scheduleAtFixedRate(() -> { - ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); - ThreadInfo[] threadInfo = threadBean.dumpAllThreads(false, false); - updateMaxThreadNum(threadInfo.length); - }, 10, 10, TimeUnit.MILLISECONDS); - - long start = System.currentTimeMillis(); - // 虚拟线程 - ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor(); - // 使用平台线程 - // ExecutorService executor = Executors.newFixedThreadPool(200); - for (int i = 0; i < 10000; i++) { - executor.submit(() -> { - try { - // 线程睡眠 0.5 s,模拟业务处理 - TimeUnit.MILLISECONDS.sleep(500); - } catch (InterruptedException ignored) { - } - }); - } - executor.close(); - System.out.println("max:" + list.get(0) + " platform thread/os thread"); - System.out.printf("totalMillis:%dms\n", System.currentTimeMillis() - start); +### 调度 +平台线程依赖操作系统调度。虚拟线程由 JDK 自己的调度器调度,再由平台线程承载执行。JEP 444 中说明,虚拟线程调度器是一个 FIFO 模式的 `ForkJoinPool`,它和并行流使用的 common pool 不是同一个池。 - } - // 更新创建的平台最大线程数 - private static void updateMaxThreadNum(int num) { - if (list.isEmpty()) { - list.add(num); - } else { - Integer integer = list.get(0); - if (num > integer) { - list.add(0, num); - } - } - } +默认情况下,调度器的并行度和可用处理器数量相关,可以通过下面的系统属性调整: + +- `jdk.virtualThreadScheduler.parallelism`:调度器目标并行度。 +- `jdk.virtualThreadScheduler.maxPoolSize`:调度器可扩展的平台线程上限。 + +大多数业务系统不需要改这两个参数。优先排查连接池、限流、锁和阻塞点,通常比调整调度器参数更有效。 + +### 挂载和卸载 + +虚拟线程执行 Java 代码时,会挂载到某个平台线程上。遇到支持挂起的阻塞操作时,虚拟线程可以保存当前执行状态并卸载,平台线程继续服务其他虚拟线程。 + +常见的 JDK 阻塞操作已经为虚拟线程做了适配。例如网络 I/O、`BlockingQueue`、`Future.get()` 等,在虚拟线程中阻塞时通常不会长期占住底层平台线程。 + +不是所有阻塞都能卸载。JDK 21 到 JDK 23 中,虚拟线程在 `synchronized` 代码块或方法中阻塞,会出现 Pinning,也就是被固定在载体线程上。JDK 24 的 [JEP 491](https://openjdk.org/jeps/491) 改进了这一点,使虚拟线程在 `synchronized` 中阻塞时也能释放底层平台线程,消除了绝大多数由 `synchronized` 带来的 Pinning 场景。调用 native 方法或 Foreign Function & Memory API 相关代码时,仍然要关注剩余的 Pinning 风险。 + +### 栈管理 + +平台线程通常使用固定大小的操作系统线程栈。虚拟线程的栈以栈块对象的形式存放在 Java 堆中,可以随着执行过程增长和收缩。这也是虚拟线程能够大量创建的重要原因之一。 + +不过,这并不代表虚拟线程没有内存成本。每个虚拟线程仍然是对象,也有栈块、局部变量、`ThreadLocal` 等内存开销。百万级虚拟线程不是免费的,只是比百万级平台线程现实得多。 + +## 什么是 Pinning? + +Pinning 可以理解为“虚拟线程暂时没法从载体线程上卸载”。虚拟线程被固定在某个平台线程上后,它在阻塞期间会连带占住底层操作系统线程,扩展性也会跟着变差。 + +在 JDK 21 到 JDK 23 中,最典型的 Pinning 场景是:虚拟线程在 `synchronized` 代码块或方法里执行阻塞 I/O。 + +```java +public synchronized String load() throws IOException { + return remoteClient.get("/config"); // JDK 21-23 中,这里阻塞时可能固定载体线程 } ``` -**请求数 10000 单请求耗时 1s**: +短小、纯内存操作的 `synchronized` 问题不大。真正需要关注的是高频路径上持锁执行慢 I/O,例如持有对象锁时查数据库、调远程接口、读大文件。 + +如果你使用 JDK 21 到 JDK 23,可以考虑: + +- 避免在 `synchronized` 内部执行慢 I/O。 +- 对高频阻塞锁场景使用 `ReentrantLock`,并用 `try/finally` 释放锁。 +- 用 JFR 观察 `jdk.VirtualThreadPinned` 事件。 +- 临时使用 `-Djdk.tracePinnedThreads=full` 定位被固定的调用栈。 + +如果你使用 JDK 24 或更高版本,`synchronized` 导致的主要 Pinning 问题已经被 JEP 491 解决。选择 `synchronized` 还是 `java.util.concurrent.locks`,可以重新回到代码语义、可维护性和锁能力本身来判断。 + +## 使用虚拟线程有哪些注意事项? + +### 不要把虚拟线程当作提速 CPU 的工具 + +虚拟线程提升的是等待型任务的并发承载能力。CPU 密集型任务最终还是要抢 CPU 时间片,虚拟线程数量再多也不能突破 CPU 核心数的物理限制。 + +### 不要用线程池思维限制虚拟线程 + +不要创建固定数量的虚拟线程池。需要限制并发时,用 `Semaphore`、连接池、限流器或队列容量限制具体资源。 + +### 小心 `ThreadLocal` 缓存大对象 + +Java 21 正式版保证虚拟线程支持 `ThreadLocal`,这有利于兼容老代码和框架。但不要用 `ThreadLocal` 给每个虚拟线程缓存大对象。 + +以前在线程池里,一个 `ThreadLocal` 可能只对应几十或几百个平台线程。迁移到虚拟线程后,如果每个任务一个虚拟线程,同样的写法可能变成每个任务创建一份缓存对象,内存和分配压力会被放大。 + +如果只是传递请求上下文、用户 ID、Trace ID,通常问题不大。如果是缓存数据库连接、大数组、复杂 formatter、客户端对象,就要重新评估。新版本 Java 中的 Scoped Values 也值得关注,它更适合在大量虚拟线程之间传递不可变上下文。 + +### 虚拟线程不会消除线程安全问题 + +虚拟线程让创建线程更便宜,也意味着你更容易同时跑起大量并发任务。原来因为线程池较小而没暴露的数据竞争,切到虚拟线程后可能更容易出现。 + +需要继续遵守并发编程的基本规则:共享可变状态要加锁或隔离,数据库连接、会话对象、非线程安全客户端不要被多个虚拟线程同时乱用。 + +### 注意连接池和下游容量 + +很多服务迁移到虚拟线程后,第一个瓶颈不再是业务线程池,而是数据库连接池、HTTP 连接池、Redis 连接数或下游限流。 + +这不是虚拟线程的问题。虚拟线程只是让更多任务有机会同时推进,真正的共享资源仍然要按容量管理。压测时建议同时观察: -```plain -// Virtual Thread -max:22 platform thread/os thread -totalMillis:1806ms +- 应用 QPS、响应时间和错误率。 +- 数据库连接池活跃连接、等待队列和超时数。 +- HTTP 客户端连接池和下游 429/5xx。 +- CPU、堆内存、GC、对象分配速率。 +- JFR 中的虚拟线程事件和锁竞争。 -// Platform Thread 线程数200 -max:209 platform thread/os thread -totalMillis:50578ms +### 不要混用太多异步模型 -// Platform Thread 线程数500 -max:509 platform thread/os thread -totalMillis:20254ms +虚拟线程最适合同步阻塞代码。已经用 Reactive/WebFlux/Netty 写成全链路异步的系统,不一定能因为打开虚拟线程就获得明显收益。 -// Platform Thread 线程数1000 -max:1009 platform thread/os thread -totalMillis:10214ms +更麻烦的是混用模型:外层虚拟线程,内层又大量使用异步回调和线程池,排查时可能同时面对虚拟线程、事件循环、业务线程池、连接池几套上下文。迁移时最好先挑同步阻塞链路试点,而不是全系统一键替换。 -// Platform Thread 线程数2000 -max:2009 platform thread/os thread -totalMillis:5358ms +## Spring Boot 如何开启虚拟线程? + +Spring Boot 3.2 开始提供了比较直接的开关。使用 Java 21 或更高版本时,可以在配置中开启: + +```properties +spring.threads.virtual.enabled=true ``` -**请求数 10000 单请求耗时 0.5s**: +Spring Boot 官方文档还提到几个实践点: + +- 开启虚拟线程后,配置传统线程池大小的部分属性不再按原来的方式生效,因为虚拟线程调度依赖 JVM 范围内的平台线程池。 +- 虚拟线程是守护线程。如果应用依赖 `@Scheduled` 等后台任务保持 JVM 存活,建议设置 `spring.main.keep-alive=true`。 +- Spring Boot 官方目前建议 Java 24 或更高版本获得更好的虚拟线程体验,主要和 Pinning 改进有关。 -```plain -// Virtual Thread -max:22 platform thread/os thread -totalMillis:1316ms +一个简单配置如下: + +```yaml +spring: + threads: + virtual: + enabled: true + main: + keep-alive: true +``` -// Platform Thread 线程数200 -max:209 platform thread/os thread -totalMillis:25619ms +开启之后,不代表所有接口都会变快。它更可能改善的是同步阻塞、I/O 等待明显、并发较高的接口。如果接口主要耗在 CPU、锁竞争、慢 SQL 本身或下游限流上,虚拟线程只能让问题更早暴露。 -// Platform Thread 线程数500 -max:509 platform thread/os thread -totalMillis:10277ms +## 如何排查虚拟线程问题? -// Platform Thread 线程数1000 -max:1009 platform thread/os thread -totalMillis:5197ms +JDK 已经为虚拟线程补了不少观测能力。 -// Platform Thread 线程数2000 -max:2009 platform thread/os thread -totalMillis:2865ms +### 使用 `jcmd` 导出线程转储 + +传统 `jstack` 面对成千上万个虚拟线程时不太合适。JDK 提供了新的线程转储能力: + +```bash +jcmd Thread.dump_to_file -format=json thread-dump.json ``` -- 可以看到在密集 IO 的场景下,需要创建大量的平台线程异步处理才能达到虚拟线程的处理速度。 -- 因此,在密集 IO 的场景,虚拟线程可以大幅提高线程的执行效率,减少线程资源的创建以及上下文切换。 +也可以导出文本格式: -**注意**:有段时间 JDK 一直致力于 Reactor 响应式编程来提高 Java 性能,但响应式编程难以理解、调试、使用,最终又回到了同步编程,最终虚拟线程诞生。 +```bash +jcmd Thread.dump_to_file -format=text thread-dump.txt +``` -## 虚拟线程的底层原理是什么? +JSON 格式更适合工具分析,尤其是虚拟线程数量很多时。 + +### 使用 JFR 观察虚拟线程事件 + +JFR 中和虚拟线程相关的事件包括: + +- `jdk.VirtualThreadStart` +- `jdk.VirtualThreadEnd` +- `jdk.VirtualThreadPinned` +- `jdk.VirtualThreadSubmitFailed` + +其中 `jdk.VirtualThreadPinned` 对排查 Pinning 很有用。JDK 24 以后,`synchronized` 相关 Pinning 大多被解决,但 native/FFM 等剩余场景仍然可以通过 JFR 观察。 + +### 临时打开 Pinning 栈追踪 + +在 JDK 21 到 JDK 23 中,可以临时使用: + +```bash +-Djdk.tracePinnedThreads=full +``` + +它会在虚拟线程阻塞且被固定时打印调用栈,适合本地或测试环境定位问题。JDK 24 的 JEP 491 之后,这个参数已经不再需要,设置也不会产生效果。 + +## 虚拟线程常见面试题 + +### 虚拟线程和平台线程的区别是什么? + +平台线程通常和操作系统线程一一对应,创建和上下文切换成本较高,数量有限。虚拟线程由 JDK 调度,可以把大量虚拟线程映射到少量平台线程上。虚拟线程阻塞等待 I/O 时,通常可以从载体线程卸载,让平台线程继续执行其他虚拟线程。 + +### 虚拟线程为什么适合 I/O 密集型任务? + +I/O 密集型任务大部分时间在等待外部资源。平台线程等待时会占住操作系统线程;虚拟线程等待时可以挂起自己并释放载体线程。这样同样数量的平台线程可以承载更多并发任务。 + +### 虚拟线程适合 CPU 密集型任务吗? + +不适合把它当作 CPU 提速工具。CPU 密集型任务需要真实 CPU 时间,线程数超过核心数后只会增加调度竞争。虚拟线程能改善高并发等待,不会让单个计算任务更快。 + +### 虚拟线程需要池化吗? + +不需要,也不建议。虚拟线程便宜,应该按任务创建。需要限制并发时,限制具体资源,比如数据库连接池、HTTP 连接池、`Semaphore`、限流器,而不是池化虚拟线程。 + +### 虚拟线程和协程一样吗? + +它们都属于轻量级并发的思路,但 Java 虚拟线程是 `java.lang.Thread` 的实现,纳入了 Java 原有线程模型。业务代码不需要写 `async/await`,也不需要手动 yield。对开发者来说,它更像“便宜很多的线程”。 + +### 使用虚拟线程后还需要 Reactive 编程吗? + +看场景。很多同步阻塞的服务端接口可以用虚拟线程获得更好的可读性和足够的吞吐,不必为了释放线程写复杂回调链。但 Reactive 仍然适合流式处理、背压、事件驱动、长连接和已经全链路异步化的系统。虚拟线程不是替代所有异步模型的银弹。 + +### JDK 21 里的 `synchronized` 还能不能用? + +可以用,但要注意边界。JDK 21 到 JDK 23 中,虚拟线程在 `synchronized` 内部执行阻塞操作可能出现 Pinning。短小的内存同步问题不大,高频路径上不要持有 `synchronized` 锁执行慢 I/O。JDK 24 通过 JEP 491 改进后,`synchronized` 相关 Pinning 已经基本解决。 -如果你想要详细了解虚拟线程实现原理,推荐一篇文章:[虚拟线程 - VirtualThread 源码透视](https://www.cnblogs.com/throwable/p/16758997.html)。 +## 参考资料 -面试一般是不会问到这个问题的,仅供学有余力的同学进一步研究学习。 +- [JEP 444: Virtual Threads](https://openjdk.org/jeps/444) +- [Oracle Java 21 Documentation: Virtual Threads](https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html) +- [JEP 491: Synchronize Virtual Threads without Pinning](https://openjdk.org/jeps/491) +- [Spring Boot Reference Documentation: Virtual threads](https://docs.spring.io/spring-boot/reference/features/spring-application.html#features.spring-application.virtual-threads) +- [Spring Blog: Embracing Virtual Threads](https://spring.io/blog/2022/10/11/embracing-virtual-threads/) +- [Inside Java: Managing Throughput with Virtual Threads](https://inside.java/2024/02/04/sip094/) +- [Quarkus Blog: When Quarkus meets Virtual Threads](https://quarkus.io/blog/virtual-thread-1/) diff --git "a/\346\223\215\344\275\234\347\263\273\347\273\237\344\270\223\351\242\230\344\274\230\345\214\226\345\273\272\350\256\256.md" "b/\346\223\215\344\275\234\347\263\273\347\273\237\344\270\223\351\242\230\344\274\230\345\214\226\345\273\272\350\256\256.md" new file mode 100644 index 00000000000..ddbbb9597b6 --- /dev/null +++ "b/\346\223\215\344\275\234\347\263\273\347\273\237\344\270\223\351\242\230\344\274\230\345\214\226\345\273\272\350\256\256.md" @@ -0,0 +1,199 @@ +# 操作系统专题优化建议 + +> 评审范围:`docs/cs-basics/operating-system/` 目录下的 8 篇文章 +> 评审视角:技术正确性、内容一致性、读者体验、可维护性、SEO 与无障碍 + +本文先给出一个整体判断,再按"全局问题"和"逐篇问题"两条线展开,最后给一份可以直接照着做的改进清单。所有问题都尽量标到具体文件和行号,方便直接定位。 + +--- + +## 一、整体判断 + +这个专题目前可以分成两档: + +**第一档(高质量,几乎可以当范本)**: + +- `virtual-memory.md`(虚拟内存详解) +- `io-multiplexing.md`(I/O 多路复用详解) +- `zero-copy.md`(零拷贝详解) + +这三篇是明显经过重写的,特点是:痛点开场、循循善诱、技术细节扎实(五级页表与 LA57、Belady 异常的栈性质、epoll 红黑树/就绪链表、SG-DMA、splice 两次系统调用等),而且大量主动纠正了网上流传的错误说法(比如"epoll 靠 mmap 共享内存省拷贝"是错的)。这一档的"信噪比"很高。 + +**第二档(偏传统罗列式,存在时效性与体验问题)**: + +- `operating-system-basic-questions-01.md`(面试题上) +- `operating-system-basic-questions-02.md`(面试题下,已部分改写) +- `linux-intro.md`(Linux 基础) +- `shell-intro.md`(Shell 基础) + +核心矛盾就在这里:**第一档和第二档之间存在明显的"风格代差"和"质量落差"**,读者从专题文章跳回基础文章时,体验是割裂的。 + +--- + +## 二、全局问题(跨文章) + +### 1. 第一人称称谓不统一(建议优先修) + +写作风格要求行文自称 **"Guide"**,但实际文中出现了三种叫法: + +- `virtual-memory.md` 第 41 行、第 236 行附近自称 **"小 G"**。 +- `zero-copy.md` 第 19 行自称 **"小 G"**。 +- 其余文章基本是无人称的客观叙述。 + +**建议**:统一为 "Guide"(或统一去掉第一人称代称),避免同一专题里人设漂移。 + +### 2. 头尾 include 片段不统一 + +- 面试题上篇(`-01.md`)开头是 ``,**没有** `@include: @article-header.snippet.md`。 +- 面试题下篇(`-02.md`)开头用了 `@include: @article-header.snippet.md`。 +- 三篇专题(虚拟内存、I/O、零拷贝)和两篇基础(Linux、Shell)**都没有** header/footer include。 +- 但 `-01.md`、`-02.md`、`linux-intro.md`、`README.md` 又都有 `@article-footer.snippet.md`。 + +**建议**:明确一个规范——所有正式文章统一加 header + footer 片段,或统一不加。当前这种"有的有、有的无"的状态会让站点页脚(赞赏、版权、相关推荐等)时有时无。 + +### 3. 概览篇与专题篇内容高度重复,存在双重维护成本 + +`-02.md` 里的"虚拟内存""I/O 多路复用""零拷贝"三节,和三篇专题文章在结论、图片、措辞上高度重叠(很多句子几乎一字不差)。 + +这本身是合理的设计(概览 + 详解 + 末尾"详细介绍"链接),但风险在于:**一旦某个技术结论需要修订,要同时改两处,很容易漏改导致前后矛盾。** + +**建议**: + +- 明确边界:概览篇只保留"结论 + 一张图 + 一句话适用场景",把推导、代码、边界条件全部交给专题篇。 +- 在概览篇相应小节顶部用注释标注"本节为 xxx.md 的精简版,修改请同步",降低漏改概率。 + +### 4. 图片 alt 文案两极分化(影响 SEO 与无障碍) + +新专题文章的图片 alt 写得非常好(例如"缺页中断处理流程:MMU 发现页不在内存后……"),但老内容里大量图片是空 alt: + +- `-01.md` 第 28 行 `![](...image-20200807161118901.png)` +- `-01.md` 第 172 行 `![](...wechat-factory....png)` +- `-01.md` 第 304 行死锁图用了 `` 裸标签且无 alt +- `linux-intro.md` 第 85、246、250、302 行等多处 `![](./images/...)` 空 alt + +**建议**:给所有空 alt 的图片补上描述性文案,既利于 SEO,也利于无障碍访问和图片加载失败时的兜底。 + +### 5. 风格代差 + +`virtual-memory.md` / `io-multiplexing.md` / `zero-copy.md` 用的是"痛点开场 + 跨界隐喻 + 踩坑预警 + 面试怎么答"的现代风格;而 `linux-intro.md` 和 `shell-intro.md` 前半段仍是"命令罗列 + 平铺直叙"。 + +**建议**:至少给 `linux-intro.md`、`shell-intro.md` 补一个"痛点式开头"和"末尾要点回顾",向高质量三篇靠拢,保证专题内体验一致。 + +--- + +## 三、逐篇问题 + +### `linux-intro.md`(问题最集中,建议重点修) + +这篇时效性问题最严重,有几个是事实性错误: + +1. **CentOS 推荐已过时(重要)**:第 51~54 行推荐初学者用 CentOS,理由是"免费、基于 RHEL、稳定"。但 CentOS Linux 8 已于 2021 年底 EOL,CentOS 项目已转向 CentOS Stream(上游滚动发行,定位变了)。继续向初学者无条件推荐 CentOS 会误导。 + **建议**:改为推荐 Rocky Linux / AlmaLinux(RHEL 兼容、社区接棒),或 Ubuntu LTS / Debian,并简单说明 CentOS 的现状变化。 + +2. **命令笔误(bug)**:第 190 行 `find /home -i name "*.txt"`,正确写法是 `find /home -iname "*.txt"`(`-iname` 是一个整体参数,中间不能有空格)。 + +3. **`chkconfig` 已过时**:第 310~311 行用 `chkconfig --add/--list` 演示开机自启。现代发行版基本是 systemd,应改用 `systemctl enable` 并注明 `chkconfig` 属于 SysV init 时代。 + +4. **环境变量加载顺序描述过于绝对(准确性)**:第 380 行给出 `/etc/environment` --> `/etc/profile` --> ... --> `~/.bashrc` 的固定顺序。实际上登录 shell 与非登录/交互 shell 的加载路径不同,`~/.bash_profile` 与 `~/.bashrc` 的触发条件也不同。建议补一句"加载顺序取决于是否登录 shell、交互 shell",避免读者照搬出错。 + +5. **inode 与扇区表述可更精确**:第 72 行"现代硬盘扇区通常为 4KB"——传统是 512 字节,现代盘有 512e / 4Kn 之分,可稍作区分。 + +6. **缺少常用现代排障命令**:已经提到了 `ss` 替代 `netstat`、`ip` 替代 `ifconfig`,但日志排障少了 `journalctl`(systemd 日志),可以补上。 + +7. **结构上缺"版本说明/痛点开头/要点回顾"**:和 `shell-intro.md` 的"版本说明"以及专题三篇的开头不对称。 + +### `shell-intro.md`(内容很全,但深浅严重不均) + +1. **深浅断层(核心体验问题)**:文章定位是"带你入门 Shell",前半段是 HelloWorld、变量、字符串,非常入门;但从"生产环境最佳实践"开始,突然跳到指数退避 + 随机抖动、flock 脑裂(还配了 mermaid 时序图)、iptables 故障注入、NFS 一致性压测——这些是偏 SRE/资深运维的内容。跨度太大。 + **建议**:要么把"生产环境最佳实践 / 故障演练"独立成一篇进阶文章(如《Shell 脚本生产实践》),入门篇只留指针;要么在该章节前明确标注"以下为进阶内容,初学者可先跳过"。 + +2. **可移植性 bug(与文章主张自相矛盾)**:第 970 行 `sleep "${delay}e-6"`。文章通篇强调可移植性,但这里依赖 `sleep` 接受科学计数法 `e-6`——GNU coreutils 的 sleep 支持小数秒,但科学计数法并不可靠,BSD/macOS 的 sleep 连小数都不支持。建议改成毫秒转秒的普通小数,或直接用整数秒退避。 + +3. **示例与"始终加双引号"的建议自相矛盾**:文章在最佳实践里强调"始终用双引号包裹变量",但前面大量示例没加引号,例如: + + - 第 482 行字符串运算符表 `[ $a = $b ]`、`[ -z $a ]` + - 关系运算符示例中的变量引用 + **建议**:把入门示例也统一加上双引号,做到言行一致,否则初学者会照着没加引号的版本学。 + +4. **`expr` 与 GNU 扩展的提示已经做得不错**(第 224 行对 `expr length` 非 POSIX 的提醒很到位),这点值得保持。 + +### `operating-system-basic-questions-01.md`(面试题上) + +整体质量不错,用户态/内核态、死锁部分写得很好。零散问题: + +1. **"局部性原理(2-8 原则)"表述不严谨**:第 21 行把局部性原理直接等同于二八原则。两者相关但不等价,建议措辞上区分开。 + +2. **"事件(Event)"同步方式描述偏弱**:第 214 行"事件(Event):Wait/Notify……"这一条比较含糊,且容易和 Java 的 `Object.wait/notify` 混淆。建议要么讲清楚(条件变量 condition variable 的语义),要么和上面的几种同步原语统一粒度。 + +3. **外链稳定性**:第 245 行进程间通信引用了简书链接、第 415 行银行家算法引用 CSDN。这类站点链接腐烂率较高,建议要么改引更稳定的来源,要么把核心内容内化进正文。 + +4. **图片路径归类**:第 257 行进程调度算法图 URL 在 `.../cs-basics/network/scheduling-algorithms-of-process.png`(放在 network 目录下而非 operating-system)。不影响显示,但归类不当,长期维护时容易找不到。 + +5. **header include 缺失**:见全局问题第 2 点。 + +### `operating-system-basic-questions-02.md`(面试题下) + +这篇已经做过较好的改写,质量较高。剩余问题: + +1. **与三篇专题重复**:见全局问题第 3 点,这是最需要关注的。 + +2. **段页式管理偏简略**:第 327~338 行段页机制讲得比较快,可补一张图或对照专题里更完整的版本。 + +3. **SLAB 一笔带过**:第 65 行"由于这部分内容不是本篇文章的重点,这里就不详细介绍了"。可以补一句话点明 SLAB 解决的是"小对象频繁分配"的内部碎片,给读者一个完整闭环,而不是戛然而止。 + +4. **磁盘调度算法缺少直观示例**:第 475~490 行 6 种算法讲解清晰,但没有一个具体的磁道访问序列示例(如给定请求序列 + 当前磁头位置,对比各算法的寻道总距离),读者较难形成直观感受。 + +### `virtual-memory.md`(高质量) + +几乎没有硬伤,只有锦上添花的小建议: + +1. 自称"小 G",统一为 Guide(全局问题第 1 点)。 +2. 五级页表、LA57、Belady 栈性质这些细节非常出彩,建议保持。 +3. 末尾"面试里怎么答"是亮点,可以考虑把这个范式复制到其他篇。 + +### `io-multiplexing.md`(高质量) + +1. C10K 痛点开场、五种 I/O 模型定位、epoll 内核结构(红黑树 + 就绪链表 + 回调)讲解都很到位。 +2. 主动纠正"epoll 靠 mmap 省拷贝"的误区(第 231 行)非常有价值。 +3. 唯一建议:补 footer include(全局问题第 2 点)。 + +### `zero-copy.md`(高质量) + +1. "先说清楚这本账的前提"那段把简化模型的假设摆明,非常专业,避免了"几次拷贝"被当成放之四海的常数。 +2. 自称"小 G",统一为 Guide。 +3. Rust zerocopy crate 的"另一回事"提醒很贴心,可保留。 + +### `README.md`(专题目录页) + +作为 landing page 质量很好:适合谁看、学习重点、阅读顺序、高频问题、相关专题结构完整,SEO 友好。无需大改,仅需在新增/拆分文章后同步更新链接列表。 + +--- + +## 四、可执行改进清单(按优先级) + +**P0|事实性错误与 bug(应尽快修)** + +- [ ] `linux-intro.md` 更新 CentOS 推荐(改 Rocky/Alma/Ubuntu,并说明 CentOS 现状) +- [ ] `linux-intro.md` 修正 `find -i name` → `find -iname`(第 190 行) +- [ ] `linux-intro.md` `chkconfig` 改为 systemd 方案或加时代注明(第 310 行) +- [ ] `shell-intro.md` 修正 `sleep "${delay}e-6"` 的可移植性问题(第 970 行) + +**P1|一致性(影响专题整体观感)** + +- [ ] 统一第一人称为 "Guide"(virtual-memory.md、zero-copy.md) +- [ ] 统一 header/footer include 规范(全部 5+ 篇) +- [ ] `shell-intro.md` 入门示例统一加双引号,与自身最佳实践一致 +- [ ] `linux-intro.md` 环境变量加载顺序补充"登录/非登录 shell"前提 + +**P2|结构与体验** + +- [ ] 拆分 `shell-intro.md`:入门篇 + 生产实践进阶篇(或加"进阶内容"标注) +- [ ] 给 `linux-intro.md` / `shell-intro.md` 补痛点开头与要点回顾,对齐三篇专题风格 +- [ ] 明确概览篇(-02.md)与专题篇的内容边界,标注同步关系 +- [ ] 给所有空 alt 图片补描述文案 + +**P3|内容增强** + +- [ ] `-01.md` 厘清"局部性原理 vs 二八原则"、完善"事件同步"描述、替换易腐外链 +- [ ] `-02.md` 补段页式配图、SLAB 一句话闭环、磁盘调度寻道距离示例 +- [ ] `linux-intro.md` 补 `journalctl` 等现代排障命令 From 0cb5d7c27bc8445d77d026b5c0a538ca264bb5ec Mon Sep 17 00:00:00 2001 From: Guide Date: Thu, 11 Jun 2026 13:47:26 +0800 Subject: [PATCH 009/116] docs: add process thread and ipc guides --- README.md | 2 + docs/.vuepress/sidebar/cs-basics.ts | 8 + docs/cs-basics/README.md | 2 + docs/cs-basics/operating-system/README.md | 24 +- docs/cs-basics/operating-system/ipc.md | 149 ++++++++++++ .../operating-system-basic-questions-01.md | 127 +++++++--- .../operating-system-basic-questions-02.md | 18 +- .../operating-system/process-and-thread.md | 228 ++++++++++++++++++ 8 files changed, 512 insertions(+), 46 deletions(-) create mode 100644 docs/cs-basics/operating-system/ipc.md create mode 100644 docs/cs-basics/operating-system/process-and-thread.md diff --git a/README.md b/README.md index f3c74438816..4c3c6fd26d4 100755 --- a/README.md +++ b/README.md @@ -147,6 +147,8 @@ JVM 这部分内容主要参考 [JVM 虚拟机规范-Java8](https://docs.oracle. - [操作系统常见知识点&面试题总结(上)](./docs/cs-basics/operating-system/operating-system-basic-questions-01.md) - [操作系统常见知识点&面试题总结(下)](./docs/cs-basics/operating-system/operating-system-basic-questions-02.md) +- [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./docs/cs-basics/operating-system/process-and-thread.md) +- [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./docs/cs-basics/operating-system/ipc.md) - [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./docs/cs-basics/operating-system/virtual-memory.md) - [I/O 多路复用详解:select、poll、epoll 原理与区别](./docs/cs-basics/operating-system/io-multiplexing.md) - [零拷贝详解:mmap、sendfile 与 splice](./docs/cs-basics/operating-system/zero-copy.md) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index 35081e5ceae..3541f1de5c3 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -131,6 +131,14 @@ export const csBasics = [ { text: "⭐️零拷贝详解", link: "zero-copy" }, ], }, + { + text: "进程与线程", + icon: ICONS.STAR, + children: [ + { text: "⭐️进程与线程详解", link: "process-and-thread" }, + { text: "进程间通信(IPC)详解", link: "ipc" }, + ], + }, { text: "Linux", icon: ICONS.LINUX, diff --git a/docs/cs-basics/README.md b/docs/cs-basics/README.md index 82b862ae6f5..535b3de6718 100644 --- a/docs/cs-basics/README.md +++ b/docs/cs-basics/README.md @@ -67,6 +67,8 @@ head: - [操作系统专题](./operating-system/):从操作系统基础讲到 Linux 常见问题。 - [操作系统常见面试题总结(上)](./operating-system/operating-system-basic-questions-01.md):覆盖操作系统基础、进程线程、死锁、内存管理等问题。 - [操作系统常见面试题总结(下)](./operating-system/operating-system-basic-questions-02.md):继续整理文件系统、I/O、Linux 等面试考点。 +- [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./operating-system/process-and-thread.md):讲清进程和线程的资源边界、状态转换、上下文切换和 Java 虚拟线程。 +- [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./operating-system/ipc.md):对比管道、消息队列、共享内存、Socket、Binder 等 IPC 机制。 - [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./operating-system/virtual-memory.md):讲清分页、页表、TLB、缺页中断和页面置换。 - [I/O 多路复用详解:select、poll、epoll 原理与区别](./operating-system/io-multiplexing.md):讲清 select、poll、epoll 的实现原理、性能差异和适用场景。 - [零拷贝详解:mmap、sendfile 与 splice](./operating-system/zero-copy.md):讲清传统 I/O、mmap、sendfile、splice 的拷贝路径和工程应用。 diff --git a/docs/cs-basics/operating-system/README.md b/docs/cs-basics/operating-system/README.md index 73a40ad25fa..208733a380d 100644 --- a/docs/cs-basics/operating-system/README.md +++ b/docs/cs-basics/operating-system/README.md @@ -1,6 +1,6 @@ --- -title: 操作系统专题:进程线程、虚拟内存、I/O 多路复用、Linux 与 Shell -description: 操作系统面试与学习路线,涵盖进程线程、死锁、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 基础、Shell 编程和常见操作系统面试题。 +title: 操作系统专题:进程线程、IPC、虚拟内存、I/O 多路复用、Linux 与 Shell +description: 操作系统面试与学习路线,涵盖进程线程、进程间通信、死锁、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 基础、Shell 编程和常见操作系统面试题。 category: 计算机基础 tag: - 操作系统 @@ -13,10 +13,10 @@ sitemap: head: - - meta - name: keywords - content: 操作系统,操作系统面试题,进程,线程,死锁,内存管理,虚拟内存,零拷贝,I/O多路复用,select,poll,epoll,文件系统,Linux,Shell,后端面试 + content: 操作系统,操作系统面试题,进程,线程,进程间通信,IPC,死锁,内存管理,虚拟内存,零拷贝,I/O多路复用,select,poll,epoll,文件系统,Linux,Shell,后端面试 --- -这份 **操作系统专题** 面向后端学习和面试复习,整理操作系统基础、进程线程、内存管理、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 和 Shell 相关内容。 +这份 **操作系统专题** 面向后端学习和面试复习,整理操作系统基础、进程线程、进程间通信、内存管理、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 和 Shell 相关内容。 ## 适合谁看 @@ -28,7 +28,7 @@ head: ## 学习重点 - 操作系统负责管理 CPU、内存、文件、I/O 和进程,是理解上层软件运行机制的基础。 -- 进程和线程是并发编程、服务端性能和问题排查的基础概念。 +- 进程、线程和进程间通信是并发编程、服务端性能和问题排查的基础概念。 - 死锁、上下文切换、调度、同步互斥是面试高频点。 - 内存管理、虚拟内存、分页、页面置换能帮助理解 JVM、数据库和缓存。 - 零拷贝、I/O 多路复用能帮助理解 Kafka、RocketMQ、Redis、Nginx、Netty 等高性能组件。 @@ -38,16 +38,20 @@ head: 1. [操作系统常见面试题总结(上)](./operating-system-basic-questions-01.md):先建立操作系统基础、进程线程、死锁、内存管理的高频问题清单。 2. [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续补齐文件系统、I/O、Linux 等问题。 -3. [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):把分页、页表、TLB、缺页中断和页面置换串起来。 -4. [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):理解一个线程处理海量连接背后的内核机制。 -5. [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):搞清传统 I/O、mmap、sendfile、splice 的拷贝路径和适用场景。 -6. [Linux 基础知识总结](./linux-intro.md):掌握目录结构、文件权限、常用命令和基础排障能力。 -7. [Shell 编程基础知识总结](./shell-intro.md):学习变量、条件、循环、函数和常用脚本写法。 +3. [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./process-and-thread.md):系统理解进程、线程、PCB/TCB、fork/exec/wait、线程模型和上下文切换。 +4. [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md):对比管道、消息队列、共享内存、信号量、Socket、Binder 等 IPC 方案。 +5. [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):把分页、页表、TLB、缺页中断和页面置换串起来。 +6. [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):理解一个线程处理海量连接背后的内核机制。 +7. [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):搞清传统 I/O、mmap、sendfile、splice 的拷贝路径和适用场景。 +8. [Linux 基础知识总结](./linux-intro.md):掌握目录结构、文件权限、常用命令和基础排障能力。 +9. [Shell 编程基础知识总结](./shell-intro.md):学习变量、条件、循环、函数和常用脚本写法。 ## 核心文章 - [操作系统常见面试题总结(上)](./operating-system-basic-questions-01.md):覆盖操作系统基础、进程线程、死锁、内存管理等高频问题。 - [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续整理文件系统、I/O、多路复用、Linux 等知识点。 +- [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./process-and-thread.md):讲清进程和线程的资源边界、状态转换、Linux 创建机制和 Java 虚拟线程。 +- [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md):讲清常见 IPC 方式的原理、优缺点和选型思路。 - [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):讲清虚拟地址、物理地址、分页、多级页表、TLB、缺页中断和页面置换算法。 - [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):讲清网络 I/O 的两个阶段、五种 I/O 模型,以及 select、poll、epoll 的区别。 - [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):讲清零拷贝到底省掉了什么,以及 Java NIO、Kafka、RocketMQ 中的典型应用。 diff --git a/docs/cs-basics/operating-system/ipc.md b/docs/cs-basics/operating-system/ipc.md new file mode 100644 index 00000000000..8f7dcd24c4d --- /dev/null +++ b/docs/cs-basics/operating-system/ipc.md @@ -0,0 +1,149 @@ +--- +title: 进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder +description: 进程间通信高频知识点总结,从进程地址空间隔离讲起,讲清管道、消息队列、共享内存、信号量、信号、Socket、Android Binder 和微内核 IPC 的设计取舍。 +category: 计算机基础 +tag: + - 操作系统 + - Linux + - IPC +head: + - - meta + - name: keywords + content: 进程间通信,IPC,Linux IPC,管道,FIFO,消息队列,共享内存,信号量,信号,Socket,Unix Domain Socket,Android Binder,微内核 IPC,操作系统面试题 +--- + +两个进程想交换一段数据,最直觉的想法是:A 进程把数据写到自己的内存里,然后 B 进程直接去读就行了。 + +不过,这在操作系统里行不通。每个进程都有独立的虚拟地址空间,A 进程里的 `0x7f...` 地址和 B 进程里的 `0x7f...` 地址并不是同一块内存。用户态进程之间不能随便互相摸内存,否则权限隔离也没法谈。 + +所以 **IPC(Inter-Process Communication,进程间通信)** 绕不开操作系统。 + +不要想的太复杂,我更习惯把 IPC 看成三件事:**怎么传数据、怎么同步控制流、怎么做命名和权限检查**。只记“管道、消息队列、共享内存”这些名字,很容易背完就忘。 + +![进程地址空间隔离导致进程间通信需要借助内核提供的 IPC 机制](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-why-ipc.png) + +## IPC 到底在解决什么? + +![IPC 需要同时解决数据传递、同步控制、命名寻址和权限检查等问题](https://oss.javaguide.cn/github/javaguide/java/new-features/what-problem-does-ipc-solve.png) + +**IPC 先解决数据怎么过去。** 管道和字节流 Socket 传连续字节,消息边界由应用约定;消息队列、数据报 Socket、Binder 事务传一条条消息,天然有边界;共享内存让多个进程映射同一块物理内存,映射完成后读写共享区域不需要每次陷入内核。 + +**它还要解决同步。** 共享内存只解决“看见同一份数据”,不解决“谁先写、谁后读”。多个进程同时改同一个环形队列,如果没有互斥锁、信号量、futex 或条件变量,数据很快就会乱。 + +**命名和权限也不能少。** 匿名管道靠 `fork` 后继承文件描述符建立关系;FIFO 靠文件系统路径;System V IPC 靠 key 和内核对象 ID;Unix Domain Socket 可以绑定路径,也可以用 Linux 的 abstract namespace;Android Binder 借助 Service Manager 把服务名映射到 Binder 引用。 + +## 管道:字节流,简单,但边界少 + +管道(pipe)是最容易遇到的 IPC。Shell 里的 `ps aux | grep java`,中间那个 `|` 就是把前一个进程的标准输出接到后一个进程的标准输入。 + +Linux 里调用 `pipe()` 会得到两个文件描述符:一个读端,一个写端。父进程创建管道后再 `fork()`,子进程会继承这些文件描述符,于是父子进程就能靠同一条管道传数据。匿名管道没有名字,通常用于有亲缘关系的进程之间。 + +![管道通过内核缓冲区在父进程和子进程之间传递单向字节流](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-pipe-flow.png) + +管道是单向字节流。POSIX 只要求它单向,双向通信通常建两条管道;它不理解消息边界,写端写了 3 次,读端不一定也读 3 次;缓冲区在内核里,写满后阻塞写会睡眠,非阻塞写可能返回 `EAGAIN`;它也不是普通文件,不能用 `lseek()` 随机定位。 + +Linux 上还有一个容易被问到的数字:`PIPE_BUF` 是 4096 字节。对管道或 FIFO 来说,单次 `write()` 不超过 `PIPE_BUF` 时,内核保证这次写入不会和其他写者的数据交错;阻塞模式下可能等待缓冲区空间,非阻塞模式下如果空间不足会返回 `EAGAIN`。超过 `PIPE_BUF` 的写入可能被拆分,也可能和其他写者的数据交错。这个保证不代表管道有消息边界。 + +命名管道(FIFO)用 `mkfifo` 在文件系统里创建一个特殊文件,两个无亲缘关系的进程按路径打开它就能通信。FIFO 有路径名,但数据并不是写进磁盘;路径只是命名入口,真正的数据仍在内核缓冲区里。 + +管道适合命令行工具串联、父子进程传少量数据。它不适合复杂协议和大对象传输。真要在字节流上做长度前缀、校验和、序列号,很多场景下不如换 Socket 或消息队列。 + +## 消息队列:内核保存消息,应用少处理切包 + +消息队列把数据拆成一条条消息存到内核对象里。发送方调用 `msgsnd()` 或 `mq_send()` 把消息放进队列,接收方调用 `msgrcv()` 或 `mq_receive()` 取出来。System V 消息队列和 POSIX 消息队列接口不同,但都属于“内核持有队列,进程按消息读写”的方案。 + +和管道相比,消息队列最直接的好处是**消息有边界**。System V 消息队列支持按消息类型接收;POSIX 消息队列支持优先级,Linux 上 `sysconf(_SC_MQ_PRIO_MAX)` 常见返回值是 32768,而 POSIX 标准只要求至少支持 0 到 31 这个范围。 + +代价也很直接:发送时,应用缓冲区的数据被拷进内核队列;接收时,再从内核队列拷回接收进程的用户缓冲区。队列本身也受内核参数限制,比如 POSIX 消息队列有 `/proc/sys/fs/mqueue/msg_max`、`msgsize_max` 等限制项。 + +所以消息队列适合传结构化小消息,比如任务通知、状态事件、控制命令。它不适合传大块图片、音视频帧或超大的序列化对象。Linux IPC 里的消息队列也不是 Kafka、RocketMQ 那种消息中间件,没有持久化日志、消费组和跨机器复制。 + +## 共享内存:少拷贝,但同步要自己负责 + +共享内存的思路很直接:让多个进程把同一块物理内存映射到各自的虚拟地址空间里。映射建立之后,A 进程写这块内存,B 进程就能读到更新。 + +Linux 上常见两类接口:System V 共享内存用 `shmget()`、`shmat()`、`shmdt()`、`shmctl()`;POSIX 共享内存用 `shm_open()` 创建对象,`ftruncate()` 设置大小,再用 `mmap()` 映射到进程地址空间。 + +![共享内存让多个进程映射同一块物理内存,但仍需要信号量、futex 等同步机制配合](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-shared-memory.png) + +共享内存快在数据路径短。管道、消息队列、Socket 这类方式通常要把数据先交给内核,再由内核交给另一个进程;共享内存完成映射后,进程读写的是同一片物理页,数据本身不用每次都在用户态和内核态之间搬来搬去。日志采集、音视频处理、数据库缓存这类本机大块数据交换场景,才比较适合把它拿出来用。 + +不过,映射同一块内存只解决“能不能看见”的问题,不解决“什么时候能读”和“谁可以写”的问题。 + +以共享环形队列为例,生产者通常会写数据、更新 `tail`,消费者根据 `head` 和 `tail` 判断有没有新数据。如果生产者还没把一条记录写完整,就提前更新了 `tail`,消费者可能马上读到一条半成品。这个问题不能靠共享内存自己解决,需要把写入顺序、可见性和唤醒机制一起设计好:简单一点可以用进程间互斥锁、POSIX 信号量;追求性能时可能会用 `eventfd`、`futex`、原子变量和内存屏障。 + +还有一个细节很容易踩坑:共享内存里别直接放进程内指针。同一块共享内存在 A 进程里可能映射到 `0x7000...`,在 B 进程里可能映射到 `0x5000...`,A 写进去的地址,B 拿到后大概率没有意义。工程里更常见的写法是保存偏移量、数组下标,或者一开始就约定好固定布局结构。 + +所以共享内存不能只看拷贝次数。整体性能还会受缓存一致性、锁竞争、内存屏障、唤醒机制和数据布局影响。它适合数据量大、双方都在本机、并且愿意认真处理同步和内存布局的场景;如果只是传几个状态字段或一条控制命令,消息队列、管道、Unix Domain Socket 反而更省心。 + +## 信号量和信号有什么区别? + +信号量(semaphore)经常和共享内存一起出现,但它不负责传业务数据。它更像一个计数器,用来控制有多少进程可以进入某段临界区,或者通知对方“现在有数据可读”。POSIX 信号量可以是命名的,也可以是未命名的;`sem_post()` 会把计数加一,`sem_wait()` 会尝试把计数减一,计数为 0 时调用方会阻塞等待。 + +信号(signal)更像异步事件通知:`SIGINT` 表示终端中断,`SIGTERM` 表示请求进程退出,`SIGCHLD` 表示子进程状态变化。Linux 支持标准信号和实时信号。信号能携带的信息少,处理函数也受 async-signal-safe 限制,生产代码里常让 signal handler 只修改 `volatile sig_atomic_t` 标志位,或者通过 async-signal-safe 的 `write(2)` 往 self-pipe 写一个字节、往 eventfd 写一个 `uint64_t` 计数值,再由主循环统一处理。 + +## Socket:本机和跨机器都能用 + +Socket 不只用于网络通信,也能做本机 IPC。 + +如果两个进程在不同机器上,基本就得走 TCP/UDP 这类网络 Socket。如果两个进程在同一台机器上,可以用 Unix Domain Socket。它的地址族是 `AF_UNIX` 或 `AF_LOCAL`,支持 `SOCK_STREAM`、`SOCK_DGRAM`、`SOCK_SEQPACKET` 等类型。 + +Unix Domain Socket 的接口接近网络 Socket,支持无亲缘关系进程通信;Linux 下既可以绑定文件系统路径,也可以使用 abstract namespace。它还可以借助 `sendmsg()` 的辅助数据和 `SCM_RIGHTS` 传文件描述符。对端身份这块,连接型 Unix Socket 常用 `SO_PEERCRED` 获取 pid、uid、gid;数据报场景也可以结合 `SO_PASSCRED` 和 `SCM_CREDENTIALS` 让凭据随消息传过来。 + +如果问“管道和 Unix Domain Socket 怎么选”,小 G 一般会这么答:父子进程之间的简单字节流,用管道就够;要双向通信、请求响应、传 fd、服务端监听,Unix Domain Socket 更合适;要跨机器,换 TCP/UDP 或更上层的 RPC 框架。 + +## Android Binder:把 IPC 做成系统服务调用 + +![Android Binder 通过 AIDL、Parcel、Binder 驱动和 Service Manager 将 IPC 封装成系统服务调用](https://oss.javaguide.cn/github/javaguide/java/new-features/android-binder-turning-ipc-into-system-service-calls.png) + +Android 里最典型的 IPC 是 Binder。应用调用系统服务、不同进程里的 Service 交互、AIDL 生成的远程接口,底层都离不开它。 + +Binder 有几个设计点值得单独看。AIDL 让客户端和服务端约定接口,Android 工具链生成参数编解码和代理代码;客户端像在调本地方法,实际会把参数打包成 Parcel,交给 Binder 驱动完成跨进程事务。系统里的 Service Manager 会向 Binder 驱动注册为 context manager,负责维护服务名到 Binder 引用的映射。 + +Binder 事务里可以携带 Binder 对象、handle、fd 等特殊对象。fd 传递让 Binder 可以和共享内存配合:Binder 传控制消息和句柄,大块数据放到共享内存里。Android 官方 AIDL 文档也提醒过:远程调用会从平台维护的 Binder 线程池分发进服务进程,服务实现必须考虑线程安全。 + +Binder 也不是拿来塞大对象的通道。Android 的 `TransactionTooLargeException` 文档写得很明确:Binder transaction buffer 当前是 1 MB,并且由进程内正在进行的事务共享。这个异常本身也是启发式判断:客户端无法准确知道失败发生在请求发送阶段,还是响应返回阶段。更稳的做法是让 Binder 传小请求、分页结果、fd 或资源标识。 + +## 微内核为什么特别在意 IPC? + +Linux 这种宏内核把文件系统、网络协议栈、驱动等大量能力放在内核里。微内核会把尽可能多的服务移到用户态进程,比如文件系统服务、驱动服务、网络服务。隔离性更好,但 IPC 会变得非常频繁。 + +应用读一个文件,在宏内核里可能主要是一次系统调用进内核;在微内核里,可能要和文件系统服务、块设备服务多次通信。IPC 慢一点,整个系统都跟着慢。 + +所以微内核论文和系统实现里,IPC 优化一直是重点。 + +Mach 的代表设计是 port。port 可以理解成受内核保护的消息队列和能力句柄:任务持有某个 port right,才可以向对应对象发送或接收消息。L4 家族则尽量把常见 IPC 做短:短消息用寄存器传参,同步 IPC 采用 rendezvous 风格,直接进程切换(direct process switch)避免某些路径绕一圈调度器。LRPC(Lightweight Remote Procedure Call)也在做同一件事:减少同机跨保护域调用里的线程、缓冲和调度开销。 + +## 常见 IPC 怎么选? + +选型时别只问“哪个最快”。更好的问题是:数据有多大?需不需要消息边界?通信双方有没有亲缘关系?要不要双向请求响应?要不要跨机器?要不要权限校验和身份识别? + +| IPC 方式 | 数据形态 | 是否保留消息边界 | 是否适合大数据 | 是否跨机器 | 典型场景 | +| ------------------ | ---------------------- | ---------------- | ------------------ | ---------------- | ---------------------- | +| 匿名管道 | 字节流 | 否 | 不适合 | 否 | 父子进程、Shell 管道 | +| FIFO | 字节流 | 否 | 不适合 | 否 | 无亲缘关系进程简单通信 | +| 消息队列 | 消息 | 是 | 不适合 | 否 | 控制命令、状态事件 | +| 共享内存 | 共享区域 | 由应用定义 | 适合 | 否 | 大块本机数据交换 | +| Unix Domain Socket | 字节流、数据报、顺序包 | 取决于类型 | 中等 | 否 | 本机服务监听、传 fd | +| TCP/UDP Socket | 字节流或数据报 | 取决于协议 | 取决于协议和实现 | 是 | 跨机器通信 | +| Binder | 事务、对象引用、fd | 是 | 不适合直接传大对象 | 否,Android 本机 | Android 系统服务调用 | + +![常见 IPC 方式在数据形态、消息边界、大数据传输和跨机器能力上的横向对比](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-ipc-comparison.png) + +父子进程之间传少量字节流,管道够用;无亲缘关系进程需要双向请求响应,Unix Domain Socket 更顺手;小型结构化事件可以用消息队列;大块数据优先考虑共享内存加同步通知;跨机器通信交给 TCP/UDP 或更上层的 RPC;Android 应用跨进程调用则通常走 Binder。 + +![根据数据量、消息边界、跨机器和进程亲缘关系选择合适的 IPC 方式](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-ipc-selection.png) + +## 面试里怎么答 IPC? + +可以这样回答:进程默认不能直接访问彼此的用户态地址空间,所以 IPC 要么让内核代收代发数据,要么让内核创建一份可共享的对象或内存映射。 + +沿着这条线看,管道、FIFO、Socket 主要传字节流,消息边界通常要由应用协议处理;消息队列保留消息边界,适合较小的任务消息、状态变化和控制命令;共享内存把同一批物理页映射给多个进程,适合本机大块数据交换,但同步和内存布局要自己处理;信号偏事件通知,信号量、互斥锁、`futex` 这类机制更多是配合共享数据做同步。Android Binder 可以看作面向系统服务的本机 RPC/事务通道,常用于跨进程服务调用。 + +真正做选择时,不是看名字熟不熟,而是看数据量、消息边界、通信范围、双方关系和权限校验。比如父子进程串联命令,管道就够;本机服务要双向请求响应,还想传 fd,Unix Domain Socket 更合适;跨机器通信再考虑 TCP/UDP 或上层 RPC。 + +如果继续追问“共享内存为什么还需要信号量”,可以这样答:共享内存只是让两个进程看到同一块数据,不保证访问顺序。谁先写、谁后读、写到一半能不能读,都要靠信号量、进程间互斥锁、`futex`、`eventfd` 这类机制约束。 + +如果追问“Binder 为什么不适合传大对象”,可以补上 Android 官方文档里的 1 MB 事务缓冲限制,并说明这个缓冲由进程内进行中的事务共享。Binder 更适合传方法参数、返回值、对象引用和 fd;大块数据应该拆分、分页,或用共享内存传递。 + +小 G 自己记 IPC 时不会把它背成一串名词,而是先问这几个问题:数据大不大?要不要保留消息边界?通信双方是不是都在本机?要不要双向请求响应?同步和权限谁来管?这些问题答完,方案基本也就出来了。 diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md index c44c65c0762..9875eb9762e 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md @@ -1,27 +1,24 @@ --- -title: 操作系统常见面试题总结(上) -description: 最新操作系统高频面试题总结(上):用户态/内核态切换、进程线程区别、死锁四条件、系统调用详解、调度算法对比,附图表+⭐️重点标注,一文掌握OS核心考点,快速通关后端技术面试! +title: 操作系统常见面试题总结(上) +description: 最新操作系统高频面试题总结(上):用户态/内核态切换、进程线程区别、进程状态、PCB/TCB、进程间通信 IPC、fork/exec/wait、死锁四条件、系统调用和调度算法,一文掌握 OS 核心考点。 category: 计算机基础 tag: - 操作系统 head: - - meta - name: keywords - content: 操作系统面试题,用户态 vs 内核态,进程 vs 线程,死锁必要条件,系统调用过程,进程调度算法,PCB进程控制块,进程间通信IPC,死锁预防避免,操作系统基础高频题,虚拟内存管理 + content: 操作系统面试题,用户态 vs 内核态,进程 vs 线程,进程状态,PCB,TCB,fork,exec,wait,进程间通信IPC,进程调度算法,死锁必要条件,死锁预防避免,操作系统基础高频题 --- -很多读者抱怨计算操作系统的知识点比较繁杂,自己也没有多少耐心去看,但是面试的时候又经常会遇到。所以,我带着我整理好的操作系统的常见问题来啦!这篇文章总结了一些我觉得比较重要的操作系统相关的问题比如 **用户态和内核态、系统调用、进程和线程、死锁、内存管理、虚拟内存、文件系统** 等等。 +很多读者抱怨计算操作系统的知识点比较繁杂,自己也没有多少耐心去看,但是面试的时候又经常会遇到。所以,我带着我整理好的操作系统的常见问题来啦! -这篇文章只是对一些操作系统比较重要概念的一个概览,深入学习的话,建议大家还是老老实实地去看书。另外,这篇文章的很多内容参考了《现代操作系统》第三版这本书,非常感谢。 +这篇《操作系统常见面试题总结(上)》会先从操作系统基础讲起,再重点梳理 **用户态/内核态、系统调用、进程和线程、进程间通信、进程调度、死锁** 这些高频考点。它适合用来快速建立面试问题清单,也适合作为复习时查漏补缺的入口。 -开始本文的内容之前,我们先聊聊为什么要学习操作系统。 +学习操作系统不只是为了背八股。缓存、调度、同步、内存映射、零拷贝、I/O 多路复用这些思想,在 Redis、Kafka、Nginx、Netty、JVM、数据库里都能看到影子。把底层机制想清楚,再理解上层框架和线上性能问题,会轻松很多。 -- **从对个人能力方面提升来说**:操作系统中的很多思想、很多经典的算法,你都可以在我们日常开发使用的各种工具或者框架中找到它们的影子。比如说我们开发的系统使用的缓存(比如 Redis)和操作系统的高速缓存就很像。CPU 中的高速缓存有很多种,不过大部分都是为了解决 CPU 处理速度和内存处理速度不对等的问题。我们还可以把内存看作外存的高速缓存,程序运行的时候我们把外存的数据复制到内存,由于内存的处理速度远远高于外存,这样提高了处理速度。同样地,我们使用的 Redis 缓存就是为了解决程序处理速度和访问常规关系型数据库速度不对等的问题。高速缓存通常会利用局部性原理:程序在一段时间内访问的数据往往集中在一小部分区域,这和二八原则有些相似,但两者不是同一个概念。很多淘汰算法都和操作系统中的类似。说到缓存,那就不得不提命中率了,这是所有缓存概念都通用的。简单来说也就是你要访问的数据有多少能直接在缓存中直接找到。命中率高的话,一般表明你的缓存设计比较合理,系统处理速度也相对较快。 -- **从面试角度来说**:尤其是校招,对于操作系统方面知识的考察是非常非常多的。 - -**简单来说,学习操作系统能够提高自己思考的深度以及对技术的理解力,并且,操作系统方面的知识也是面试必备。** +本文偏“面试速查 + 核心概念串联”,深入学习还是建议搭配教材和专题文章一起看。文中部分内容参考了《现代操作系统》第三版,在此表示感谢。 ## 操作系统基础 @@ -159,10 +156,17 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win ## 进程和线程 +进程和线程是操作系统面试里绕不开的一组概念。下面先给出高频问法的精简答案,想系统学习的话,可以继续阅读这两篇详细文章: + +- [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./process-and-thread.md),路径:`./process-and-thread.md` +- [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md),路径:`./ipc.md` + ### 进程和线程的区别是什么? 进程和线程是操作系统中并发执行的两个核心概念,它们的关系可以理解为 **工厂和工人** 的关系。 +![程序、进程和线程的关系](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/relationship-between-program-process-and-thread.png) + **进程(Process)就像一个工厂**。操作系统在分配资源时,是以进程为基本单位的。比如,当我启动一个微信,操作系统就为它建立了一个独立的工厂,分配给它专属的内存空间、文件句柄等资源。这个工厂与其他工厂(比如我打开的浏览器进程)是严格隔离的。 **线程(Thread)则像是工厂里的工人**。一个工厂里可以有很多工人,他们共享这个工厂的资源,但每个工人有自己的工具箱和任务清单,让他们可以独立地执行不同的任务。比如微信这个工厂里,可以有一个工人(线程)负责接收消息,一个工人负责渲染界面。 @@ -177,17 +181,30 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 从上图可以看出:一个进程中可以有多个线程,多个线程共享进程的**堆**和**方法区(JDK1.8 之后的元空间)**资源,但是每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**。 -这里从 3 个角度总结下线程和进程的核心区别: +![线程共享和私有的内容](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/thread-shared-and-private-content.png) -1. **资源所有权**:进程是资源分配的基本单位,拥有独立的地址空间;而线程是 CPU 调度的基本单位,几乎不拥有系统资源,只保留少量私有数据(PC、栈、寄存器),主要共享其所属进程的资源。 -2. **开销**:创建或销毁一个工厂(进程)的开销很大,需要分配独立的资源。而雇佣或解雇一个工人(线程)的开销就小得多。同理,进程间的上下文切换开销远大于线程间的切换。 -3. **健壮性**:工厂之间是隔离的,一个工厂倒闭(进程崩溃)不会影响其他工厂。但一个工厂内的工人之间是共享资源的,一个工人操作失误(比如一个线程访问了非法内存)可能会导致整个工厂停工(整个进程崩溃)。 +可以从资源、调度、通信、开销和可靠性这 5 个角度总结: + +| 维度 | 进程 | 线程 | +| ------------- | -------------------------------------------------- | ------------------------------------------------------- | +| 基本定位 | 资源分配和隔离的基本单位 | CPU 调度和执行的基本单位 | +| 地址空间 | 默认拥有独立虚拟地址空间 | 同一进程内的线程共享进程地址空间 | +| 私有内容 | PID、地址空间、打开文件表、权限信息等进程级资源 | 线程 ID、栈、寄存器、程序计数器、线程本地存储等执行现场 | +| 通信方式 | 需要 IPC,例如管道、消息队列、共享内存、Socket | 可以直接读写共享内存,但必须处理同步和线程安全 | +| 创建/切换成本 | 通常更高,进程切换可能涉及地址空间切换、TLB 失效等 | 通常更低,同进程线程切换一般不需要切换整套地址空间 | +| 故障影响 | 隔离性更好,一个进程崩溃通常不影响其他进程 | 一个线程出错可能导致整个进程退出 | + +比较完整的面试回答可以这样组织: + +> 进程是程序运行时的资源容器,拥有独立虚拟地址空间和文件、权限等资源;线程是进程内的执行流,多个线程共享进程资源,但各自保存栈、寄存器、程序计数器等执行现场。进程间隔离更强,通信和切换成本更高;线程间协作更方便,创建和切换通常更轻,但共享内存带来线程安全问题。 ### 有了进程为什么还需要线程? -核心原因就是**为了在单个应用内实现低开销、高效率的并发**。如果我想让微信同时接收消息和发送文件,如果用两个进程来实现,不仅资源开销巨大,它们之间通信还非常麻烦(需要 IPC)。而使用两个线程,它们不仅切换成本低,还能直接通过共享内存高效通信,从而能更好地利用多核 CPU,提升应用的响应速度和吞吐量。 +核心原因就是**为了在单个应用内实现低开销、高效率的并发**。 + +如果一个服务端要同时处理网络读写、业务计算、日志刷盘,用多个进程当然也能做,但进程之间共享状态麻烦,通信要走 IPC,资源占用也更高。改成多个线程后,它们能直接共享堆内存和打开的连接,只要同步写对,协作成本低很多。 -再拿我们上面举的工厂和工人为例:线程=同一屋檐下的轻量级工人,切换成本低、共享内存零拷贝;若换成两个独立进程,就得各建一座工厂(独立地址空间),既费砖又费电(资源与 IPC 开销)。 +线程也能提高资源利用率。单核 CPU 上,一个线程阻塞在磁盘或网络 I/O 时,其他线程可以继续运行;多核 CPU 上,多个线程有机会在不同核心上并行执行。不过,线程不是越多越好。线程过多会带来栈内存占用、调度开销、锁竞争和缓存失效等问题,CPU 密集型任务和 I/O 密集型任务的线程数配置也不一样。 ### 为什么要使用多线程? @@ -219,18 +236,24 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 当操作系统创建一个新进程时,会为该进程分配一个唯一的进程 ID,并且为该进程创建一个对应的进程控制块。当进程执行时,PCB 中的信息会不断变化,操作系统会根据这些信息来管理和调度进程。 -PCB 主要包含下面几部分的内容: - -- 进程的描述信息,包括进程的名称、标识符等等。 -- 进程的调度信息,包括进程阻塞原因、进程状态(就绪、运行、阻塞等)、进程优先级(标识进程的重要程度)等等。 -- 进程对资源的需求情况,包括 CPU 时间、内存空间、I/O 设备等等。 -- 进程打开的文件信息,包括文件描述符、文件类型、打开模式等等。 -- 处理机的状态信息(由处理机的各种寄存器中的内容组成的),包括通用寄存器、指令计数器、程序状态字 PSW、用户栈指针。 +- **标识信息**:PID、父进程 ID、用户 ID 等。 +- **进程状态和调度信息**:就绪、运行、阻塞、优先级、时间片、CPU 时间统计等。 +- **CPU 上下文**:程序计数器、栈指针、通用寄存器、程序状态字 PSW 等,用于上下文切换后恢复执行。 +- **内存管理信息**:虚拟地址空间、页表、内存映射等。 +- **资源信息**:打开文件、文件描述符、I/O 状态、工作目录、信号处理信息等。 - …… +发生上下文切换时,操作系统会把当前进程的寄存器等现场保存到 PCB 中,再从下一个进程的 PCB 中恢复现场,让它能够从上次暂停的位置继续执行。 + +### TCB 是什么?和 PCB 有什么关系? + +**TCB(Thread Control Block)** 即线程控制块,用来保存线程级别的控制信息,例如线程 ID、线程状态、寄存器现场、栈信息、调度优先级、线程本地存储等。 + +在一些教材或系统实现里,PCB 和 TCB 是分开的:PCB 更偏进程级资源,TCB 更偏线程级执行现场。Linux 的实现比较特殊,它把进程和线程都看成 task,用 `task_struct` 描述调度实体,再通过资源结构是否共享来区分进程和线程。理解时不用纠结名字,关键是分清:**地址空间、文件表等属于资源边界;栈、寄存器、程序计数器等属于执行现场**。 + ### 进程有哪几种状态? -我们一般把进程大致分为 5 种状态,这一点和线程很像! +我们一般把进程大致分为 5 种状态,这一点和线程很像: - **创建状态(new)**:进程正在被创建,尚未到就绪状态。 - **就绪状态(ready)**:进程已处于准备运行状态,即进程获得了除了处理器之外的一切所需资源,一旦得到处理器资源(处理器分配的时间片)即可运行。 @@ -240,17 +263,57 @@ PCB 主要包含下面几部分的内容: ![进程状态图转换图](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/state-transition-of-process.png) +状态转换要重点看触发原因:就绪态拿到 CPU 后进入运行态;运行态时间片用完,可能回到就绪态;运行中发起阻塞 I/O、等待锁或等待事件,会进入阻塞态;阻塞等待的事件完成后,通常先回到就绪态,等待下一次被调度。 + +有些教材还会加入**挂起状态**。挂起强调进程暂时不在内存中,或者被用户/系统暂停;阻塞强调进程在等待某个事件。二者不是一回事:进程可以阻塞但仍在内存里,也可以被换出到外存后处于阻塞挂起。 + ### 进程间的通信方式有哪些? -> 下面这部分总结参考了:[《进程间通信 IPC (InterProcess Communication)》](https://www.jianshu.com/p/c1015f5ffa74) 这篇文章,推荐阅读,总结的非常不错。 +进程默认拥有独立虚拟地址空间,不能直接访问彼此的用户态内存,所以需要 **IPC(Inter-Process Communication,进程间通信)**。IPC 要解决的不只是“数据怎么传过去”,还包括同步、命名寻址和权限检查等问题。更系统的介绍可以看:[进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md),路径:`./ipc.md`。 + +![根据数据量、消息边界、跨机器和进程亲缘关系选择合适的 IPC 方式](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-ipc-selection.png) + +常见 IPC 方式如下: + +| IPC 方式 | 数据形态 | 典型特点 | 适用场景 | +| ---------------- | --------------- | ---------------------------------------------------------------------- | -------------------------------------------- | +| 匿名管道 | 字节流 | 没有名字,通常依赖 `fork()` 后继承文件描述符,主要用于有亲缘关系的进程 | Shell 管道、父子进程简单通信 | +| 命名管道(FIFO) | 字节流 | 通过文件系统路径命名,无亲缘关系进程也能通信 | 本机简单字节流通信 | +| 消息队列 | 消息 | 内核维护队列,保留消息边界,适合小型结构化消息 | 任务通知、状态事件、控制命令 | +| 共享内存 | 共享内存区域 | 多个进程映射同一块物理内存,数据路径短,但同步要自己处理 | 本机大块数据交换、日志采集、音视频处理 | +| 信号量 | 计数器/同步原语 | 不传业务数据,主要用于控制并发访问和进程间同步 | 配合共享内存控制读写顺序 | +| 信号 | 异步事件通知 | 能携带的信息少,处理函数受限制 | 进程退出、子进程状态变化、终端中断等事件通知 | +| Socket | 字节流或数据报 | Unix Domain Socket 适合同机通信,TCP/UDP Socket 可跨机器通信 | 本机服务监听、跨机器通信、RPC 底层通信 | + +面试里可以这样总结: + +> 管道、FIFO、Socket 主要传字节流,消息边界通常要由应用协议处理;消息队列保留消息边界,适合小消息;共享内存适合本机大块数据交换,但必须配合同步机制;信号偏事件通知,信号量更多用于同步;如果要跨机器通信,一般选择 TCP/UDP Socket 或更上层的 RPC 框架。 + +如果继续追问“共享内存为什么还需要信号量”,可以回答:共享内存只解决“多个进程能看到同一份数据”,不解决“谁先写、谁后读、写到一半能不能读”。访问顺序、互斥和唤醒仍然要靠信号量、进程间互斥锁、`futex`、`eventfd` 等同步机制配合。 + +### fork、exec、wait 分别做什么? + +在 Unix/Linux 编程里,进程创建和程序替换常绕不开 `fork()`、`exec()`、`wait()` 这三个动作。 + +![fork、exec、wait 的调用链路](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/fork-exec-wait-call-chain.png) + +- **`fork()`**:创建子进程。调用成功后,父子进程会从同一个位置继续执行,但返回值不同:父进程拿到子进程 PID,子进程拿到 0。父子进程拥有独立虚拟地址空间,现代系统通常会配合写时复制(COW),只有某一方写内存时才复制对应页面。 +- **`exec()`**:在当前进程中装入另一个程序。它不会新建进程,而是把当前进程的代码、数据、堆、栈等用户态内容替换成新程序。 +- **`wait()`/`waitpid()`**:等待子进程状态变化,并回收子进程退出后保留在内核中的状态信息。子进程已经退出但父进程还没有 `wait`,就会留下僵尸进程。 + +Shell 启动外部命令时,常见链路就是:Shell 先 `fork()` 出子进程,子进程再 `exec()` 成目标程序,父进程用 `wait()` 或 `waitpid()` 等待并回收退出状态。 + +还有一个容易踩坑的细节:多线程进程调用 `fork()` 后,子进程里通常只保留调用 `fork()` 的那个线程。父进程其他线程持有的锁、malloc 状态、stdio 状态等可能被复制过去,但对应线程已经不存在。因此,多线程程序通常应该尽快在子进程里执行 `exec()`,不要在 `fork()` 后到 `exec()` 前做复杂逻辑。 + +### 什么是上下文切换? + +上下文切换指 CPU 从一个执行实体切到另一个执行实体。操作系统需要保存当前执行实体的寄存器、程序计数器、栈指针等现场,再恢复下一个执行实体的现场。 + +![线程上下文切换和进程上下文切换的成本对比](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/context-switch-cost-comparison.png) + +线程切换和进程切换都会有开销,但进程切换通常更重。原因是进程有独立地址空间,切换时可能涉及页表切换、TLB 失效、缓存局部性下降等成本;同一进程内的线程共享地址空间,切换时通常不需要换整套内存映射。 -1. **管道/匿名管道(Pipes)**:用于具有亲缘关系的父子进程间或者兄弟进程之间的通信。 -2. **有名管道(Named Pipes)**:匿名管道由于没有名字,只能用于亲缘关系的进程间通信。为了克服这个缺点,提出了有名管道。有名管道严格遵循 **先进先出(First In First Out)**。有名管道以磁盘文件的方式存在,可以实现本机任意两个进程通信。 -3. **信号(Signal)**:信号是一种比较复杂的通信方式,用于通知接收进程某个事件已经发生。 -4. **消息队列(Message Queuing)**:消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识。管道和消息队列的通信数据都是先进先出的原则。与管道(无名管道:只存在于内存中的文件;命名管道:存在于实际的磁盘介质或者文件系统)不同的是消息队列存放在内核中,只有在内核重启(即操作系统重启)或者显式地删除一个消息队列时,该消息队列才会被真正的删除。消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取,比 FIFO 更有优势。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺点。 -5. **信号量(Semaphores)**:信号量是一个计数器,用于多进程对共享数据的访问,信号量的意图在于进程间同步。这种通信方式主要用于解决与同步相关的问题并避免竞争条件。 -6. **共享内存(Shared memory)**:使得多个进程可以访问同一块内存空间,不同进程可以及时看到对方进程中对共享内存中数据的更新。这种方式需要依靠某种同步操作,如互斥锁和信号量等。可以说这是最有用的进程间通信方式。 -7. **套接字(Sockets)**:此方法主要用于在客户端和服务器之间通过网络进行通信。套接字是支持 TCP/IP 的网络通信的基本操作单元,可以看做是不同主机之间的进程进行双向通信的端点,简单的说就是通信的两方的一种约定,用套接字中的相关函数来完成通信过程。 +可以这样简化理解:同一进程内的线程切换,主要换线程自己的栈、寄存器、程序计数器等执行现场;跨进程切换除了换执行现场,还可能切换地址空间,并带来 TLB 和缓存局部性的影响。线上性能分析里,如果发现大量时间花在调度、锁等待、系统调用和上下文切换上,继续盲目加线程通常只会让情况更差。 ### 进程的调度算法有哪些? diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md index 22c27b3160e..f85eb09bdbb 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-02.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-02.md @@ -1,17 +1,23 @@ --- -title: 操作系统常见面试题总结(下) -description: 最新操作系统高频面试题总结(下):虚拟内存映射、内存碎片/伙伴系统、TLB+页缺失处理、分页分段对比、页面置换算法、零拷贝、I/O 多路复用、文件系统&磁盘调度,附图表+⭐️重点标注,一文掌握 OS 内存/I/O/文件考点,快速通关后端面试! +title: 操作系统常见面试题总结(下) +description: 最新操作系统高频面试题总结(下):虚拟内存映射、进程地址空间隔离、内存碎片/伙伴系统、TLB+页缺失处理、分页分段对比、页面置换算法、零拷贝、I/O 多路复用、文件系统&磁盘调度,一文掌握 OS 内存/I/O/文件考点。 category: 计算机基础 tag: - 操作系统 head: - - meta - name: keywords - content: 操作系统面试题,虚拟内存详解,分页 vs 分段,页面置换算法,内存碎片,伙伴系统,TLB快表,页缺失,零拷贝,mmap,sendfile,splice,I/O多路复用,select,poll,epoll,文件系统基础,磁盘调度算法,硬链接 vs 软链接 + content: 操作系统面试题,虚拟内存详解,进程地址空间,进程隔离,共享内存,分页 vs 分段,页面置换算法,内存碎片,伙伴系统,TLB快表,页缺失,零拷贝,mmap,sendfile,splice,I/O多路复用,select,poll,epoll,文件系统基础,磁盘调度算法,硬链接 vs 软链接 --- +这篇《操作系统常见面试题总结(下)》承接上篇,重点放在 **内存管理、虚拟内存、分页分段、TLB、缺页中断、页面置换、I/O 多路复用、零拷贝、文件系统和磁盘调度**。 + +如果说上篇更偏“进程、线程和并发控制”,这篇更偏“程序运行时到底怎么用内存、怎么做 I/O、怎么和文件系统交互”。这些内容看起来离业务代码比较远,但很多后端问题最终都会落到这里:为什么 mmap 能少一次拷贝?为什么 epoll 能撑住大量连接?为什么同一个虚拟地址在不同进程里互不影响?为什么频繁缺页会让系统变慢? + +建议阅读时抓住一条主线:**操作系统通过虚拟内存管理地址和隔离,通过 I/O 机制管理数据流动,通过文件系统管理持久化数据**。把这条线串起来,很多零散概念就不再只是名词。 + ## 内存管理 ### 内存管理主要做了什么? @@ -87,7 +93,7 @@ head: - **隔离进程**:每个进程都有自己的虚拟地址空间和页表。不同进程即使使用相同的虚拟地址,也可以映射到不同的物理页,彼此不会直接踩内存。 - **提升物理内存利用率**:操作系统不需要把进程的全部代码和数据一次性装进物理内存,只把当前真正会用到的页加载进来。 - **简化内存管理**:进程看到的是一片连续的虚拟地址空间,物理内存可以是离散的页帧,复杂的拼接工作交给页表和 MMU。 -- **多个进程共享物理内存**:进程在运行过程中,会加载许多操作系统的动态库。这些库对于每个进程而言都是公用的,它们在内存中实际只会加载一份,这部分称为共享内存。 +- **多个进程共享物理内存**:进程在运行过程中会加载许多操作系统动态库,这些库对于多个进程而言可以共用同一份物理页;多个进程也可以通过共享内存 IPC 主动映射同一块物理内存,用于高效交换数据。 - **提高内存使用安全性**:控制进程对物理内存的访问,隔离不同进程的访问权限,提高系统的安全性。 - **提供更大的可使用内存空间**:当物理内存不够用时,可以把暂时不用的页换出到磁盘,需要时再换回来。这样程序感知到的可用内存空间可以超过实际物理内存,不过频繁换页会明显拖慢系统。 @@ -114,6 +120,8 @@ head: 通过 MMU 将虚拟地址转换为物理地址后,CPU 再访问对应的物理内存位置,完成读写请求。也正是因为有这层转换,不同进程里数值相同的虚拟地址,最终可以落到完全不同的物理页上。 +这也是进程隔离和进程间通信的基础:默认情况下,一个进程不能直接读写另一个进程的用户态地址空间;如果两个进程确实需要交换数据,就要借助管道、消息队列、共享内存、Socket 等 IPC 机制。关于 IPC 的系统总结可以看:[进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md)。 + MMU 将虚拟地址翻译为物理地址的主要机制有两种:**分段机制** 和 **分页机制**。 #### 什么是虚拟地址空间和物理地址空间? @@ -358,6 +366,8 @@ LRU 及其近似算法在实际系统中应用较多,因为它比较符合程 ![虚拟地址到物理地址的映射过程:不同进程的相同虚拟地址通过 MMU 和页表映射到不同物理页](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/virtual-memory-virtual-physical-mapping.png) +不过,隔离不代表进程之间完全不能共享数据。操作系统可以有控制地让多个进程映射同一批物理页,例如动态库共享、`mmap` 文件映射、共享内存 IPC。区别在于:默认隔离由页表权限保证,共享则必须由内核显式建立映射并配合权限控制;如果是共享内存 IPC,还需要额外处理同步问题。 + 分页机制把虚拟地址空间和物理内存都切成固定大小的页,通过页表记录“虚拟页号 -> 物理页帧”的映射。这样基本消除了分段容易产生的外部碎片,也让物理内存可以离散分配;代价是页表本身会占空间,所以现代系统会用多级页表按需创建下级页表。 TLB 可以理解为页表项缓存。CPU 先查 TLB,命中就直接拿到物理页帧号;未命中才去查多级页表,并把结果回填到 TLB。如果页表项显示页面不在内存,就会触发缺页中断,内核再判断访问是否合法,合法则分配页帧、必要时换出旧页、从文件或 Swap 调入页面,最后更新页表并重新执行那条指令。 diff --git a/docs/cs-basics/operating-system/process-and-thread.md b/docs/cs-basics/operating-system/process-and-thread.md new file mode 100644 index 00000000000..faff549720a --- /dev/null +++ b/docs/cs-basics/operating-system/process-and-thread.md @@ -0,0 +1,228 @@ +--- +title: 进程与线程详解:区别、状态、通信、上下文切换与虚拟线程 +description: 进程与线程高频面试题总结,从操作系统视角梳理进程和线程的概念、资源模型、状态转换、PCB/TCB、fork/exec/wait、线程模型、上下文切换以及 Java 线程和虚拟线程的关系。 +category: 计算机基础 +tag: + - 操作系统 + - 进程线程 + - Java 并发 +head: + - - meta + - name: keywords + content: 进程,线程,进程和线程的区别,进程状态,线程状态,PCB,TCB,fork,exec,wait,clone,pthread,上下文切换,线程模型,Java虚拟线程,操作系统面试题 +--- + +进程和线程是操作系统里最基础、也最容易被混着背的两个概念。 + +面试里问它们的区别,很多回答会停在“进程是资源分配的基本单位,线程是 CPU 调度的基本单位”。这句话可以作为入口,但不够用。 + +继续往下追,就会遇到一串更具体的问题:为什么进程之间默认隔离?线程到底共享了什么?`fork()` 后父子进程有哪些东西相同、哪些东西已经分开?为什么多线程程序里随便 `fork()` 会出问题?Java 虚拟线程又算不算操作系统线程? + +这篇文章就顺着这些问题展开。先把程序、进程、线程的边界讲清楚,再看 Linux 里的 `fork`、`exec`、`wait`、`clone`,最后回到上下文切换、线程模型和 Java 虚拟线程。读的时候可以抓住一条主线:进程更像资源和隔离边界,线程更像一条可以被调度的执行路径。 + +## 程序、进程和线程分别是什么? + +![程序、进程和线程的关系](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/relationship-between-program-process-and-thread.png) + +程序是存放在磁盘上的一组指令和数据,比如一个可执行文件、一个 JAR 包。它还没有真正运行,只是静态文件。 + +当操作系统把程序加载到内存,为它建立虚拟地址空间、文件描述符表等进程级资源,并为初始线程建立栈、寄存器上下文等执行现场后,程序的一次运行就变成了**进程**。同一个程序可以启动多次,对应多个进程;比如同时打开两个终端窗口,通常就是两个不同的进程实例。 + +线程是进程里的执行流。一个进程至少有一个线程,进程中的多个线程共享这份进程资源,但每个线程也有自己的执行现场。现代操作系统真正拿去调度的通常是线程:哪个线程处于可运行状态,调度器就可能把 CPU 时间片分给它。 + +可以用一句话先记住大方向:**进程侧重资源边界,线程侧重执行和调度。** + +判断一个概念更偏进程还是更偏线程,也可以先问:它描述的是资源边界,还是一条执行路径?地址空间、打开文件表、权限信息更偏进程;栈、寄存器、程序计数器更偏线程。 + +![用微信工厂类比进程和线程的区别](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/wechat-factory-process-thread.png) + +不过这句话只是学习时的抓手,不能当成所有系统的实现细节。比如 Linux 内核内部用 `task_struct` 描述调度实体,进程和线程更像是共享资源程度不同的任务;Windows 文档则明确把线程说成操作系统分配处理器时间的基本单位。不同系统名字不完全一样,但抽象层面的关系大致相通。 + +## 进程拥有哪些资源? + +进程不是只有正在执行的代码。一个进程通常包含这些内容: + +- **虚拟地址空间**:进程看到的是一段连续的虚拟内存,里面有代码段、数据段、堆、栈、内存映射区域等。 +- **打开的文件和句柄**:比如文件描述符、Socket、管道、设备句柄。 +- **安全和身份信息**:比如用户 ID、权限、凭据、安全上下文。 +- **调度相关信息**:优先级、CPU 时间统计、亲和性、状态等。 +- **信号、环境变量、工作目录等运行上下文**。 + +进程之间默认是隔离的。一个进程不能随便读写另一个进程的虚拟地址空间,这也是操作系统能把不同程序保护起来的基础。两个进程想交换数据,需要借助管道、消息队列、共享内存、Socket、文件、信号等 IPC 方式。 + +隔离带来安全,也带来成本。两个进程各自有地址空间和资源表,切换、通信、创建和销毁都比线程更重。 + +## 进程有哪些常见状态? + +教材里常见的五状态模型够应付大多数面试题: + +- **创建状态(New)**:进程正在创建,还没有进入就绪队列。 +- **就绪状态(Ready)**:运行条件基本具备,只差 CPU。 +- **运行状态(Running)**:正在 CPU 上执行。 +- **阻塞状态(Blocked/Waiting)**:正在等某个事件,比如 I/O 完成、锁释放、定时器到期。 +- **终止状态(Terminated/Exit)**:进程结束,操作系统回收相关资源。 + +![进程状态图转换图](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/state-transition-of-process.png) + +状态转换的关键不在名词,而在触发原因。就绪态拿到 CPU 会变成运行态;运行中的时间片用完,可能回到就绪态;运行中发起阻塞 I/O,会进入阻塞态;阻塞等待的事件完成后,先回到就绪态,等待下一次被调度。 + +有些教材还会加入**挂起状态**。挂起强调进程暂时不在内存中,或者被用户/系统暂停;阻塞强调它在等待事件。二者不是一回事:一个进程可以阻塞但仍在内存里,也可以被换出到外存后处于阻塞挂起。 + +## PCB 是什么? + +PCB(Process Control Block,进程控制块)是操作系统管理进程的数据结构。进程运行时的许多信息不会散落在空气里,而是由内核放在类似 PCB 的结构里维护。 + +PCB 通常记录: + +- 进程标识信息:PID、父进程 ID、用户 ID 等。 +- 进程状态和调度信息:就绪、运行、阻塞、优先级、时间统计。 +- CPU 上下文:程序计数器、栈指针、通用寄存器等,方便切换回来继续执行。 +- 内存管理信息:页表、虚拟地址空间、内存映射。 +- 资源信息:打开文件、信号处理、工作目录、I/O 状态等。 + +发生上下文切换时,操作系统会把当前执行实体的寄存器等现场保存起来,再恢复下一个执行实体的现场。PCB/TCB 这类结构就是“下次从哪儿继续跑”的依据。 + +Linux 的实现有一点特别:它把进程和线程都看成 task,`task_struct` 里并不直接塞进所有资源,而是通过指针指向内存描述符、文件表、信号处理等资源结构。多个线程属于同一进程时,它们会指向同一批资源结构;不同进程则指向不同资源。这也是 Linux 上理解 `clone()` 很有用的原因。 + +## Linux 里 fork、exec、wait 分别做什么? + +![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/fork-exec-wait-call-chain.png) + +在 Unix/Linux 编程里,进程创建常绕不开 `fork()`、`exec()`、`wait()` 这三个动作。 + +`fork()` 用来创建子进程。调用成功后,父子进程从同一个位置继续往下执行,只是返回值不同:父进程拿到子进程 PID,子进程拿到 0。父子进程拥有独立的虚拟地址空间,刚创建时内容看起来一样;现代系统一般配合写时复制,只有当某一方写内存时,内核才复制对应页面。 + +还要注意文件描述符。`fork()` 后,父子进程的文件描述符表是各自的副本,但对应 fd 会指向同一个 open file description,所以文件偏移量、打开状态标志等会共享。工程里常配合 `FD_CLOEXEC` 或 `O_CLOEXEC`,避免 `exec()` 后把不该继承的 fd 泄漏给新程序。 + +`exec()` 系列函数用于在当前进程里装入另一个程序。它不会新建进程,而是把当前进程的代码、数据、堆、栈等用户态内容替换成新程序。命令行里常见的模型就是:Shell 先 `fork()` 出子进程,子进程再 `exec()` 成目标程序。 + +`wait()`/`waitpid()` 用来等待子进程状态变化,并回收子进程退出后残留在内核里的状态信息。子进程已经退出但父进程还没有 `wait`,就会留下僵尸进程。僵尸进程不再执行代码,但仍占着 PID 和退出状态记录。 + +Shell 启动外部命令时,常见链路就是:Shell 调 `fork()` 创建子进程,子进程调 `exec()` 变成目标程序,父进程用 `wait()` 或 `waitpid()` 等待并回收退出状态。 + +这里有个容易忽略的细节:多线程进程调用 `fork()` 后,子进程里只保留调用 `fork()` 的那个线程。父进程其他线程的锁状态、条件变量状态、malloc 状态、stdio 状态可能被复制过去,但对应线程已经不存在。更严格地说,多线程程序 `fork()` 之后、`exec()` 之前,子进程只应调用 async-signal-safe 的函数;在这段窗口里做复杂逻辑很容易踩坑。 + +## 线程共享什么,又私有什么? + +![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/thread-shared-and-private-content.png) + +从操作系统角度看,同一进程内的线程共享进程的大部分资源,例如: + +- 代码段、数据段、堆等进程地址空间里的内存区域; +- 打开的文件描述符、Socket、工作目录; +- 进程 ID、地址空间、信号处理配置中的一部分; +- 全局变量和堆对象。 + +如果换到 Java/JVM 语境,Java 线程还会共享同一个 JVM 进程里的堆、方法区/元空间等运行时数据区域。方法区/元空间不是通用操作系统概念,放在 JVM 这一层理解更合适。 + +在 Linux 用户态,同一进程内的多个线程调用 `getpid()` 通常看到的是同一个线程组 ID,也就是平时说的进程 ID;但每个线程在内核里仍有自己的 task/TID,可以用 `gettid()` 区分。 + +每个线程也有自己的私有内容: + +- 栈:保存函数调用、局部变量、返回地址等。 +- 寄存器和程序计数器:记录线程当前执行到哪里。 +- 线程 ID、调度优先级、线程本地存储(TLS)。 +- 线程状态和少量内核用于恢复执行的上下文信息。 + +共享让线程间通信很方便,一个线程往堆里的对象写入数据,另一个线程马上就可能看到。但共享也带来数据竞争:多个线程同时读写同一份可变数据,如果没有锁、原子变量、条件变量等同步手段,结果就可能不符合预期。 + +这也是线程和进程在工程上的重要差别:进程崩溃通常不会直接破坏另一个进程;同一进程内某个线程越界写内存、触发非法访问,往往会把整个进程带走。 + +## TCB 是什么? + +TCB(Thread Control Block,线程控制块)可以理解为线程级别的控制信息。它通常记录线程 ID、线程状态、寄存器现场、栈信息、优先级、线程本地存储等内容。 + +在一些教材或系统实现里,PCB 和 TCB 是分开的:PCB 负责进程级资源,TCB 负责线程级执行现场。Linux 的 `task_struct` 则把调度实体统一为 task,再按资源结构是否共享来区分进程和线程。概念学习时不必纠结名字,关键是看清哪些信息属于资源边界,哪些信息属于执行现场。 + +## 有了进程为什么还需要线程? + +主要是为了在同一个应用内用更低成本做并发。 + +如果一个服务端要同时处理网络读写、业务计算、日志刷盘,用多个进程当然也能做,但进程之间共享状态麻烦,通信要走 IPC,资源占用也更高。改成多个线程后,它们能直接共享堆内存和打开的连接,只要同步写对,协作成本低很多。 + +线程也能提高资源利用率。单核 CPU 上,一个线程阻塞在磁盘或网络 I/O 时,其他线程可以继续运行;多核 CPU 上,多个线程有机会在不同核心上同时执行。CPU 密集型任务、I/O 密集型任务对线程数的需求不同,不能简单理解为线程越多越快。 + +线程不是免费资源。Linux NPTL 下,如果进程启动时的 `RLIMIT_STACK` 软限制不是 `unlimited`,它会决定新线程的默认栈大小;常见 `ulimit -s` 为 8192 KB,因此常见默认线程栈是 8 MB。如果 `RLIMIT_STACK` 是 `unlimited`,则使用架构相关默认值,例如多数架构为 2 MB。也可以通过 `pthread_attr_setstacksize()` 指定线程栈大小,但不能低于 `PTHREAD_STACK_MIN`,Linux man-pages 给出的值是 16384 字节。除此之外,线程还受 PID 数量、`threads-max`、内存等限制。线上系统里盲目创建大量平台线程,常见后果是内存压力、调度开销和上下文切换增多。 + +## 用户线程、内核线程和线程模型怎么区分? + +按“谁负责调度”来看,线程可以分为用户级线程和内核级线程。 + +**用户级线程**由用户态运行时或线程库管理,内核通常看不到这些线程。它的好处是创建、切换不一定需要系统调用;问题是如果所有用户线程只对应一个内核调度实体,那么其中一个线程发起阻塞系统调用,可能拖住整个进程,也很难利用多核。 + +**内核级线程**由操作系统内核创建和调度。某个线程阻塞,内核还能调度同进程的其他线程;多个线程也能在多核上并行执行。代价是创建、销毁、阻塞、唤醒、切换都要内核参与。 + +常见线程模型有三类: + +![常见的三种线程模型](https://oss.javaguide.cn/github/javaguide/java/new-features/process-and-thread-three-thread-models.png) + +| 模型 | 含义 | 优点 | 主要问题 | +| ------ | ------------------------------ | -------------------------- | ------------------------------------------ | +| 多对一 | 多个用户线程映射到一个内核线程 | 用户态切换快,实现成本低 | 一个阻塞可能影响整体,不能充分利用多核 | +| 一对一 | 一个用户线程映射到一个内核线程 | 能利用多核,阻塞影响较小 | 线程数量受系统资源限制,创建和切换成本更高 | +| 多对多 | 多个用户线程映射到多个内核线程 | 在灵活性和并行能力之间折中 | 运行时和调度实现更复杂 | + +Linux 的 POSIX 线程和 Windows 系统线程基本属于一对一模型。Linux 的 `pthread_create()` 底层会使用 `clone()`,并由 `CLONE_VM`、`CLONE_FILES`、`CLONE_FS`、`CLONE_THREAD` 等标志决定共享哪些资源。Linux 上进程和线程并不是两套完全割裂的创建机制,而是 `clone()` 参数不同带来的资源共享差异。 + +## 线程上下文切换和进程上下文切换有什么不同? + +![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/context-switch-cost-comparison.png) + +上下文切换指 CPU 从一个执行实体切到另一个执行实体。操作系统需要保存当前实体的寄存器、程序计数器、栈指针等现场,再恢复下一个实体的现场。 + +线程切换和进程切换都会有开销,但进程切换通常更重。原因是进程有独立地址空间,切换时可能涉及页表切换、TLB 失效、缓存局部性下降等成本;同一进程内的线程共享地址空间,切换时通常不需要换整套内存映射。 + +可以把它简化成两句话:同一进程内的线程切换,主要换线程自己的栈、寄存器、程序计数器等执行现场;跨进程切换除了换执行现场,还可能切换地址空间,并带来 TLB 和缓存局部性的影响。 + +不过,线程切换也不能只看成“保存几个寄存器”。跨核迁移、锁竞争、缓存行来回失效、线程数量远大于 CPU 核数时,线程调度照样会消耗很多 CPU。性能分析里如果看到大量时间花在调度、锁等待、系统调用和上下文切换上,继续加线程往往只会让情况更差。 + +## 纤程、协程和虚拟线程算线程吗? + +纤程(Fiber)和协程通常运行在用户态,由应用或运行时调度。操作系统真正调度的是承载它们的内核线程,而不是每一个纤程或协程。因此,这类轻量执行单元切换时通常不需要陷入内核,成本可以更低。 + +但它们不是“免费线程”。如果运行时没有把阻塞 I/O 改造成可挂起、可恢复的形式,一个用户态任务阻塞住承载线程,同一承载线程上的其他任务也会受影响。另外,不同语言、运行时、CPU 架构和调用栈深度都会影响切换成本,不能把某个基准测试里的纳秒数字当成通用结论。 + +Java 21 引入的虚拟线程就是一个典型例子。它仍然是 `java.lang.Thread`,但不会长期独占一个操作系统线程。虚拟线程运行时会挂载到平台线程(platform thread)上,平台线程再对应底层的系统内核线程;当虚拟线程执行 JDK 支持的可挂起阻塞 I/O 时,JDK 可以先把它卸载下来,让这个平台线程去运行别的虚拟线程。 + +所以,虚拟线程适合大量“等 I/O”的任务,比如高并发请求、数据库访问、远程调用等。它提升的是并发承载能力和吞吐扩展性,不是让一段 CPU 计算代码跑得更快。CPU 密集型长任务仍然要看 CPU 核数、计算量和调度开销,不能无限量丢给虚拟线程。 + +虚拟线程、平台线程和系统内核线程的关系: + +![虚拟线程、平台线程和系统内核线程的关系](https://oss.javaguide.cn/github/javaguide/java/new-features/virtual-threads-platform-threads-kernel-threads-relationship.png) + +还要注意 pinning。以 Java 21 为例,虚拟线程在 `synchronized` 块/方法、native 方法或 foreign function 中执行阻塞操作时,可能无法从承载它的平台线程上卸载,结果就是平台线程也被一起占住,不能去运行其他虚拟线程。少量、短时间的 pinning 不会让程序出错,但频繁、长时间的 pinning 会影响扩展性。后续 JDK 对 `synchronized` 相关的 pinning 做过改进,实际判断时要以当前使用的 JDK 版本为准;native/foreign 调用这类边界仍然需要额外留意。 + +## 进程和线程的区别怎么总结? + +面试里可以从资源、调度、通信、开销、可靠性 5 个角度答。 + +| 维度 | 进程 | 线程 | +| ------------- | ------------------------------------------ | -------------------------------- | +| 基本定位 | 资源分配和隔离的基本单位 | CPU 调度和执行的基本单位 | +| 地址空间 | 默认独立 | 同一进程内共享 | +| 私有内容 | PID、地址空间、资源表等 | 栈、寄存器、程序计数器、TLS 等 | +| 通信方式 | 需要 IPC,如管道、Socket、共享内存 | 可直接读写共享内存,但要同步 | +| 创建/切换成本 | 通常更高 | 通常更低 | +| 故障影响 | 隔离性更好,一个进程崩溃通常不影响其他进程 | 一个线程崩溃可能导致整个进程退出 | + +比较完整的回答可以这样组织: + +进程是程序运行时的资源容器,拥有独立虚拟地址空间和文件、权限等资源;线程是进程内的执行流,多个线程共享进程资源,但各自保存栈、寄存器、程序计数器等执行现场。进程间隔离更强,通信和切换成本更高;线程间协作更方便,创建和切换通常更轻,但共享内存带来线程安全问题,一个线程出错也可能影响整个进程。 + +## 常见误区 + +**误区一:进程并行,线程并发。** + +并发和并行描述的是执行关系,不是进程/线程的固定属性。单核上多个进程或线程都只能并发;多核上多个进程或线程都可能并行。 + +**误区二:线程越多,性能越好。** + +线程适合掩盖 I/O 等待,也能利用多核;但线程过多会带来栈内存、调度、锁竞争和缓存失效。CPU 密集型任务通常更接近“核心数附近”的线程配置,I/O 密集型任务才可能需要更多并发执行单元。 + +**误区三:进程之间完全不能共享内存。** + +默认隔离不等于不能共享。共享内存就是专门让多个进程映射同一块物理内存的 IPC 方式,只是程序员需要自己处理同步和生命周期。 + +**误区四:Java 虚拟线程就是操作系统线程。** + +平台线程通常是 OS 线程的薄封装;虚拟线程由 Java 运行时调度,会挂载到平台线程上执行。它们都表现为 `Thread`,但资源模型和调度方式不同。 From a2cea626a71464641b89c0074fd9eaf2d69413b7 Mon Sep 17 00:00:00 2001 From: Guide Date: Thu, 11 Jun 2026 14:30:31 +0800 Subject: [PATCH 010/116] docs: optimize algorithms and data structures interview prep --- docs/.vuepress/sidebar/cs-basics.ts | 31 ++- docs/cs-basics/README.md | 16 +- .../10-classical-sorting-algorithms.md | 24 ++ docs/cs-basics/algorithms/README.md | 113 +++++--- docs/cs-basics/algorithms/backtracking.md | 208 +++++++++++++++ docs/cs-basics/algorithms/binary-search.md | 252 ++++++++++++++++++ ...ical-algorithm-problems-recommendations.md | 216 +++++++++------ ...ata-structures-leetcode-recommendations.md | 132 ++++++--- .../algorithms/complexity-analysis.md | 185 +++++++++++++ docs/cs-basics/algorithms/dfs-bfs.md | 194 ++++++++++++++ .../algorithms/dynamic-programming.md | 200 ++++++++++++++ docs/cs-basics/algorithms/greedy.md | 127 +++++++++ .../linkedlist-algorithm-problems.md | 34 +++ .../algorithms/string-algorithm-problems.md | 29 +- docs/cs-basics/algorithms/top-k.md | 162 +++++++++++ .../two-pointers-and-sliding-window.md | 236 ++++++++++++++++ docs/cs-basics/data-structure/README.md | 104 +++++--- docs/cs-basics/data-structure/bloom-filter.md | 27 ++ docs/cs-basics/data-structure/graph.md | 25 ++ docs/cs-basics/data-structure/hash-table.md | 110 ++++++++ docs/cs-basics/data-structure/heap.md | 38 +++ .../data-structure/linear-data-structure.md | 28 +- docs/cs-basics/data-structure/lru-cache.md | 158 +++++++++++ .../data-structure/red-black-tree.md | 20 ++ docs/cs-basics/data-structure/skip-list.md | 90 +++++++ docs/cs-basics/data-structure/tree.md | 49 +++- docs/cs-basics/data-structure/trie.md | 121 +++++++++ docs/cs-basics/data-structure/union-find.md | 111 ++++++++ docs/database/mysql/mysql-index.md | 4 + docs/database/redis/redis-questions-01.md | 4 +- docs/database/redis/redis-skiplist.md | 2 + .../backend-interview-plan.md | 4 +- docs/java/collection/README.md | 4 + .../java-collection-questions-01.md | 6 +- 34 files changed, 2851 insertions(+), 213 deletions(-) create mode 100644 docs/cs-basics/algorithms/backtracking.md create mode 100644 docs/cs-basics/algorithms/binary-search.md create mode 100644 docs/cs-basics/algorithms/complexity-analysis.md create mode 100644 docs/cs-basics/algorithms/dfs-bfs.md create mode 100644 docs/cs-basics/algorithms/dynamic-programming.md create mode 100644 docs/cs-basics/algorithms/greedy.md create mode 100644 docs/cs-basics/algorithms/top-k.md create mode 100644 docs/cs-basics/algorithms/two-pointers-and-sliding-window.md create mode 100644 docs/cs-basics/data-structure/hash-table.md create mode 100644 docs/cs-basics/data-structure/lru-cache.md create mode 100644 docs/cs-basics/data-structure/skip-list.md create mode 100644 docs/cs-basics/data-structure/trie.md create mode 100644 docs/cs-basics/data-structure/union-find.md diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index 3541f1de5c3..e456bdf0512 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -156,11 +156,16 @@ export const csBasics = [ collapsible: true, children: [ { text: "线性数据结构", link: "linear-data-structure" }, + { text: "哈希表", link: "hash-table" }, { text: "树结构", link: "tree" }, { text: "图", link: "graph" }, { text: "堆", link: "heap" }, + { text: "Trie 前缀树", link: "trie" }, + { text: "并查集", link: "union-find" }, + { text: "跳表", link: "skip-list" }, { text: "红黑树", link: "red-black-tree" }, { text: "布隆过滤器", link: "bloom-filter" }, + { text: "LRU 缓存", link: "lru-cache" }, ], }, { @@ -169,12 +174,26 @@ export const csBasics = [ icon: ICONS.ALGORITHM, collapsible: true, children: [ - "classical-algorithm-problems-recommendations", - "common-data-structures-leetcode-recommendations", - "string-algorithm-problems", - "linkedlist-algorithm-problems", - "the-sword-refers-to-offer", - "10-classical-sorting-algorithms", + { text: "复杂度分析", link: "complexity-analysis" }, + { text: "二分查找", link: "binary-search" }, + { text: "双指针与滑动窗口", link: "two-pointers-and-sliding-window" }, + { text: "DFS 与 BFS", link: "dfs-bfs" }, + { text: "回溯算法", link: "backtracking" }, + { text: "动态规划", link: "dynamic-programming" }, + { text: "贪心算法", link: "greedy" }, + { text: "Top K 问题", link: "top-k" }, + { + text: "经典算法思想", + link: "classical-algorithm-problems-recommendations", + }, + { + text: "数据结构 LeetCode", + link: "common-data-structures-leetcode-recommendations", + }, + { text: "字符串算法题", link: "string-algorithm-problems" }, + { text: "链表算法题", link: "linkedlist-algorithm-problems" }, + { text: "剑指 Offer", link: "the-sword-refers-to-offer" }, + { text: "经典排序算法", link: "10-classical-sorting-algorithms" }, ], }, ]; diff --git a/docs/cs-basics/README.md b/docs/cs-basics/README.md index 535b3de6718..384f705b252 100644 --- a/docs/cs-basics/README.md +++ b/docs/cs-basics/README.md @@ -38,16 +38,16 @@ head: - 计算机网络重点理解分层模型、TCP/UDP、HTTP/HTTPS、DNS、ARP、NAT 和常见网络安全问题。 - 操作系统重点理解进程线程、内存管理、虚拟内存、零拷贝、I/O 多路复用、文件系统、Linux 基础和 Shell 使用。 -- 数据结构重点理解数组、链表、栈、队列、树、图、堆、红黑树和布隆过滤器的特点与适用场景。 -- 算法重点理解常见算法思想、复杂度分析、排序、字符串、链表和 LeetCode 高频题。 +- 数据结构重点理解数组、链表、栈、队列、哈希表、树、图、堆、Trie、并查集、跳表、红黑树、布隆过滤器和 LRU 的特点与适用场景。 +- 算法重点理解复杂度分析、二分、双指针、滑动窗口、DFS/BFS、回溯、动态规划、贪心、Top K、排序、字符串、链表和 LeetCode 高频题。 - 面试中要能把“概念 -> 原理 -> 对比 -> 场景 -> 常见问题”串成完整回答。 ## 建议阅读顺序 1. [计算机网络专题](./network/):先从分层模型、HTTP、TCP、DNS 和常见网络面试题入手,建立网络通信的整体认知。 2. [操作系统专题](./operating-system/):理解进程线程、内存、文件系统、Linux 和 Shell,为并发编程、JVM、数据库打基础。 -3. [数据结构专题](./data-structure/):掌握线性表、树、图、堆、红黑树、布隆过滤器等常见结构。 -4. [算法专题](./algorithms/):结合经典算法思想和 LeetCode 高频题进行练习。 +3. [数据结构专题](./data-structure/):掌握线性表、哈希表、树、图、堆、Trie、并查集、跳表、红黑树、布隆过滤器、LRU 等常见结构。 +4. [算法专题](./algorithms/):结合复杂度分析、核心算法模板和 LeetCode 高频题进行练习。 5. 回到面试题做查缺补漏:重点复盘网络和操作系统高频问题,再把数据结构与算法题按类型刷一遍。 ## 核心文章 @@ -79,13 +79,19 @@ head: - [数据结构专题](./data-structure/):按结构类型整理常见数据结构及图解。 - [线性数据结构详解](./data-structure/linear-data-structure.md):理解数组、链表、栈、队列的存储特点和操作复杂度。 +- [哈希表面试题总结](./data-structure/hash-table.md):理解哈希函数、哈希冲突、扩容和 Java `HashMap` 关联。 - [树结构详解](./data-structure/tree.md):掌握二叉树、二叉搜索树、AVL、B 树、B+ 树等常见树结构。 - [图详解](./data-structure/graph.md):理解图的表示、DFS、BFS 和最短路径等基础算法。 - [堆详解](./data-structure/heap.md)、[红黑树详解](./data-structure/red-black-tree.md)、[布隆过滤器详解](./data-structure/bloom-filter.md):补齐高频工程结构和面试考点。 +- [Trie 前缀树面试题总结](./data-structure/trie.md)、[并查集面试题总结](./data-structure/union-find.md)、[跳表面试题总结](./data-structure/skip-list.md)、[LRU 缓存面试题总结](./data-structure/lru-cache.md):补齐字符串集合、连通性、Redis ZSet 和缓存淘汰等高频场景。 ### 算法 - [算法专题](./algorithms/):整理常见算法思想、LeetCode 高频题和经典排序。 +- [时间复杂度和空间复杂度面试指南](./algorithms/complexity-analysis.md):掌握 Big O、递归复杂度和常见复杂度误判。 +- [二分查找面试题总结](./algorithms/binary-search.md)、[双指针与滑动窗口面试题总结](./algorithms/two-pointers-and-sliding-window.md):掌握数组、字符串、链表题里最常见的手写模板。 +- [DFS 与 BFS 面试题总结](./algorithms/dfs-bfs.md)、[回溯算法面试题总结](./algorithms/backtracking.md):掌握树、图、矩阵搜索、排列组合和路径枚举。 +- [动态规划面试题总结](./algorithms/dynamic-programming.md)、[贪心算法面试题总结](./algorithms/greedy.md)、[Top K 问题面试题总结](./algorithms/top-k.md):补齐最优值、区间贪心、堆和数据流相关题型。 - [经典算法思想总结](./algorithms/classical-algorithm-problems-recommendations.md):覆盖二分、双指针、滑动窗口、回溯、动态规划等常见思想。 - [常见数据结构经典 LeetCode 题目推荐](./algorithms/common-data-structures-leetcode-recommendations.md):按数据结构类型整理刷题路线。 - [几道常见的字符串算法题](./algorithms/string-algorithm-problems.md)、[几道常见的链表算法题](./algorithms/linkedlist-algorithm-problems.md):集中练习高频题型。 @@ -101,7 +107,7 @@ head: - 进程和线程有什么区别?什么是死锁,如何避免? - 操作系统内存管理、虚拟内存、分页和分段分别是什么? - 数组、链表、栈、队列、树、图、堆分别适合什么场景? -- 红黑树、B+ 树、布隆过滤器在工程中常用在哪里? +- 哈希表、红黑树、B+ 树、跳表、布隆过滤器、LRU 在工程中常用在哪里? - 刷算法题时如何按题型建立解题模板? ## 相关专题 diff --git a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md index a4452d627b0..1fa95ae45d0 100644 --- a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md +++ b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md @@ -775,4 +775,28 @@ public static int[] radixSort(int[] arr) { - - +## 面试复盘重点 + +排序算法面试一般不会要求你把 10 种排序全部手写,但复杂度、稳定性、原地排序和适用场景要能说清。 + +| 排序算法 | 平均时间复杂度 | 最坏时间复杂度 | 空间复杂度 | 稳定性 | 是否原地 | +| -------- | -------------- | -------------- | ---------- | -------------- | -------- | +| 冒泡排序 | `O(n^2)` | `O(n^2)` | `O(1)` | 稳定 | 是 | +| 选择排序 | `O(n^2)` | `O(n^2)` | `O(1)` | 不稳定 | 是 | +| 插入排序 | `O(n^2)` | `O(n^2)` | `O(1)` | 稳定 | 是 | +| 归并排序 | `O(nlogn)` | `O(nlogn)` | `O(n)` | 稳定 | 否 | +| 快速排序 | `O(nlogn)` | `O(n^2)` | `O(logn)` | 不稳定 | 是 | +| 堆排序 | `O(nlogn)` | `O(nlogn)` | `O(1)` | 不稳定 | 是 | +| 计数排序 | `O(n+k)` | `O(n+k)` | `O(n+k)` | 稳定 | 否 | +| 桶排序 | 和数据分布有关 | 可能退化 | `O(n+k)` | 取决于桶内排序 | 否 | +| 基数排序 | `O(nk)` | `O(nk)` | `O(n+k)` | 稳定 | 否 | + +几个高频追问: + +- 快排为什么最坏是 `O(n^2)`?如何降低退化概率?可以随机选 pivot 或三数取中。 +- 归并排序为什么稳定?因为合并时相等元素可以优先取左侧元素。 +- 堆排序为什么不稳定?因为堆调整和交换可能打乱相等元素原有顺序。 +- 插入排序什么时候表现好?数组基本有序且规模不大时。 +- 计数排序、桶排序、基数排序为什么不是通用排序?它们依赖数据范围、分布或位数。 + diff --git a/docs/cs-basics/algorithms/README.md b/docs/cs-basics/algorithms/README.md index 698bccabe9f..dfd7b586b14 100644 --- a/docs/cs-basics/algorithms/README.md +++ b/docs/cs-basics/algorithms/README.md @@ -1,6 +1,6 @@ --- -title: 算法专题:经典算法思想、LeetCode 高频题、字符串、链表、剑指 Offer 与排序 -description: 算法面试与刷题路线,涵盖经典算法思想、LeetCode 高频题、字符串算法、链表算法、剑指 Offer 和十大经典排序算法。 +title: 算法专题:面试刷题路线、核心模板与 LeetCode 高频题 +description: 算法面试复习路线,涵盖复杂度分析、二分、双指针、滑动窗口、DFS/BFS、回溯、动态规划、贪心、Top K、字符串、链表、排序和 LeetCode 高频题。 category: 计算机基础 tag: - 算法 @@ -13,58 +13,101 @@ sitemap: head: - - meta - name: keywords - content: 算法,算法面试题,LeetCode,剑指Offer,排序算法,字符串算法,链表算法,动态规划,回溯,后端面试 + content: 算法,算法面试题,LeetCode,刷题路线,二分查找,双指针,滑动窗口,DFS,BFS,回溯,动态规划,贪心,TopK,排序算法,字符串算法,链表算法,后端面试 --- -这份 **算法专题** 面向算法面试和基础能力训练,整理经典算法思想、常见数据结构 LeetCode 题目、字符串、链表、剑指 Offer 和排序算法。 +这份 **算法专题** 不是按教材顺序堆知识点,而是按面试刷题的真实路径整理:先搞清复杂度,再掌握二分、双指针、滑动窗口、DFS/BFS、回溯、动态规划、贪心、Top K 这些高频模板,最后用字符串、链表、排序和 LeetCode 题单做复盘。 + +算法题准备到后面,很容易陷入一个状态:题刷了不少,但换个条件就卡住。原因通常不是题量不够,而是没有把题目归到模板里。面试时真正有用的是:看到题目后能判断它像哪类问题,先写出可工作的版本,再解释复杂度和边界处理。 ## 适合谁看 -- 正在准备校招、社招算法题的同学。 -- 想按题型系统刷 LeetCode,而不是随机刷题的读者。 -- 数据结构已经有基础,但缺少算法解题模板的后端开发者。 -- 需要在面试前快速复盘字符串、链表、排序和常见算法思想的工程师。 +- 正在准备校招、社招算法题,希望按题型系统刷 LeetCode 的同学。 +- 已经刷过一些题,但复盘时说不清“这题为什么这么做”的读者。 +- 数据结构基础还可以,但缺少算法模板和边界处理经验的后端开发者。 +- 面试前只有 7 到 30 天,需要快速找回手感的工程师。 + +## 算法面试考什么 + +算法面试一般不只是看你能不能 AC 一道题,更多是在看 4 件事: -## 学习重点 +| 考察点 | 面试里的具体表现 | 复习时要做什么 | +| ---------- | ------------------------------------ | ------------------------------ | +| 题型识别 | 这题是二分、滑动窗口、回溯还是 DP | 按题型刷,不要完全随机刷 | +| 代码稳定性 | 边界、空指针、下标、循环条件是否可靠 | 每个模板准备 2 到 3 个边界样例 | +| 复杂度表达 | 能否说清时间复杂度和空间复杂度 | 每做完一题都写复杂度 | +| 迁移能力 | 条件变化后能否改模板 | 一类题至少刷基础题和变体题 | -- 算法题要先按题型建立模板,再通过变体题训练迁移能力。 -- 常见思想包括二分、双指针、滑动窗口、递归、回溯、贪心、动态规划、图搜索等。 -- 字符串和链表题高频且容易考察边界处理。 -- 排序算法不只要背复杂度,还要理解稳定性、原地排序和适用场景。 -- 刷题复盘比刷题数量更重要,要记录错误原因、模板和边界条件。 +如果只能记一句话:**先按题型建模板,再用代表题练迁移。** ## 建议阅读顺序 -1. [经典算法思想总结](./classical-algorithm-problems-recommendations.md):先按思想建立算法题分类框架。 -2. [常见数据结构经典 LeetCode 题目推荐](./common-data-structures-leetcode-recommendations.md):结合数组、链表、栈、队列、树、图等结构刷题。 -3. [几道常见的字符串算法题](./string-algorithm-problems.md):集中练习字符串匹配、回文、子串等高频题。 -4. [几道常见的链表算法题](./linkedlist-algorithm-problems.md):掌握反转链表、快慢指针、环检测、合并链表等题型。 -5. [剑指 Offer 部分编程题](./the-sword-refers-to-offer.md) 和 [十大经典排序算法总结](./10-classical-sorting-algorithms.md):用于面试前复盘。 +1. [时间复杂度和空间复杂度面试指南](./complexity-analysis.md):先把 Big O、递归复杂度和常见误判讲清楚。 +2. [二分查找面试题总结](./binary-search.md):练基础二分、左右边界和答案二分。 +3. [双指针与滑动窗口面试题总结](./two-pointers-and-sliding-window.md):解决数组、字符串、链表里的高频题。 +4. [DFS 与 BFS 面试题总结](./dfs-bfs.md):掌握树、图、矩阵搜索和层序遍历。 +5. [回溯算法面试题总结](./backtracking.md):集中处理组合、排列、子集和棋盘问题。 +6. [动态规划面试题总结](./dynamic-programming.md):从状态定义和转移方程入手,不靠背题。 +7. [贪心算法面试题总结](./greedy.md) 和 [Top K 问题面试题总结](./top-k.md):补齐排序贪心、堆、快排分区和桶计数。 +8. [几道常见的字符串算法题](./string-algorithm-problems.md)、[几道常见的链表算法题](./linkedlist-algorithm-problems.md)、[十大经典排序算法总结](./10-classical-sorting-algorithms.md):按专题做面试前复盘。 + +## 核心模板 + +| 模板 | 识别信号 | 重点文章 | +| -------- | ------------------------------------------ | ------------------------------------------------------------------ | +| 二分查找 | 有序、单调、最小可行值、最大可行值 | [二分查找面试题总结](./binary-search.md) | +| 双指针 | 原地修改、两端收缩、快慢追赶、链表定位 | [双指针与滑动窗口面试题总结](./two-pointers-and-sliding-window.md) | +| 滑动窗口 | 连续子数组、连续子串、最长/最短窗口 | [双指针与滑动窗口面试题总结](./two-pointers-and-sliding-window.md) | +| DFS/BFS | 树遍历、图遍历、矩阵连通块、层序最短步数 | [DFS 与 BFS 面试题总结](./dfs-bfs.md) | +| 回溯 | 枚举所有方案、路径选择、组合排列、棋盘约束 | [回溯算法面试题总结](./backtracking.md) | +| 动态规划 | 最优值、计数、能否到达、子序列、背包 | [动态规划面试题总结](./dynamic-programming.md) | +| 贪心 | 每一步选择当前最合适的对象,常和排序搭配 | [贪心算法面试题总结](./greedy.md) | +| Top K | 第 K 大、前 K 高频、数据流、优先级 | [Top K 问题面试题总结](./top-k.md) | + +## 7 天速刷路线 + +时间很紧时,不建议从难题开始。7 天路线的目标是恢复模板和手写稳定性: + +| 天数 | 重点 | 建议动作 | +| ------- | ----------------- | ---------------------------------------------- | +| 第 1 天 | 复杂度 + 排序 | 复盘 Big O、快排、归并、堆排序和稳定性 | +| 第 2 天 | 二分 + 双指针 | 写左右边界模板、两数之和、三数之和、删除重复项 | +| 第 3 天 | 滑动窗口 + 字符串 | 写最长无重复子串、最小覆盖子串、回文相关题 | +| 第 4 天 | 链表 | 写反转链表、环形链表、删除倒数第 N 个节点 | +| 第 5 天 | 树和 BFS | 写前中后序遍历、层序遍历、最近公共祖先 | +| 第 6 天 | 回溯 + DP | 写子集、组合、零钱兑换、最长递增子序列 | +| 第 7 天 | Top K + 复盘 | 写第 K 大、前 K 高频,整理错题和边界样例 | + +## 30 天系统路线 -## 核心文章 +30 天路线不用追求每天刷很多题。更靠谱的节奏是:每天 1 到 3 道代表题,题后写 5 行复盘。 -- [经典算法思想总结](./classical-algorithm-problems-recommendations.md):整理常见算法思想和对应 LeetCode 题目。 -- [常见数据结构经典 LeetCode 题目推荐](./common-data-structures-leetcode-recommendations.md):按数据结构类型推荐经典题目。 -- [几道常见的字符串算法题](./string-algorithm-problems.md):覆盖字符串处理、匹配、回文和子串相关问题。 -- [几道常见的链表算法题](./linkedlist-algorithm-problems.md):覆盖链表反转、合并、环检测、删除节点等高频题。 -- [剑指 Offer 部分编程题](./the-sword-refers-to-offer.md):整理经典面试编程题。 -- [十大经典排序算法总结](./10-classical-sorting-algorithms.md):讲解冒泡、选择、插入、归并、快速、堆排序等经典排序算法。 +| 阶段 | 时间 | 目标 | +| -------- | -------------- | ------------------------------------------------ | +| 第一阶段 | 第 1 到 5 天 | 复杂度、数组、链表、栈、队列,保证基础模板能手写 | +| 第二阶段 | 第 6 到 12 天 | 二分、双指针、滑动窗口、字符串,重点练边界 | +| 第三阶段 | 第 13 到 18 天 | 树、图、DFS/BFS、并查集,建立搜索题框架 | +| 第四阶段 | 第 19 到 24 天 | 回溯、动态规划、贪心,重点练状态定义和剪枝 | +| 第五阶段 | 第 25 到 30 天 | Top K、排序、综合题和错题复盘,准备面试讲解 | -## 高频问题 +## 高频问题自测 -- 刷算法题应该按题型刷,还是按难度随机刷? -- 二分查找最容易错在哪里?如何处理边界? -- 双指针和滑动窗口分别适合什么问题? -- 回溯、DFS、动态规划有什么区别? -- 链表题为什么容易出错?如何处理虚拟头节点和边界? -- 字符串题常见解法有哪些? -- 常见排序算法的时间复杂度、空间复杂度和稳定性分别是什么? -- 面试前如何用有限时间复盘算法题? +- 时间复杂度为什么要看最高阶?递归复杂度怎么算? +- 二分查找的 `left < right` 和 `left <= right` 怎么选? +- 双指针和滑动窗口有什么区别? +- DFS 和 BFS 分别适合什么问题?什么时候需要 `visited`? +- 回溯和 DFS 是什么关系?剪枝应该放在哪里? +- 动态规划为什么难?状态定义和遍历顺序怎么确定? +- 贪心为什么需要证明?面试中答到什么程度够用? +- Top K 用堆、快排分区还是桶计数,怎么选? +- 排序算法的稳定性、原地排序、最好/最坏复杂度分别是什么? ## 相关专题 - [计算机基础知识体系](../) - [数据结构专题](../data-structure/) +- [常见数据结构经典 LeetCode 题目推荐](./common-data-structures-leetcode-recommendations.md) +- [经典算法思想总结](./classical-algorithm-problems-recommendations.md) - [Java 集合](../../java/collection/java-collection-questions-01.md) - [面试准备](../../interview-preparation/) - [计算机基础书籍推荐](../../books/cs-basics.md) diff --git a/docs/cs-basics/algorithms/backtracking.md b/docs/cs-basics/algorithms/backtracking.md new file mode 100644 index 00000000000..8bf95957cb7 --- /dev/null +++ b/docs/cs-basics/algorithms/backtracking.md @@ -0,0 +1,208 @@ +--- +title: 回溯算法面试题总结:组合、排列、子集、剪枝与 Java 模板 +description: 回溯算法面试题总结,讲解回溯题型识别、组合模板、排列模板、子集模板、去重剪枝、复杂度分析和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: 回溯算法,回溯模板,组合,排列,子集,N皇后,剪枝,Java回溯,LeetCode回溯,算法面试题 +--- + +回溯题的特点很明显:题目让你找所有方案、所有路径、所有组合,或者在一堆选择里试探。它和 DFS 很像,区别在于回溯更强调“选择 -> 递归 -> 撤销选择”。 + +面试里写回溯,最重要的是先说清递归函数的含义。函数含义稳了,参数、结束条件和撤销选择就不容易乱。 + +## 面试考察重点 + +- 能写组合、排列、子集三类模板。 +- 能解释 `path`、`startIndex`、`used` 的作用。 +- 能根据题目判断是否需要去重。 +- 能做简单剪枝,避免无效搜索。 +- 能说清复杂度和结果规模有关。 + +## 回溯题怎么想? + +回溯题可以先画成一棵“选择树”。树上的每一层代表一次选择,根节点代表还没选,叶子节点代表一个完整方案。 + +写代码前先回答 4 个问题: + +1. 路径是什么?通常是已经选择的元素,代码里叫 `path`。 +2. 选择列表是什么?当前还能选哪些元素。 +3. 结束条件是什么?什么时候把 `path` 放进答案。 +4. 是否需要剪枝?哪些选择一定不会得到合法答案。 + +回溯模板里的“撤销选择”不是形式主义。因为 `path` 是复用的,当前分支试完后必须还原现场,给下一个分支使用。 + +## 组合模板 + +组合不关心顺序,通常用 `startIndex` 控制下一层从哪里开始: + +```java +List> combine(int n, int k) { + List> ans = new ArrayList<>(); + backtrack(1, n, k, new ArrayList<>(), ans); + return ans; +} + +void backtrack(int start, int n, int k, List path, List> ans) { + if (path.size() == k) { + ans.add(new ArrayList<>(path)); + return; + } + for (int i = start; i <= n; i++) { + path.add(i); + backtrack(i + 1, n, k, path, ans); + path.remove(path.size() - 1); + } +} +``` + +组合问题不关心顺序,所以 `[1, 2]` 和 `[2, 1]` 是同一个答案。`start` 的作用就是保证后续只能选当前位置之后的数字,避免重复。 + +如果要从 `1..n` 里选 `k` 个数,还可以剪枝: + +```java +for (int i = start; i <= n - (k - path.size()) + 1; i++) { + // ... +} +``` + +含义是:如果从 `i` 开始,剩余数字数量已经不够凑满 `k` 个,就没必要继续枚举。 + +## 排列模板 + +排列关心顺序,通常用 `used` 标记元素是否已经被选过: + +```java +List> permute(int[] nums) { + List> ans = new ArrayList<>(); + boolean[] used = new boolean[nums.length]; + backtrack(nums, used, new ArrayList<>(), ans); + return ans; +} + +void backtrack(int[] nums, boolean[] used, List path, List> ans) { + if (path.size() == nums.length) { + ans.add(new ArrayList<>(path)); + return; + } + for (int i = 0; i < nums.length; i++) { + if (used[i]) { + continue; + } + used[i] = true; + path.add(nums[i]); + backtrack(nums, used, path, ans); + path.remove(path.size() - 1); + used[i] = false; + } +} +``` + +排列问题关心顺序,所以每一层都可以从所有数字里选,只是不能重复使用同一个数字。`used[i]` 表示 `nums[i]` 是否已经在当前路径里。 + +如果数组里有重复数字,排列去重要比组合更容易写错。通常先排序,然后在同一层跳过“前一个相同数字还没被使用”的情况: + +```java +if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) { + continue; +} +``` + +这句的作用是固定重复数字在同一层的选择顺序,避免生成重复排列。 + +## 子集模板 + +子集问题通常每个节点都是一个答案: + +```java +List> subsets(int[] nums) { + List> ans = new ArrayList<>(); + backtrack(0, nums, new ArrayList<>(), ans); + return ans; +} + +void backtrack(int start, int[] nums, List path, List> ans) { + ans.add(new ArrayList<>(path)); + for (int i = start; i < nums.length; i++) { + path.add(nums[i]); + backtrack(i + 1, nums, path, ans); + path.remove(path.size() - 1); + } +} +``` + +子集问题和组合问题很像,但它不是只在固定长度时收集答案,而是每到一个节点都收集一次。因为任何长度的路径都可以是一个子集。 + +如果题目要求去重,比如输入 `[1, 2, 2]`,仍然是先排序,再跳过同一层重复元素: + +```java +if (i > start && nums[i] == nums[i - 1]) { + continue; +} +``` + +## 去重怎么做? + +如果输入有重复元素,通常先排序,再在同一层跳过重复选择: + +```java +if (i > start && nums[i] == nums[i - 1]) { + continue; +} +``` + +这句的含义是:同一层里,前一个相同数字已经作为开头尝试过了,当前数字再作为开头会产生重复结果。 + +## 过程示意和边界样例 + +以 `n = 3, k = 2` 的组合问题为例,选择树可以简化成下面这样: + +| 第一层选择 | 第二层可选 | 产生结果 | +| ---------- | ---------- | ------------------ | +| 选 1 | 2、3 | `[1, 2]`、`[1, 3]` | +| 选 2 | 3 | `[2, 3]` | +| 选 3 | 无 | 不足 2 个数,剪枝 | + +回溯题建议检查这些边界: + +| 输入 | 重点 | +| ------------ | ----------------------- | +| 空数组 | 子集题通常要返回 `[[]]` | +| `k = 0` | 组合题是否返回空组合 | +| 有重复元素 | 是否先排序并做同层去重 | +| 结果只有一个 | 是否正确拷贝 `path` | + +常见错误写法: + +```java +ans.add(path); // 错:后续 path 会继续变化 +``` + +应该写成: + +```java +ans.add(new ArrayList<>(path)); +``` + +回溯里的 `path` 是复用对象,不拷贝就会导致答案里的列表一起被后续递归修改。 + +## 易错点 + +- 加入答案时要拷贝 `path`,不能直接放引用。 +- 组合用 `startIndex`,排列用 `used`,不要混着写。 +- 去重通常要先排序。 +- 剪枝条件必须不影响正确答案。 +- 回溯复杂度经常和结果数量相同量级,不要随手写 `O(n)`。 + +## 推荐练习题 + +- [77. 组合](https://leetcode.cn/problems/combinations/) +- [78. 子集](https://leetcode.cn/problems/subsets/) +- [46. 全排列](https://leetcode.cn/problems/permutations/) +- [39. 组合总和](https://leetcode.cn/problems/combination-sum/) +- [51. N 皇后](https://leetcode.cn/problems/n-queens/) + + diff --git a/docs/cs-basics/algorithms/binary-search.md b/docs/cs-basics/algorithms/binary-search.md new file mode 100644 index 00000000000..291508d9e3c --- /dev/null +++ b/docs/cs-basics/algorithms/binary-search.md @@ -0,0 +1,252 @@ +--- +title: 二分查找面试题总结:左右边界、答案二分与 Java 模板 +description: 二分查找面试题总结,系统讲解基础二分、左边界、右边界、答案二分、Java 手写模板、复杂度分析和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: 二分查找,二分查找模板,左右边界,答案二分,Java二分查找,LeetCode二分查找,算法面试题 +--- + +二分查找最容易让人翻车的地方不是思想,而是边界。`left`、`right`、`mid`、循环条件、返回值,只要有一个含义没想清楚,就很容易写出死循环或者漏掉答案。 + +面试里判断能不能用二分,先看一句话:**答案所在空间是否有单调性**。数组有序只是最直观的一种情况,最小速度、最小容量、最小天数这类题,也可以在答案范围上二分。 + +## 面试考察重点 + +- 能写出基础二分模板。 +- 能处理左边界、右边界。 +- 能识别答案二分,而不是只会在数组里找数。 +- 能解释为什么循环会结束,为什么不会漏答案。 +- 能说出时间复杂度是 `O(logn)`,空间复杂度通常是 `O(1)`。 + +## 什么时候想到二分? + +不要把二分查找理解成“只能在有序数组里找数字”。它真正依赖的是 **单调性**。 + +常见单调性有两类: + +| 类型 | 例子 | 判断方式 | +| -------- | ------------------------------ | ------------------------------------------ | +| 数组单调 | 有序数组中找 `target` | `nums[mid]` 和 `target` 比较后能排除一半 | +| 答案单调 | 求最小速度、最小容量、最少天数 | 某个答案可行时,更大的答案也可行,或反过来 | + +比如“爱吃香蕉的珂珂”里,吃香蕉速度越快,越容易在规定时间内吃完。这里数组本身不需要有序,单调的是“速度”和“是否能吃完”之间的关系。 + +面试时可以这样判断: + +1. 题目是否在找一个位置、边界或最小/最大可行值? +2. 如果猜一个答案 `x`,能不能在 `O(n)` 或更低复杂度内判断它是否可行? +3. `x` 变大或变小时,可行性是否单调变化? + +三个问题都能回答上来,基本就可以尝试二分。 + +## 基础二分模板 + +适合在有序数组中查找一个确定值: + +```java +int binarySearch(int[] nums, int target) { + int left = 0; + int right = nums.length - 1; + while (left <= right) { + int mid = left + (right - left) / 2; + if (nums[mid] == target) { + return mid; + } else if (nums[mid] < target) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return -1; +} +``` + +这个模板里,搜索区间是闭区间 `[left, right]`,所以循环条件是 `left <= right`。每次排除 `mid`,因此更新成 `mid + 1` 或 `mid - 1`。 + +用一句话记这个模板:**区间里每个位置都还可能是答案,循环结束时区间为空。** + +举个例子,数组 `[1, 3, 5, 7, 9]` 中找 `7`: + +1. `left = 0`,`right = 4`,`mid = 2`,`nums[mid] = 5`,目标在右侧。 +2. 更新 `left = mid + 1 = 3`。 +3. `mid = 3`,找到 `7`。 + +如果查找 `6`,最后会出现 `left > right`,说明闭区间已经被排空,返回 `-1`。 + +## 左边界模板 + +找第一个大于等于 `target` 的位置: + +```java +int lowerBound(int[] nums, int target) { + int left = 0; + int right = nums.length; + while (left < right) { + int mid = left + (right - left) / 2; + if (nums[mid] >= target) { + right = mid; + } else { + left = mid + 1; + } + } + return left; +} +``` + +这个模板的搜索区间是左闭右开 `[left, right)`。`right` 初始化为 `nums.length`,返回值可能等于 `nums.length`,表示数组中不存在大于等于 `target` 的位置。 + +左边界模板的关键不是“找到 target”,而是“找到第一个满足条件的位置”。这个写法能自然处理目标不存在的情况。 + +比如数组 `[1, 2, 2, 2, 4]`,找第一个大于等于 `2` 的位置: + +- 当 `nums[mid] >= 2`,`mid` 可能就是答案,所以不能排除 `mid`,更新 `right = mid`。 +- 当 `nums[mid] < 2`,`mid` 和它左边都不可能是答案,更新 `left = mid + 1`。 + +循环结束时,`left == right`,这个位置就是第一个满足条件的位置。 + +## 右边界模板 + +找最后一个小于等于 `target` 的位置,可以先找第一个大于 `target` 的位置,再减 1: + +```java +int upperBound(int[] nums, int target) { + int left = 0; + int right = nums.length; + while (left < right) { + int mid = left + (right - left) / 2; + if (nums[mid] > target) { + right = mid; + } else { + left = mid + 1; + } + } + return left - 1; +} +``` + +这种写法的好处是左右边界只记一套思路:找第一个满足条件的位置。 + +右边界容易写错,推荐转化成左边界问题: + +- 最后一个小于等于 `target` 的位置 = 第一个大于 `target` 的位置 - 1。 +- 最后一个小于 `target` 的位置 = 第一个大于等于 `target` 的位置 - 1。 + +这样不需要维护两套模板,面试手写时更稳。 + +## 答案二分 + +答案二分不是在数组里找元素,而是在答案范围里找最小可行值或最大可行值。 + +典型问题:给定若干堆香蕉和总时间 `h`,求最小吃香蕉速度。速度越快,越容易在 `h` 小时内吃完,这就是单调性。 + +这类题通常分两步: + +1. 确定答案范围。比如速度最小是 `1`,最大不超过最大那堆香蕉数。 +2. 写 `check` 函数。给定一个速度,判断能不能在 `h` 小时内吃完。 + +```java +int minEatingSpeed(int[] piles, int h) { + int left = 1; + int right = 0; + for (int pile : piles) { + right = Math.max(right, pile); + } + while (left < right) { + int mid = left + (right - left) / 2; + if (canFinish(piles, h, mid)) { + right = mid; + } else { + left = mid + 1; + } + } + return left; +} + +boolean canFinish(int[] piles, int h, int speed) { + long hours = 0; + for (int pile : piles) { + hours += (pile + speed - 1) / speed; + } + return hours <= h; +} +``` + +这里为什么返回 `left`?因为循环一直在找“第一个可行速度”。当 `canFinish(mid)` 为 true,说明 `mid` 可行,但可能还有更小的速度也可行,所以收缩右边界。最后左右边界重合的位置,就是最小可行速度。 + +答案二分的 `check` 函数往往比二分本身更重要。面试时建议先把 `check` 的含义说清楚,再写二分框架。 + +## 三类二分怎么选? + +| 目标 | 推荐模板 | 返回值 | +| ---------------------------- | -------- | ----------------------------- | +| 找到某个等于 `target` 的下标 | 基础二分 | 找到返回下标,找不到返回 `-1` | +| 找第一个满足条件的位置 | 左边界 | 返回 `left`,可能等于数组长度 | +| 找最小可行答案 | 答案二分 | 返回最终的 `left` | + +如果题目里有“第一个”“最后一个”“最小可行”“最大可行”,不要急着写基础二分,先判断是不是边界问题。 + +## 过程示意和边界样例 + +以左边界模板为例,数组 `[1, 2, 2, 2, 4]` 中找第一个大于等于 `2` 的位置: + +| 轮次 | `left` | `right` | `mid` | 判断 | 下一步 | +| ---- | ------ | ------- | ----- | --------------- | ----------- | +| 1 | 0 | 5 | 2 | `nums[2] >= 2` | `right = 2` | +| 2 | 0 | 2 | 1 | `nums[1] >= 2` | `right = 1` | +| 3 | 0 | 1 | 0 | `nums[0] < 2` | `left = 1` | +| 结束 | 1 | 1 | - | `left == right` | 返回 1 | + +几个边界样例建议手写前先过一遍: + +| 输入 | 目标 | 预期 | +| ----------- | ---------- | ------------------------------------ | +| `[]` | `1` | 返回 `-1` 或插入位置 `0`,看题目要求 | +| `[1]` | `1` | 能命中唯一元素 | +| `[1, 1, 1]` | 左边界 `1` | 返回 `0` | +| `[1, 3, 5]` | 左边界 `4` | 返回 `2` | +| `[1, 3, 5]` | 左边界 `6` | 返回 `3` | + +常见错误写法: + +```java +while (left < right) { + int mid = (left + right) / 2; + if (nums[mid] >= target) { + right = mid - 1; // 错:mid 可能就是左边界,不能直接排除 + } else { + left = mid + 1; + } +} +``` + +左边界里,当 `nums[mid] >= target` 时,`mid` 仍然可能是答案,所以应该写 `right = mid`。 + +## 易错点 + +- `mid = (left + right) / 2` 可能整数溢出,推荐写成 `left + (right - left) / 2`。 +- 不要混用闭区间和左闭右开区间的更新方式。 +- 找边界时,命中目标后通常不能直接返回,还要继续收缩区间。 +- 答案二分要先证明单调性,不能看到“最小值”就硬套。 +- `canFinish` 这类判断函数里可能需要 `long`,避免累计值溢出。 + +## 高频问题自测 + +- `left < right` 和 `left <= right` 有什么区别? +- 二分查找为什么是 `O(logn)`? +- 找左边界时,为什么命中后要移动 `right`? +- 什么是答案二分?它和普通二分有什么区别? +- 二分查找一定要求数组有序吗? + +## 推荐练习题 + +- [704. 二分查找](https://leetcode.cn/problems/binary-search/) +- [35. 搜索插入位置](https://leetcode.cn/problems/search-insert-position/) +- [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/) +- [875. 爱吃香蕉的珂珂](https://leetcode.cn/problems/koko-eating-bananas/) +- [1011. 在 D 天内送达包裹的能力](https://leetcode.cn/problems/capacity-to-ship-packages-within-d-days/) + + diff --git a/docs/cs-basics/algorithms/classical-algorithm-problems-recommendations.md b/docs/cs-basics/algorithms/classical-algorithm-problems-recommendations.md index 8f8ac974930..36b728e90db 100644 --- a/docs/cs-basics/algorithms/classical-algorithm-problems-recommendations.md +++ b/docs/cs-basics/algorithms/classical-algorithm-problems-recommendations.md @@ -1,116 +1,162 @@ --- -title: 经典算法思想总结(含LeetCode题目推荐) -description: 总结常见算法思想与解题模板,配合典型题目推荐,强调思维路径与复杂度权衡,快速构建解题体系。 +title: 经典算法思想总结(含 LeetCode 题目推荐) +description: 总结二分、双指针、滑动窗口、DFS/BFS、回溯、动态规划、贪心、分治、拓扑排序、并查集、位运算等高频算法思想,并给出题型识别、模板、代表题和复盘重点。 category: 计算机基础 tag: - 算法 + - LeetCode + - 面试 head: - - meta - name: keywords - content: 贪心,分治,回溯,动态规划,二分,双指针,算法思想,题目推荐 + content: 算法思想,二分查找,双指针,滑动窗口,DFS,BFS,回溯,动态规划,贪心,分治,拓扑排序,并查集,位运算,LeetCode题目推荐 --- -## 贪心算法 - -### 算法思想 - -贪心的本质是选择每一阶段的局部最优,从而达到全局最优。 - -### 一般解题步骤 +算法思想不要孤立背。面试里更有用的问法是:什么信号提示我该用它?模板里最容易错的地方在哪里?如果面试官改条件,我应该从哪个变量或状态开始调整? -- 将问题分解为若干个子问题 -- 找出适合的贪心策略 -- 求解每一个子问题的最优解 -- 将局部最优解堆叠成全局最优解 +这份题单按思想组织,每一类都给出“识别信号、常用模板、代表题、复盘重点”。题目数量控制在能代表模板的范围内,先把这些题讲明白,比机械刷更多题更划算。 -### LeetCode +## 怎么用这份题单 -455.分发饼干: +不要一上来就把所有题目按顺序刷完。更适合面试准备的方式是:先读对应的模板文章,确认自己能手写核心代码,再做“必刷题”,最后用“进阶题”检查边界和变体。 -121.买卖股票的最佳时机: +| 目标 | 建议动作 | +| -------------- | --------------------------------------------------------------------------------------------------------------------------------------- | +| 快速建立模板 | 先读 [二分查找](./binary-search.md)、[双指针与滑动窗口](./two-pointers-and-sliding-window.md)、[DFS/BFS](./dfs-bfs.md) 这些高频模板文章 | +| 补齐搜索和 DP | 继续读 [回溯算法](./backtracking.md)、[动态规划](./dynamic-programming.md),每类至少手写 2 道基础题 | +| 面试前查漏补缺 | 用 [贪心算法](./greedy.md)、[Top K 问题](./top-k.md)、[并查集](../data-structure/union-find.md) 补齐常见变体 | +| 复盘自己的答案 | 每题写下题型识别信号、核心变量含义、复杂度、边界样例。如果这些讲不清,说明这题还没真正掌握 | -122.买卖股票的最佳时机 II: - -55.跳跃游戏: - -45.跳跃游戏 II: - -## 动态规划 +## 二分查找 -### 算法思想 +| 项目 | 内容 | +| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 有序数组、单调条件、找边界、找最小可行值或最大可行值 | +| 常用模板 | 基础二分、左边界、右边界、答案二分 | +| 必刷题 | [704. 二分查找](https://leetcode.cn/problems/binary-search/)、[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/) | +| 进阶题 | [35. 搜索插入位置](https://leetcode.cn/problems/search-insert-position/)、[875. 爱吃香蕉的珂珂](https://leetcode.cn/problems/koko-eating-bananas/) | +| 复盘重点 | 循环条件、`mid` 计算、边界更新后是否会死循环 | -动态规划中每一个状态一定是由上一个状态推导出来的,这一点就区分于贪心,贪心没有状态推导,而是从局部直接选最优的。 +## 双指针 -经典题目:01 背包、完全背包 +| 项目 | 内容 | +| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 有序数组、原地修改、两端向中间收缩、链表快慢追赶 | +| 常用模板 | 左右指针、快慢指针、读写指针 | +| 必刷题 | [26. 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/)、[977. 有序数组的平方](https://leetcode.cn/problems/squares-of-a-sorted-array/) | +| 进阶题 | [15. 三数之和](https://leetcode.cn/problems/3sum/)、[142. 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii/) | +| 复盘重点 | 指针含义要固定,去重条件不要漏,链表题先画 3 个节点 | -### 一般解题步骤 +## 滑动窗口 -- 确定 dp 数组(dp table)以及下标的含义 -- 确定递推公式 -- dp 数组如何初始化 -- 确定遍历顺序 -- 举例推导 dp 数组 +| 项目 | 内容 | +| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 连续子数组、连续子串、最长/最短、窗口内满足某个条件 | +| 常用模板 | 固定窗口、可变窗口、计数 Map | +| 必刷题 | [3. 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters/)、[209. 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum/) | +| 进阶题 | [76. 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring/)、[438. 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string/) | +| 复盘重点 | 什么时候扩右边界,什么时候缩左边界,窗口内变量如何维护 | -### LeetCode +## DFS 与 BFS -509.斐波那契数: - -746.使用最小花费爬楼梯: - -416.分割等和子集: - -518.零钱兑换: - -647.回文子串: - -516.最长回文子序列: +| 项目 | 内容 | +| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 树遍历、图遍历、矩阵连通块、最短步数、层序遍历 | +| 常用模板 | 递归 DFS、栈模拟 DFS、队列 BFS、层序 BFS | +| 必刷题 | [102. 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)、[200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) | +| 进阶题 | [994. 腐烂的橘子](https://leetcode.cn/problems/rotting-oranges/)、[127. 单词接龙](https://leetcode.cn/problems/word-ladder/) | +| 复盘重点 | 访问标记、越界判断、BFS 层数统计 | ## 回溯算法 -### 算法思想 - -回溯算法实际上一个类似枚举的搜索尝试过程,主要是在搜索尝试过程中寻找问题的解,当发现已不满足求解条件时,就 “回溯” 返回,尝试别的路径。其本质就是穷举。 - -经典题目:8 皇后 +| 项目 | 内容 | +| -------- | ------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 枚举所有方案、路径选择、组合、排列、子集、棋盘约束 | +| 常用模板 | 路径 `path`、选择列表、递归层、撤销选择 | +| 必刷题 | [77. 组合](https://leetcode.cn/problems/combinations/)、[78. 子集](https://leetcode.cn/problems/subsets/) | +| 进阶题 | [39. 组合总和](https://leetcode.cn/problems/combination-sum/)、[51. N 皇后](https://leetcode.cn/problems/n-queens/) | +| 复盘重点 | 递归参数代表什么,剪枝条件放在循环前还是循环内 | -### 一般解题步骤 - -- 针对所给问题,定义问题的解空间,它至少包含问题的一个(最优)解。 -- 确定易于搜索的解空间结构,使得能用回溯法方便地搜索整个解空间。 -- 以深度优先的方式搜索解空间,并且在搜索过程中用剪枝函数避免无效搜索。 - -### LeetCode - -77.组合: - -39.组合总和: - -40.组合总和 II: +## 动态规划 -78.子集: +| 项目 | 内容 | +| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| 识别信号 | 求最优值、方案数、能否到达、子序列、背包、区间合并 | +| 常用模板 | 一维 DP、二维 DP、滚动数组、背包 DP | +| 必刷题 | [70. 爬楼梯](https://leetcode.cn/problems/climbing-stairs/)、[322. 零钱兑换](https://leetcode.cn/problems/coin-change/) | +| 进阶题 | [300. 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence/)、[416. 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum/) | +| 复盘重点 | `dp[i]` 的含义、初始化、遍历顺序、是否能压缩空间 | -90.子集 II: +## 贪心算法 -51.N 皇后: +| 项目 | 内容 | +| -------- | ----------------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 每一步选择当前最合适的对象,常伴随排序、区间、跳跃、买卖 | +| 常用模板 | 排序后选择、维护最远边界、区间合并/覆盖 | +| 必刷题 | [455. 分发饼干](https://leetcode.cn/problems/assign-cookies/)、[55. 跳跃游戏](https://leetcode.cn/problems/jump-game/) | +| 进阶题 | [45. 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii/)、[435. 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals/) | +| 复盘重点 | 贪心策略为什么不会错,反例能否推翻当前策略 | ## 分治算法 -### 算法思想 - -将一个规模为 N 的问题分解为 K 个规模较小的子问题,这些子问题相互独立且与原问题性质相同。求出子问题的解,就可得到原问题的解。 - -经典题目:二分查找、汉诺塔问题 - -### 一般解题步骤 - -- 将原问题分解为若干个规模较小,相互独立,与原问题形式相同的子问题; -- 若子问题规模较小而容易被解决则直接解,否则递归地解各个子问题; -- 将各个子问题的解合并为原问题的解。 - -### LeetCode - -108.将有序数组转换成二叉搜索数: - -148.排序列表: - -23.合并 k 个升序链表: +| 项目 | 内容 | +| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 问题可以拆成同类子问题,子问题结果能合并 | +| 常用模板 | 递归拆分、子问题求解、合并结果 | +| 必刷题 | [108. 将有序数组转换为二叉搜索树](https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/)、[148. 排序链表](https://leetcode.cn/problems/sort-list/) | +| 进阶题 | [23. 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists/)、[215. 数组中的第 K 个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) | +| 复盘重点 | 递归出口、左右区间是否重叠、合并复杂度 | + +## 拓扑排序 + +| 项目 | 内容 | +| -------- | ----------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 课程依赖、任务依赖、有向无环图、判断是否能完成 | +| 常用模板 | 入度数组 + 队列,或 DFS 三色标记 | +| 必刷题 | [207. 课程表](https://leetcode.cn/problems/course-schedule/) | +| 进阶题 | [210. 课程表 II](https://leetcode.cn/problems/course-schedule-ii/)、[269. 火星词典](https://leetcode.cn/problems/alien-dictionary/) | +| 复盘重点 | 入度什么时候减,结果数量是否等于节点数量 | + +## 并查集 + +| 项目 | 内容 | +| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| 识别信号 | 连通性、分组、朋友圈、冗余边、等式关系 | +| 常用模板 | `find`、`union`、路径压缩、按大小合并 | +| 必刷题 | [547. 省份数量](https://leetcode.cn/problems/number-of-provinces/) | +| 进阶题 | [684. 冗余连接](https://leetcode.cn/problems/redundant-connection/)、[990. 等式方程的可满足性](https://leetcode.cn/problems/satisfiability-of-equality-equations/) | +| 复盘重点 | `find` 是否路径压缩,什么时候判断冲突 | + +## 位运算 + +| 项目 | 内容 | +| -------- | ------------------------------------------------------------------------------------------------------------------------------- | +| 识别信号 | 奇偶、是否为 2 的幂、只出现一次、状态压缩 | +| 常用模板 | 异或、与运算清最低位 1、位掩码枚举 | +| 必刷题 | [136. 只出现一次的数字](https://leetcode.cn/problems/single-number/)、[231. 2 的幂](https://leetcode.cn/problems/power-of-two/) | +| 进阶题 | [191. 位 1 的个数](https://leetcode.cn/problems/number-of-1-bits/)、[78. 子集](https://leetcode.cn/problems/subsets/) | +| 复盘重点 | 异或性质、`n & (n - 1)` 的含义、负数位表示 | + +## 面试前 7 天速刷清单 + +| 天数 | 重点 | 推荐题 | +| ------- | -------------------------- | ------------------ | +| 第 1 天 | 二分 + 双指针 | 704、34、26、15 | +| 第 2 天 | 滑动窗口 | 3、209、76、438 | +| 第 3 天 | DFS/BFS | 102、200、994、127 | +| 第 4 天 | 回溯 | 77、78、39、51 | +| 第 5 天 | 动态规划 | 70、322、300、416 | +| 第 6 天 | 贪心 + 分治 | 55、45、148、215 | +| 第 7 天 | 拓扑排序 + 并查集 + 位运算 | 207、547、684、136 | + +## 30 天系统刷题路线 + +| 阶段 | 时间 | 目标 | +| --------- | -------------- | ---------------------------------------- | +| 模板入门 | 第 1 到 6 天 | 二分、双指针、滑动窗口,每类做 3 到 5 道 | +| 搜索题 | 第 7 到 12 天 | DFS/BFS、回溯,重点写访问标记和撤销选择 | +| DP 和贪心 | 第 13 到 20 天 | 每天 1 道 DP,穿插贪心区间题 | +| 图和结构 | 第 21 到 25 天 | 拓扑排序、并查集、堆、Trie | +| 复盘 | 第 26 到 30 天 | 只看错题和变体题,练口述复杂度 | + + diff --git a/docs/cs-basics/algorithms/common-data-structures-leetcode-recommendations.md b/docs/cs-basics/algorithms/common-data-structures-leetcode-recommendations.md index 4a004e27905..45943f64057 100644 --- a/docs/cs-basics/algorithms/common-data-structures-leetcode-recommendations.md +++ b/docs/cs-basics/algorithms/common-data-structures-leetcode-recommendations.md @@ -1,69 +1,125 @@ --- -title: 常见数据结构经典LeetCode题目推荐 -description: 按数据结构类别整理经典 LeetCode 题目清单,聚焦高频与核心考点,助力系统化刷题与巩固。 +title: 常见数据结构经典 LeetCode 题目推荐 +description: 按数组、链表、栈、队列、哈希表、树、图、堆、Trie、并查集等结构整理 LeetCode 高频题,给出题型、模板、面试价值和复盘重点。 category: 计算机基础 tag: - 算法 + - 数据结构 + - LeetCode head: - - meta - name: keywords - content: LeetCode,数组,链表,栈,队列,二叉树,题目推荐,刷题 + content: LeetCode,数据结构,数组,链表,栈,队列,哈希表,二叉树,图,堆,Trie,并查集,题目推荐,刷题路线 --- -## 数组 +刷数据结构题,不建议只按难度从 Easy 刷到 Hard。更稳的方式是按结构建立题型:数组看下标和区间,链表看指针,栈队列看顺序约束,树图看遍历,堆看优先级,哈希表看快速定位。 -704.二分查找: +下面的题单控制在面试高频和模板代表题范围内。每类先做“必刷题”,再做“进阶题”。题目做完后,至少写下复杂度、边界样例和这题属于哪个模板。 -80.删除有序数组中的重复项 II: +## 怎么用这份题单 -977.有序数组的平方: +数据结构题不要只记结论。每刷一类题,先回到对应结构看一次“存储方式、核心操作、复杂度”,再动手写题。这样面试官追问 Java 集合、Redis、MySQL 索引或缓存场景时,答案不会只停在题解层面。 -## 链表 +| 结构 | 先读什么 | 刷题时重点看什么 | +| ------------------ | ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------- | +| 数组、链表、栈队列 | [线性数据结构详解](../data-structure/linear-data-structure.md)、[双指针与滑动窗口](./two-pointers-and-sliding-window.md) | 下标、指针更新、入栈出栈时机 | +| 哈希表 | [哈希表面试题总结](../data-structure/hash-table.md) | key 的设计、计数时机、冲突和扩容 | +| 树和图 | [树结构详解](../data-structure/tree.md)、[图详解](../data-structure/graph.md)、[DFS 与 BFS](./dfs-bfs.md) | 递归返回值、访问标记、BFS 层数统计 | +| 堆和 Top K | [堆详解](../data-structure/heap.md)、[Top K 问题面试题总结](./top-k.md) | 堆大小、比较器、数据流场景 | +| Trie 和并查集 | [Trie 前缀树面试题总结](../data-structure/trie.md)、[并查集面试题总结](../data-structure/union-find.md) | 节点结构、结束标记、路径压缩、连通判断 | +| LRU | [LRU 缓存面试题总结](../data-structure/lru-cache.md) | 哈希表和双向链表如何保持 O(1) | -707.设计链表: +## 数组 -206.反转链表: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| -------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | ----------------------------- | +| 二分查找 | [704. 二分查找](https://leetcode.cn/problems/binary-search/) | [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/) | 考循环条件和边界 | `left <= right`、左右边界更新 | +| 原地修改 | [26. 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/) | [80. 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii/) | 考双指针写法 | 慢指针含义、覆盖时机 | +| 双指针 | [977. 有序数组的平方](https://leetcode.cn/problems/squares-of-a-sorted-array/) | [15. 三数之和](https://leetcode.cn/problems/3sum/) | 高频数组题 | 排序后去重、左右指针移动 | +| 前缀和 | [303. 区域和检索 - 数组不可变](https://leetcode.cn/problems/range-sum-query-immutable/) | [560. 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k/) | 子数组题入口 | 前缀和含义、哈希表计数 | -92.反转链表 II: +## 链表 -61.旋转链表: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| -------- | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------- | -------------------------------- | +| 基础操作 | [707. 设计链表](https://leetcode.cn/problems/design-linked-list/) | [24. 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs/) | 考节点操作基本功 | 虚拟头节点、插入删除顺序 | +| 链表反转 | [206. 反转链表](https://leetcode.cn/problems/reverse-linked-list/) | [92. 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii/) | 高频手写题 | `prev`、`cur`、`next` 的更新顺序 | +| 快慢指针 | [141. 环形链表](https://leetcode.cn/problems/linked-list-cycle/) | [142. 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii/) | 常见追问题 | 相遇点和入环点推导 | +| 删除节点 | [19. 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list/) | [61. 旋转链表](https://leetcode.cn/problems/rotate-list/) | 考边界处理 | 链表长度、头节点被删 | ## 栈与队列 -232.用栈实现队列: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| -------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- | --------------- | -------------------------- | +| 结构模拟 | [232. 用栈实现队列](https://leetcode.cn/problems/implement-queue-using-stacks/) | [225. 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues/) | 考结构理解 | 入队栈、出队栈职责 | +| 括号匹配 | [20. 有效的括号](https://leetcode.cn/problems/valid-parentheses/) | [394. 字符串解码](https://leetcode.cn/problems/decode-string/) | 字符串栈题入口 | 什么时候入栈、什么时候弹栈 | +| 单调栈 | [739. 每日温度](https://leetcode.cn/problems/daily-temperatures/) | [84. 柱状图中最大的矩形](https://leetcode.cn/problems/largest-rectangle-in-histogram/) | 中高频题型 | 栈中维护递增还是递减 | +| 单调队列 | [239. 滑动窗口最大值](https://leetcode.cn/problems/sliding-window-maximum/) | [862. 和至少为 K 的最短子数组](https://leetcode.cn/problems/shortest-subarray-with-sum-at-least-k/) | Hard 题常见模板 | 队首过期、队尾维护单调性 | -225.用队列实现栈: +## 哈希表 -347.前 K 个高频元素: - -239.滑动窗口最大值: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| ------------- | --------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | ------------ | ------------------------------ | +| 快速查找 | [1. 两数之和](https://leetcode.cn/problems/two-sum/) | [49. 字母异位词分组](https://leetcode.cn/problems/group-anagrams/) | 哈希表入门 | key 的设计 | +| 计数 | [242. 有效的字母异位词](https://leetcode.cn/problems/valid-anagram/) | [347. 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements/) | 高频统计题 | 数组计数和 Map 计数怎么选 | +| 前缀和 + 哈希 | [560. 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k/) | [974. 和可被 K 整除的子数组](https://leetcode.cn/problems/subarray-sums-divisible-by-k/) | 子数组题常考 | 先查再加,避免把当前前缀算进去 | +| 缓存结构 | [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/) | [460. LFU 缓存](https://leetcode.cn/problems/lfu-cache/) | 手写设计题 | 哈希表和双向链表协作 | ## 二叉树 -105.从前序与中序遍历构造二叉树: - -117.填充每个节点的下一个右侧节点指针 II: - -236.二叉树的最近公共祖先: - -129.求根节点到叶节点数字之和: - -102.二叉树的层序遍历: - -530.二叉搜索树的最小绝对差: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| ------------ | ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- | ---------- | ----------------------- | +| 遍历 | [144. 二叉树的前序遍历](https://leetcode.cn/problems/binary-tree-preorder-traversal/) | [102. 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/) | 树题基础 | 递归边界、队列层数 | +| 路径问题 | [112. 路径总和](https://leetcode.cn/problems/path-sum/) | [124. 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum/) | DFS 高频 | 返回值和全局答案分开 | +| 构造树 | [105. 从前序与中序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/) | [106. 从中序与后序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/) | 考递归区间 | 下标范围别写乱 | +| 最近公共祖先 | [236. 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/) | [235. 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/) | 高频追问 | 普通树和 BST 的解法差异 | ## 图 -200.岛屿数量: - -207.课程表: - -210.课程表 II: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| ------------ | ------------------------------------------------------------------ | ----------------------------------------------------------------------- | ------------ | ---------------------- | +| 网格 DFS/BFS | [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) | [695. 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island/) | 图搜索入门 | 越界、访问标记 | +| 拓扑排序 | [207. 课程表](https://leetcode.cn/problems/course-schedule/) | [210. 课程表 II](https://leetcode.cn/problems/course-schedule-ii/) | 依赖关系题 | 入度数组、队列 | +| 最短路径 | [994. 腐烂的橘子](https://leetcode.cn/problems/rotting-oranges/) | [127. 单词接龙](https://leetcode.cn/problems/word-ladder/) | BFS 层序应用 | 每层步数统计 | +| 连通性 | [547. 省份数量](https://leetcode.cn/problems/number-of-provinces/) | [684. 冗余连接](https://leetcode.cn/problems/redundant-connection/) | 并查集入口 | `find` 和 `union` 模板 | ## 堆 -215.数组中的第 K 个最大元素: - -216.数据流的中位数: - -217.前 K 个高频元素: +| 题型 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| -------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | ----------- | ------------------ | +| 第 K 大 | [215. 数组中的第 K 个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) | [703. 数据流中的第 K 大元素](https://leetcode.cn/problems/kth-largest-element-in-a-stream/) | Top K 高频 | 小顶堆大小保持为 K | +| 频率统计 | [347. 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements/) | [692. 前 K 个高频单词](https://leetcode.cn/problems/top-k-frequent-words/) | 哈希表 + 堆 | 比较器写法 | +| 双堆 | [295. 数据流的中位数](https://leetcode.cn/problems/find-median-from-data-stream/) | [480. 滑动窗口中位数](https://leetcode.cn/problems/sliding-window-median/) | 进阶设计题 | 大顶堆和小顶堆平衡 | + +## Trie 与并查集 + +| 结构 | 必刷题 | 进阶题 | 面试价值 | 复盘重点 | +| ---------- | -------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ------------ | ---------------------- | +| Trie | [208. 实现 Trie](https://leetcode.cn/problems/implement-trie-prefix-tree/) | [211. 添加与搜索单词](https://leetcode.cn/problems/design-add-and-search-words-data-structure/) | 字符串集合题 | 节点结构、结束标记 | +| Trie + DFS | [212. 单词搜索 II](https://leetcode.cn/problems/word-search-ii/) | [648. 单词替换](https://leetcode.cn/problems/replace-words/) | 中高频题 | 前缀剪枝 | +| 并查集 | [547. 省份数量](https://leetcode.cn/problems/number-of-provinces/) | [1319. 连通网络的操作次数](https://leetcode.cn/problems/number-of-operations-to-make-network-connected/) | 连通性模板 | 路径压缩 | +| 并查集判环 | [684. 冗余连接](https://leetcode.cn/problems/redundant-connection/) | [990. 等式方程的可满足性](https://leetcode.cn/problems/satisfiability-of-equality-equations/) | 图题常见变体 | 先合并等式,再检查冲突 | + +## 面试前 7 天速刷清单 + +| 天数 | 题型 | 推荐题 | +| ------- | ------------- | ------------------------------- | +| 第 1 天 | 数组 + 哈希表 | 704、26、1、560 | +| 第 2 天 | 链表 | 206、92、141、19 | +| 第 3 天 | 栈队列 | 20、232、739、239 | +| 第 4 天 | 树 | 144、102、105、236 | +| 第 5 天 | 图 | 200、207、994、547 | +| 第 6 天 | 堆 + Top K | 215、347、295 | +| 第 7 天 | 综合复盘 | LRU、三数之和、岛屿数量、课程表 | + +## 30 天系统刷题路线 + +| 阶段 | 时间 | 目标 | +| ---------- | -------------- | -------------------------------------- | +| 基础结构 | 第 1 到 6 天 | 数组、链表、栈、队列,每类至少 3 道 | +| 查找与统计 | 第 7 到 10 天 | 哈希表、前缀和、二分查找 | +| 树和图 | 第 11 到 18 天 | 树遍历、构造树、LCA、DFS/BFS、拓扑排序 | +| 进阶结构 | 第 19 到 24 天 | 堆、Trie、并查集、LRU | +| 综合复盘 | 第 25 到 30 天 | 只做错题、变体题和口述复杂度 | + + diff --git a/docs/cs-basics/algorithms/complexity-analysis.md b/docs/cs-basics/algorithms/complexity-analysis.md new file mode 100644 index 00000000000..c17a9754e9d --- /dev/null +++ b/docs/cs-basics/algorithms/complexity-analysis.md @@ -0,0 +1,185 @@ +--- +title: 时间复杂度和空间复杂度面试指南:Big O、递归复杂度与常见误区 +description: 时间复杂度和空间复杂度面试指南,系统讲解 Big O、循环复杂度、递归复杂度、空间复杂度、输入规模判断和算法面试常见复杂度误区。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: 时间复杂度,空间复杂度,Big O,递归复杂度,循环复杂度,算法复杂度,复杂度分析,算法面试题,LeetCode复杂度 +--- + +复杂度分析是算法面试的第一道门。面试官不一定要求你把证明写得很严,但会希望你能说清:这段代码跑了多少轮、额外用了多少空间、输入规模变大后会发生什么。 + +先把一个边界讲清楚:复杂度分析通常看输入规模趋近很大时的增长趋势,不是精确运行时间。`O(n)` 不代表一定比 `O(nlogn)` 快,常数、数据规模、缓存命中和实现细节都会影响真实耗时。不过面试里先按 Big O 说清增长量级,再补一句实际场景的限制,就够用了。 + +## 面试考察重点 + +- 能根据循环、递归、数据结构操作判断时间复杂度。 +- 能区分额外空间和输入本身占用的空间。 +- 能说清最好、最坏、平均复杂度分别适合哪些算法。 +- 遇到递归代码时,能用递归树或子问题规模分析。 +- 不把 `HashMap`、排序、堆操作都默认当成 `O(1)`。 + +## 面试里怎么讲复杂度? + +回答复杂度时,不要只报一个结论。更好的说法是“代码做了什么,因此复杂度是多少”。 + +比如两数之和: + +```text +数组遍历一遍,每个元素在 HashMap 中做一次查询和一次插入,哈希表操作平均 O(1),所以时间复杂度是 O(n)。额外使用了一个 HashMap 存元素到下标的映射,最坏会存 n 个元素,所以空间复杂度是 O(n)。 +``` + +这个回答比单说 `O(n)` 更稳,因为它把推导过程讲出来了。面试官如果继续追问哈希表最坏情况,也有接话空间。 + +## 常见复杂度量级 + +| 复杂度 | 常见场景 | 面试备注 | +| ---------- | ---------------------------------------- | ---------------------- | +| `O(1)` | 数组按下标访问、栈顶操作、哈希表平均查询 | 哈希表最坏可能退化 | +| `O(logn)` | 二分查找、堆上浮/下沉、平衡树查询 | 每轮把规模缩小一部分 | +| `O(n)` | 单次遍历数组、链表、字符串 | 看是否真的只扫一遍 | +| `O(nlogn)` | 快排平均、归并排序、堆排序 | 排序题最常见量级 | +| `O(n^2)` | 双重循环、枚举两两组合 | 面试中要警惕是否能优化 | +| `O(2^n)` | 子集枚举、部分回溯 | 结果数量本身就是指数级 | +| `O(n!)` | 全排列、旅行商暴力解 | 只适合小规模输入 | + +一般来说,算法题输入规模会暗示可接受复杂度: + +| 输入规模 | 通常可接受的复杂度 | +| ----------- | ---------------------- | +| `n <= 20` | 指数级、回溯、状态压缩 | +| `n <= 100` | `O(n^3)` 有时可以 | +| `n <= 1000` | `O(n^2)` 常见 | +| `n <= 10^5` | `O(nlogn)` 或 `O(n)` | +| `n >= 10^6` | 通常要接近 `O(n)` | + +这不是硬规则,但能帮你在面试里判断暴力解是否可能超时。 + +## 循环复杂度怎么判断? + +普通循环看执行次数: + +```java +for (int i = 0; i < n; i++) { + // O(1) +} +``` + +这段是 `O(n)`。 + +嵌套循环不能只看有几层,要看每层真实次数: + +```java +for (int i = 0; i < n; i++) { + for (int j = i; j < n; j++) { + // O(1) + } +} +``` + +内层次数是 `n + (n - 1) + ... + 1`,也就是 `n(n + 1) / 2`,复杂度记作 `O(n^2)`。 + +如果循环变量每次翻倍,通常是 `O(logn)`: + +```java +for (int i = 1; i < n; i *= 2) { + // O(1) +} +``` + +还有一种容易误判的情况是双指针: + +```java +while (left < n && right < n) { + if (needMoveRight()) { + right++; + } else { + left++; + } +} +``` + +虽然是 `while` 里嵌了条件,但 `left` 和 `right` 都只单调递增,最多各移动 `n` 次,所以整体是 `O(n)`,不是 `O(n^2)`。 + +## 递归复杂度怎么判断? + +递归复杂度可以先看两个问题: + +1. 每层递归有多少个子问题? +2. 每层除了递归调用,还做了多少额外工作? + +二分查找每次只进入一个子问题,规模减半: + +```java +int binarySearch(int[] nums, int target, int left, int right) { + if (left > right) { + return -1; + } + int mid = left + (right - left) / 2; + if (nums[mid] == target) { + return mid; + } + if (nums[mid] < target) { + return binarySearch(nums, target, mid + 1, right); + } + return binarySearch(nums, target, left, mid - 1); +} +``` + +递归深度是 `logn`,每层只做 `O(1)` 工作,所以时间复杂度是 `O(logn)`,递归栈空间是 `O(logn)`。 + +归并排序每层拆成两个子问题,每层合并总工作量是 `O(n)`,层数是 `logn`,所以时间复杂度是 `O(nlogn)`,额外数组空间是 `O(n)`。 + +再看一个反例:普通递归斐波那契。 + +```java +int fib(int n) { + if (n <= 1) { + return n; + } + return fib(n - 1) + fib(n - 2); +} +``` + +它不是 `O(n)`,因为每次会继续拆成两个递归调用,很多子问题被重复计算,时间复杂度接近 `O(2^n)`。如果加记忆化数组,每个状态只算一次,时间复杂度就变成 `O(n)`,空间复杂度也是 `O(n)`。 + +## 空间复杂度看什么? + +空间复杂度看算法运行过程中额外使用的空间,常见来源有: + +- 新建数组、哈希表、队列、栈。 +- 递归调用栈。 +- 排序或合并时的辅助空间。 +- 结果集是否算额外空间,要看题目要求。面试时可以主动说明。 + +比如反转链表的迭代写法只用了几个指针,空间复杂度是 `O(1)`。如果用递归反转,虽然没有显式创建数组,但递归栈深度是 `n`,空间复杂度是 `O(n)`。 + +## 常见易错点 + +- 排序不是免费的。先排序再双指针,时间复杂度通常至少是 `O(nlogn)`。 +- `HashMap` 查询平均是 `O(1)`,但最坏情况不是。 +- 递归没有显式创建集合,也可能有递归栈空间。 +- 二维矩阵遍历通常是 `O(mn)`,不要顺手写成 `O(n)`。 +- BFS 的队列空间不是常数,最坏可能存下一层大量节点。 +- 回溯题的复杂度经常和结果数量有关,不能只看递归深度。 + +## 高频问题自测 + +- 为什么复杂度分析通常忽略常数? +- `O(n)` 一定比 `O(nlogn)` 快吗? +- 快排的平均和最坏时间复杂度分别是多少? +- 递归算法的空间复杂度怎么算? +- DFS 和 BFS 的时间复杂度为什么通常是 `O(V + E)`? +- 哈希表查询为什么平均是 `O(1)`? + +## 推荐练习题 + +- [704. 二分查找](https://leetcode.cn/problems/binary-search/) +- [912. 排序数组](https://leetcode.cn/problems/sort-an-array/) +- [206. 反转链表](https://leetcode.cn/problems/reverse-linked-list/) +- [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) + + diff --git a/docs/cs-basics/algorithms/dfs-bfs.md b/docs/cs-basics/algorithms/dfs-bfs.md new file mode 100644 index 00000000000..d93e5dad755 --- /dev/null +++ b/docs/cs-basics/algorithms/dfs-bfs.md @@ -0,0 +1,194 @@ +--- +title: DFS 与 BFS 面试题总结:树、图、矩阵搜索与最短路径模板 +description: DFS 与 BFS 面试题总结,讲解深度优先搜索、广度优先搜索、树遍历、图遍历、矩阵搜索、层序遍历、最短路径和 Java 模板。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: DFS,BFS,深度优先搜索,广度优先搜索,树遍历,图遍历,矩阵搜索,层序遍历,最短路径,Java DFS,Java BFS,LeetCode +--- + +DFS 和 BFS 是树、图、矩阵题的基础。面试里不会只问“DFS 是什么”,更常见的是给你一个岛屿、课程依赖、最短步数或二叉树层序遍历,让你选搜索方式并写出边界处理。 + +一个简单判断:需要一路走到底、枚举路径或处理连通块时,优先想 DFS;需要按层推进、求最短步数时,优先想 BFS。 + +## 面试考察重点 + +- 能写递归 DFS、队列 BFS。 +- 能说出树和图搜索的复杂度。 +- 能处理 `visited`,避免重复访问和死循环。 +- 能区分“遍历所有节点”和“求最短步数”。 +- 能把矩阵题转换成图搜索。 + +## 怎么选择 DFS 还是 BFS? + +DFS 和 BFS 都能遍历节点,但它们的天然优势不同。 + +| 目标 | 更常用 | 原因 | +| ---------------- | ----------------- | ---------------------------- | +| 遍历所有节点 | DFS 或 BFS 都可以 | 只要不重复访问即可 | +| 找连通块面积 | DFS 更顺手 | 一路递归扩展,代码短 | +| 求无权图最短步数 | BFS | 按层推进,第一次到达就是最短 | +| 枚举所有路径 | DFS | 路径天然存在递归栈里 | +| 二叉树层序遍历 | BFS | 队列正好按层处理 | + +如果题目里出现“最少几步”“最短路径”“扩散到所有位置”,先想 BFS。如果题目里出现“所有方案”“是否存在一条路径”“连通块大小”,先想 DFS。 + +## DFS 模板 + +矩阵 DFS 常见写法: + +```java +void dfs(char[][] grid, int i, int j) { + if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length) { + return; + } + if (grid[i][j] != '1') { + return; + } + grid[i][j] = '2'; + dfs(grid, i + 1, j); + dfs(grid, i - 1, j); + dfs(grid, i, j + 1); + dfs(grid, i, j - 1); +} +``` + +这里直接把访问过的陆地改成 `'2'`,相当于使用原数组做访问标记。如果题目不允许修改输入,就单独建 `boolean[][] visited`。 + +DFS 的递归函数要先定义清楚含义。上面这段代码可以解释为:从 `(i, j)` 出发,把和它连通的所有陆地都标记掉。 + +这个含义决定了代码顺序: + +1. 越界直接返回。 +2. 当前格子不是陆地直接返回。 +3. 标记当前格子,避免重复访问。 +4. 继续访问上下左右 4 个方向。 + +很多 DFS bug 都来自第 3 步写晚了。如果先递归邻居,再标记当前节点,就可能在两个相邻格子之间来回递归。 + +## BFS 模板 + +BFS 适合层序遍历和最短步数: + +```java +int bfs(int[][] grid, int startX, int startY) { + int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}; + Queue queue = new ArrayDeque<>(); + queue.offer(new int[] {startX, startY}); + boolean[][] visited = new boolean[grid.length][grid[0].length]; + visited[startX][startY] = true; + int step = 0; + while (!queue.isEmpty()) { + int size = queue.size(); + for (int k = 0; k < size; k++) { + int[] cur = queue.poll(); + for (int[] dir : dirs) { + int x = cur[0] + dir[0]; + int y = cur[1] + dir[1]; + if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || visited[x][y]) { + continue; + } + visited[x][y] = true; + queue.offer(new int[] {x, y}); + } + } + step++; + } + return step; +} +``` + +如果题目要求最短路径,通常在发现目标节点时返回当前步数,而不是等队列清空。 + +BFS 的关键是“按层处理”。队列里一开始是第 0 层节点,每轮取出当前队列大小 `size`,只处理这一层的节点;它们扩展出来的新节点属于下一层。 + +为什么无权图 BFS 能求最短路径?因为每条边的代价相同。BFS 第一次到达某个节点时,一定是用了最少的边数。后面即使还能再次到达,也不会更短,所以可以直接标记访问。 + +多源 BFS 也很常见。比如“腐烂的橘子”里,所有烂橘子同时开始扩散。做法是先把所有初始烂橘子都入队,再按层扩散。 + +## 树搜索和图搜索的区别 + +树没有环,很多时候不需要 `visited`。图可能有环,必须考虑重复访问。 + +| 场景 | 是否常用 `visited` | 说明 | +| -------------- | ------------------ | ---------------------- | +| 二叉树递归遍历 | 通常不用 | 节点没有回到父节点的边 | +| 无向图遍历 | 需要 | 否则两个节点会互相访问 | +| 有向图遍历 | 通常需要 | 可能存在环 | +| 矩阵搜索 | 需要 | 上下左右可能走回原点 | + +## 复杂度 + +图搜索常用 `V` 表示顶点数,`E` 表示边数。邻接表存储时,DFS 和 BFS 的时间复杂度通常是 `O(V + E)`,空间复杂度是 `O(V)`。 + +矩阵搜索如果矩阵大小是 `m * n`,每个格子最多访问一次,时间复杂度是 `O(mn)`,访问标记或队列空间最坏也是 `O(mn)`。 + +## 矩阵题怎么转成图? + +矩阵中的每个格子都可以看成图里的一个节点。上下左右 4 个方向,就是这个节点连出去的边。 + +常用方向数组: + +```java +int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}; +``` + +遍历邻居时只需要做 3 件事: + +1. 计算新坐标。 +2. 判断是否越界。 +3. 判断是否已经访问过,或是否符合题目要求。 + +如果题目允许斜向移动,把方向数组扩展成 8 个方向即可。不要在代码里手写 4 段几乎相同的递归调用,方向数组更不容易漏条件。 + +## 过程示意和边界样例 + +以岛屿数量为例,遇到一个未访问过的陆地格子,就从它开始 DFS/BFS,把整座岛都标记掉。 + +| 步骤 | 操作 | 目的 | +| ---- | ---------------------- | ---------------------- | +| 1 | 扫描矩阵,找到一个 `1` | 发现一座新岛 | +| 2 | 岛屿数量加 1 | 记录连通块 | +| 3 | 从当前格子 DFS/BFS | 把这座岛所有陆地标记掉 | +| 4 | 继续扫描后续格子 | 避免重复统计同一座岛 | + +矩阵搜索建议检查这些边界: + +| 输入 | 重点 | +| ------------ | ---------------------------------- | +| 空矩阵 | 是否先判断行列长度 | +| 全是水 | 结果应该是 0 | +| 全是陆地 | 只能统计成 1 个连通块 | +| 只有斜向相邻 | 如果题目只允许上下左右,不能算连通 | + +常见错误写法: + +```java +void dfs(char[][] grid, int i, int j) { + dfs(grid, i + 1, j); + grid[i][j] = '2'; // 错:标记太晚,可能来回递归 +} +``` + +访问标记要在递归扩展邻居之前完成。图和矩阵里只要存在回边或相邻互访,标记太晚就可能重复访问甚至栈溢出。 + +## 易错点 + +- BFS 入队时就标记访问,避免同一个节点被重复入队。 +- DFS 递归深度过大可能栈溢出,面试中可以说明可改成显式栈。 +- 矩阵题先判断越界,再访问数组。 +- 无向图要注意从子节点走回父节点的问题。 +- 求最短步数时,BFS 的层数统计要和队列当前层大小绑定。 + +## 推荐练习题 + +- [102. 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/) +- [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) +- [695. 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island/) +- [994. 腐烂的橘子](https://leetcode.cn/problems/rotting-oranges/) +- [207. 课程表](https://leetcode.cn/problems/course-schedule/) + + diff --git a/docs/cs-basics/algorithms/dynamic-programming.md b/docs/cs-basics/algorithms/dynamic-programming.md new file mode 100644 index 00000000000..b6dafdb6bae --- /dev/null +++ b/docs/cs-basics/algorithms/dynamic-programming.md @@ -0,0 +1,200 @@ +--- +title: 动态规划面试题总结:状态转移、背包、子序列与 Java 模板 +description: 动态规划面试题总结,讲解状态定义、状态转移、初始化、遍历顺序、0-1 背包、完全背包、子序列、区间 DP 和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: 动态规划,DP,状态转移,背包问题,0-1背包,完全背包,子序列,区间DP,Java动态规划,LeetCode动态规划 +--- + +动态规划难,不是因为代码一定长,而是因为状态定义一旦错了,后面的转移方程、初始化和遍历顺序都会跟着错。 + +面试里不要一上来就背模板。先问自己两个问题:这个问题能不能拆成子问题?当前答案是否依赖前面已经算过的答案?如果这两个问题都成立,再考虑 DP。 + +## 面试考察重点 + +- 能说清 `dp[i]` 或 `dp[i][j]` 的含义。 +- 能写出状态转移方程。 +- 能处理初始化和遍历顺序。 +- 能判断是否可以压缩空间。 +- 能区分背包、子序列、区间等常见类型。 + +## 什么时候考虑动态规划? + +DP 不是看到“最值”就套。更靠谱的判断是看两个条件: + +1. 问题能不能拆成规模更小的同类问题。 +2. 子问题会不会被反复计算。 + +比如斐波那契数列,`f(n)` 依赖 `f(n - 1)` 和 `f(n - 2)`,而 `f(n - 2)` 会在递归里被反复计算。把这些中间结果存下来,就是 DP。 + +面试里可以先从暴力递归说起,再说明哪里重复计算,最后把递归改成记忆化搜索或表格递推。这个过程比直接背 `dp` 数组更容易让面试官相信你真的理解。 + +## DP 五步法 + +1. 定义状态:`dp[i]` 到底表示什么。 +2. 写转移:当前状态从哪些状态推出来。 +3. 做初始化:没有前置状态时答案是什么。 +4. 定遍历顺序:先算哪些状态,后算哪些状态。 +5. 检查样例:用一个小输入手推数组。 + +其中最重要的是第 1 步。`dp[i]` 的含义一旦含糊,后面的代码就会变成试出来的。 + +一个好的状态定义通常满足: + +- 能覆盖题目要问的答案。 +- 能从更小状态推出来。 +- 维度尽量少,但不要为了省空间把含义写乱。 + +## 一维 DP 示例 + +爬楼梯问题: + +```java +int climbStairs(int n) { + if (n <= 2) { + return n; + } + int prev2 = 1; + int prev1 = 2; + for (int i = 3; i <= n; i++) { + int cur = prev1 + prev2; + prev2 = prev1; + prev1 = cur; + } + return prev1; +} +``` + +状态含义:到第 `i` 阶有多少种走法。转移方程:`dp[i] = dp[i - 1] + dp[i - 2]`。 + +这题还可以从递归推出来: + +```text +到第 i 阶的最后一步,要么从 i-1 走 1 步上来,要么从 i-2 走 2 步上来。 +``` + +所以 `dp[i]` 只依赖前两个状态,可以把数组压缩成两个变量。空间压缩的前提是你确认旧状态以后不会再用。 + +## 0-1 背包模板 + +每个物品只能选一次: + +```java +int knapsack01(int[] weights, int[] values, int capacity) { + int[] dp = new int[capacity + 1]; + for (int i = 0; i < weights.length; i++) { + for (int j = capacity; j >= weights[i]; j--) { + dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]); + } + } + return dp[capacity]; +} +``` + +容量要倒序遍历,避免同一个物品在一轮里被重复使用。 + +倒序遍历是 0-1 背包最容易被问的点。假设容量正序遍历,计算 `dp[j]` 时可能用到本轮刚更新过的 `dp[j - weight]`,等于同一个物品被选了多次。这就变成完全背包了。 + +0-1 背包的典型问法不一定直接叫背包,像“能否分成两个和相等的子集”,可以转成:能否从数组里选一些数,使它们的和等于总和的一半。 + +## 完全背包模板 + +每个物品可以选多次: + +```java +int unboundedKnapsack(int[] weights, int[] values, int capacity) { + int[] dp = new int[capacity + 1]; + for (int i = 0; i < weights.length; i++) { + for (int j = weights[i]; j <= capacity; j++) { + dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]); + } + } + return dp[capacity]; +} +``` + +容量正序遍历,允许当前物品被重复使用。 + +完全背包里,正序遍历容量正是为了允许当前物品重复使用。比如零钱兑换,每种硬币可以用多次,计算更大金额时可以基于当前硬币已经参与过的状态继续转移。 + +如果题目问的是“组合数”还是“排列数”,遍历顺序也会变: + +- 组合数:通常先遍历物品,再遍历容量。 +- 排列数:通常先遍历容量,再遍历物品。 + +这块面试不一定问很深,但遇到零钱兑换 II 这类题时很关键。 + +## 常见题型 + +| 题型 | 状态设计 | 代表题 | +| --------------- | ------------------------------------------------------ | ------------- | +| 爬楼梯/打家劫舍 | `dp[i]` 表示前 `i` 个位置的最优值 | 70、198 | +| 背包 | `dp[j]` 表示容量为 `j` 时的最优值或方案数 | 416、518、322 | +| 子序列 | `dp[i]` 或 `dp[i][j]` 表示以某位置结尾或两个前缀的答案 | 300、1143 | +| 回文 | `dp[i][j]` 表示区间 `[i, j]` 是否满足条件或最优值 | 647、516 | +| 路径 | `dp[i][j]` 表示走到格子 `(i, j)` 的答案 | 62、64 | + +## 记忆化搜索和递推怎么选? + +两种写法都在存子问题答案。 + +| 写法 | 特点 | 适合场景 | +| ---------- | ---------------------------- | -------------------------- | +| 记忆化搜索 | 从目标状态往下递归,按需计算 | 状态转移复杂、递归更自然 | +| 递推 | 从小状态往大状态填表 | 遍历顺序清楚、方便压缩空间 | + +如果一开始想不清遍历顺序,可以先写记忆化搜索。等状态关系清楚后,再改成递推。很多树形 DP、区间 DP,用记忆化搜索更容易写对。 + +## 过程示意和边界样例 + +以爬楼梯为例,`n = 5` 时的状态变化如下: + +| `i` | `dp[i - 2]` | `dp[i - 1]` | `dp[i]` | +| --- | ----------- | ----------- | ------- | +| 3 | 1 | 2 | 3 | +| 4 | 2 | 3 | 5 | +| 5 | 3 | 5 | 8 | + +这张表要看的不是数字本身,而是状态只依赖前两个位置,所以可以压缩成两个变量。 + +DP 题建议检查这些边界: + +| 输入 | 重点 | +| ---------------- | ------------------------ | +| `n = 0` 或空数组 | 初始化是否覆盖 | +| 只有 1 个元素 | 是否越界访问 `dp[1]` | +| 无法组成目标 | 初始值是否能表达“不可达” | +| 求方案数 | 初始化和遍历顺序是否正确 | + +常见错误写法: + +```java +for (int j = weights[i]; j <= capacity; j++) { + dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]); // 0-1 背包中是错的 +} +``` + +0-1 背包中容量要倒序遍历,否则本轮刚更新的状态会被再次使用,相当于同一个物品被选了多次。 + +## 易错点 + +- `dp` 含义不要频繁变化。 +- 初始化不是随便填 0,要看状态含义。 +- 0-1 背包容量倒序,完全背包容量正序。 +- 求方案数和求最值的初始化不同。 +- 子序列题经常需要区分“以 i 结尾”和“前 i 个元素内”。 + +## 推荐练习题 + +- [70. 爬楼梯](https://leetcode.cn/problems/climbing-stairs/) +- [198. 打家劫舍](https://leetcode.cn/problems/house-robber/) +- [322. 零钱兑换](https://leetcode.cn/problems/coin-change/) +- [416. 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum/) +- [300. 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence/) +- [1143. 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence/) + + diff --git a/docs/cs-basics/algorithms/greedy.md b/docs/cs-basics/algorithms/greedy.md new file mode 100644 index 00000000000..61daf254660 --- /dev/null +++ b/docs/cs-basics/algorithms/greedy.md @@ -0,0 +1,127 @@ +--- +title: 贪心算法面试题总结:区间贪心、跳跃游戏与证明思路 +description: 贪心算法面试题总结,讲解贪心题型识别、排序贪心、区间贪心、跳跃游戏、贪心证明思路和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: 贪心算法,贪心算法模板,区间贪心,排序贪心,跳跃游戏,贪心证明,LeetCode贪心,算法面试题 +--- + +贪心算法的代码往往不长,难点在于为什么当前选择不会影响全局最优。面试里如果只写代码,不解释贪心策略,很容易被追问到卡住。 + +可以先记一个判断方式:如果问题可以通过排序或维护一个当前最优边界,每一步做出局部选择,并且这个选择不会破坏后续最优解,就可以尝试贪心。 + +## 面试考察重点 + +- 能找出贪心策略。 +- 能用交换、反证或直觉边界说明策略合理。 +- 能处理排序后的遍历条件。 +- 能区分贪心和动态规划。 + +## 贪心题怎么想? + +贪心题最怕“凭感觉选”。写代码前至少要说清两个东西: + +1. 每一步贪的是什么,比如结束时间最早、当前能跳到最远、当前收益为正。 +2. 为什么这个选择不会让后面变差。 + +证明不一定要很形式化,但要能讲出取舍。比如区间调度里,选择结束最早的区间,是因为它给后面留下的可选空间最大;如果选择一个结束更晚的区间,不会让答案变得更多。 + +## 常见题型 + +| 题型 | 贪心策略 | 代表题 | +| ---------- | ------------------------------ | ---------------------------------- | +| 分配问题 | 优先满足最容易满足的对象 | 分发饼干 | +| 股票买卖 | 把所有正收益累加 | 买卖股票的最佳时机 II | +| 跳跃问题 | 维护当前能到达的最远位置 | 跳跃游戏 | +| 区间问题 | 按右端点或左端点排序 | 无重叠区间、用最少数量的箭引爆气球 | +| 字符串重构 | 维护剩余可用次数或最远覆盖位置 | 划分字母区间 | + +贪心常常和排序一起出现,因为排序能让“当前最优选择”变得明确。区间题经常按左端点或右端点排序,分配题经常把需求和资源都排序后用双指针匹配。 + +## 跳跃游戏模板 + +```java +boolean canJump(int[] nums) { + int farthest = 0; + for (int i = 0; i < nums.length; i++) { + if (i > farthest) { + return false; + } + farthest = Math.max(farthest, i + nums[i]); + } + return true; +} +``` + +`farthest` 表示当前能到达的最远位置。遍历到 `i` 时,如果 `i > farthest`,说明当前位置根本不可达。 + +这题的贪心点是:不关心具体从哪一步跳到 `i`,只关心当前能覆盖到的最远位置。只要当前位置在覆盖范围内,就可以用它继续更新覆盖范围。 + +“跳跃游戏 II”多了一个最少步数。它维护两个边界: + +- `curEnd`:当前步数能覆盖到的最远位置。 +- `farthest`:在当前覆盖范围内再跳一步能到的最远位置。 + +当遍历到 `curEnd` 时,说明当前步数的范围用完了,必须多跳一步,并把 `curEnd` 更新为 `farthest`。 + +## 区间贪心模板 + +以无重叠区间为例,按右端点升序排序,每次保留结束最早的区间: + +```java +int eraseOverlapIntervals(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt(a -> a[1])); + int count = 1; + int end = intervals[0][1]; + for (int i = 1; i < intervals.length; i++) { + if (intervals[i][0] >= end) { + count++; + end = intervals[i][1]; + } + } + return intervals.length - count; +} +``` + +结束越早,留给后面区间的空间越大,这是这类题的核心选择。 + +区间题最容易错在排序字段。几个常见选择: + +- 要选最多不重叠区间:按右端点升序。 +- 要合并区间:按左端点升序。 +- 要用最少箭引爆气球:按右端点升序,尽量用当前箭覆盖更多气球。 + +如果一个贪心策略不好解释,先用小样例找反例。比如“每次选长度最短的区间”看起来合理,但并不能保证选出最多不重叠区间。 + +## 贪心和动态规划怎么区分? + +| 对比点 | 贪心 | 动态规划 | +| ------------ | ------------------------ | ---------------------- | +| 决策方式 | 当前一步直接选 | 依赖前面多个状态 | +| 是否回看历史 | 通常不回看 | 需要状态转移 | +| 证明重点 | 当前选择不会破坏全局最优 | 最优子结构和重叠子问题 | +| 常见题 | 区间、跳跃、分配 | 背包、子序列、路径 | + +如果当前选择看起来合理,但举个小反例就会错,那它更可能需要 DP 或搜索。 + +## 易错点 + +- 贪心题常常需要先排序,排序字段错了答案就错。 +- 区间题要看边界是否允许相等,比如 `[1,2]` 和 `[2,3]` 是否重叠。 +- 跳跃游戏 II 里“步数增加”的时机和当前覆盖边界有关。 +- 贪心策略要能解释,不要只说“每次选最优”。 + +## 推荐练习题 + +- [455. 分发饼干](https://leetcode.cn/problems/assign-cookies/) +- [122. 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/) +- [55. 跳跃游戏](https://leetcode.cn/problems/jump-game/) +- [45. 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii/) +- [435. 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals/) +- [763. 划分字母区间](https://leetcode.cn/problems/partition-labels/) + + diff --git a/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md b/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md index 2653b68ade0..09517584c0b 100644 --- a/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md +++ b/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md @@ -390,4 +390,38 @@ public class Solution { } ``` +## 面试复盘重点 + +链表题的代码通常不长,但指针更新顺序很容易写错。面试前至少要掌握 4 个模板:虚拟头节点、反转链表、快慢指针、合并链表。 + +| 模板 | 适用题型 | 关键点 | +| ---------- | ---------------------------------- | -------------------------------- | +| 虚拟头节点 | 删除节点、合并链表、头节点可能变化 | 返回 `dummy.next` | +| 反转链表 | 整体反转、区间反转、K 个一组反转 | 保存 `next`,再改 `cur.next` | +| 快慢指针 | 环检测、倒数第 K 个、中点 | 先判断 `fast` 和 `fast.next` | +| 合并链表 | 两个有序链表、K 个有序链表 | 递归或迭代,注意尾部接上剩余链表 | + +反转链表的迭代模板建议背熟: + +```java +ListNode reverseList(ListNode head) { + ListNode prev = null; + ListNode cur = head; + while (cur != null) { + ListNode next = cur.next; + cur.next = prev; + prev = cur; + cur = next; + } + return prev; +} +``` + +几个易错点: + +- 删除倒数第 N 个节点时,虚拟头节点能统一处理删除头节点的情况。 +- 区间反转要先保存区间前一个节点和区间后一个节点。 +- 判断链表有环时,循环条件是 `fast != null && fast.next != null`。 +- 递归合并链表代码短,但链表很长时可能有递归栈风险。 + diff --git a/docs/cs-basics/algorithms/string-algorithm-problems.md b/docs/cs-basics/algorithms/string-algorithm-problems.md index bba453d108f..6b1612c3812 100644 --- a/docs/cs-basics/algorithms/string-algorithm-problems.md +++ b/docs/cs-basics/algorithms/string-algorithm-problems.md @@ -1,6 +1,6 @@ --- title: 几道常见的字符串算法题 -description: 总结字符串高频算法与题型,重点讲解 KMP/BM 原理、滑动窗口等技巧,助力高效匹配与实现。 +description: 总结字符串高频算法与题型,重点讲解 KMP/BM 原理、滑动窗口等技巧,帮助读者理解高效匹配与实现。 category: 计算机基础 tag: - 算法 @@ -452,7 +452,6 @@ public class Main { } public static void main(String[] args) { - // TODO Auto-generated method stub String s = "-12312312"; System.out.println("使用库函数转换:" + Integer.valueOf(s)); int res = Main.StrToInt(s); @@ -464,4 +463,30 @@ public class Main { ``` +## 面试复盘重点 + +字符串题看起来杂,实际常见模板并不多:哈希计数、双指针、滑动窗口、KMP、回文、栈模拟。 + +| 题型 | 常用方法 | 代表题 | +| ---------- | -------------------- | -------------------------------- | +| 字符计数 | 数组或哈希表 | 有效的字母异位词、字母异位词分组 | +| 子串问题 | 滑动窗口 | 最长无重复子串、最小覆盖子串 | +| 回文问题 | 双指针、中心扩展、DP | 验证回文串、最长回文子串 | +| 字符串匹配 | KMP、哈希 | 实现 `strStr()` | +| 括号和编码 | 栈 | 有效的括号、字符串解码 | +| 数字转换 | 模拟 | 字符串转换整数 | + +处理字符串题时可以先问 3 个问题: + +1. 题目关心的是子串还是子序列?子串连续,子序列不要求连续。 +2. 字符集范围有多大?只有小写字母时,数组计数比哈希表更直接。 +3. 是否需要处理溢出、空串、空格、符号位这类边界? + +几个易错点: + +- Java 中 `String` 不可变,频繁拼接建议使用 `StringBuilder`。 +- `char` 处理 Unicode 字符时可能不够,普通算法题多数只考 ASCII 或小写字母。 +- 回文子串和回文子序列不是一类题,前者常用中心扩展,后者常用 DP。 +- KMP 面试中不一定要求从零推导,但要知道 `next` 数组用于避免重复匹配。 + diff --git a/docs/cs-basics/algorithms/top-k.md b/docs/cs-basics/algorithms/top-k.md new file mode 100644 index 00000000000..57d8413872c --- /dev/null +++ b/docs/cs-basics/algorithms/top-k.md @@ -0,0 +1,162 @@ +--- +title: Top K 问题面试题总结:堆、快排分区、桶计数与数据流 +description: Top K 问题面试题总结,讲解第 K 大、前 K 高频、小顶堆、快排分区、桶计数、数据流中位数、PriorityQueue 和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: TopK,Top K,第K大,前K高频,堆,小顶堆,快排分区,桶计数,PriorityQueue,数据流中位数,LeetCode +--- + +Top K 问题在后端面试里很常见,因为它既能考算法,也能自然追问工程场景:排行榜、热词统计、数据流中位数、日志里最常见的错误码,都能落到 Top K。 + +这类题不要只记一种写法。面试官常会追问:如果数据量很大怎么办?如果是数据流怎么办?如果要求前 K 高频怎么办?不同条件下方案会变。 + +## 面试考察重点 + +- 能用堆解决第 K 大和前 K 高频。 +- 能说清小顶堆和大顶堆怎么选。 +- 能对比堆、快排分区、桶计数的复杂度。 +- 能处理数据流场景。 +- 能写出 Java `PriorityQueue` 比较器。 + +## Top K 题怎么选方案? + +先看 3 个条件: + +1. 是否只需要第 K 个元素,还是要完整的前 K 个元素? +2. 数据是一次性给出,还是持续到来的数据流? +3. 是否需要结果有序? + +如果只是一次性数组里找第 K 大,快排分区平均更快;如果数据持续到来,维护一个大小为 K 的堆更自然;如果题目问前 K 高频,要先做频率统计,再对频率做 Top K。 + +## 方案对比 + +| 方案 | 适合场景 | 时间复杂度 | 空间复杂度 | +| -------- | ------------------------ | ------------------ | ------------------- | +| 排序 | 数据量不大,代码简单优先 | `O(nlogn)` | 取决于排序实现 | +| 小顶堆 | 找前 K 大或第 K 大 | `O(nlogk)` | `O(k)` | +| 快排分区 | 找第 K 大,平均效率高 | 平均 `O(n)` | `O(1)` 到 `O(logn)` | +| 桶计数 | 频率范围有限,前 K 高频 | `O(n)` | `O(n)` | +| 双堆 | 数据流中位数 | 每次插入 `O(logn)` | `O(n)` | + +面试里可以这样回答取舍: + +- 排序最简单,适合数据量不大或不追求最优复杂度。 +- 堆适合 K 比 n 小很多的场景,空间只需要 `O(k)`。 +- 快排分区适合一次性找第 K 大,平均 `O(n)`,但最坏会退化。 +- 桶计数适合频率类问题,尤其是频率范围不超过 `n`。 + +## 小顶堆求第 K 大 + +```java +int findKthLargest(int[] nums, int k) { + PriorityQueue heap = new PriorityQueue<>(); + for (int num : nums) { + heap.offer(num); + if (heap.size() > k) { + heap.poll(); + } + } + return heap.peek(); +} +``` + +堆里始终保留当前最大的 K 个数,堆顶就是这 K 个数里最小的,也就是整体第 K 大。 + +为什么是小顶堆?因为堆里要保留最大的 K 个元素。当新元素进来后,如果堆大小超过 K,就应该淘汰这 K + 1 个元素里最小的那个。小顶堆的堆顶正好是最小值。 + +如果求第 K 小,思路反过来:维护大小为 K 的大顶堆,超过 K 时弹出最大值。 + +## 前 K 高频元素 + +```java +int[] topKFrequent(int[] nums, int k) { + Map freq = new HashMap<>(); + for (int num : nums) { + freq.put(num, freq.getOrDefault(num, 0) + 1); + } + PriorityQueue heap = new PriorityQueue<>(Comparator.comparingInt(a -> a[1])); + for (Map.Entry entry : freq.entrySet()) { + heap.offer(new int[] {entry.getKey(), entry.getValue()}); + if (heap.size() > k) { + heap.poll(); + } + } + int[] ans = new int[k]; + for (int i = k - 1; i >= 0; i--) { + ans[i] = heap.poll()[0]; + } + return ans; +} +``` + +这里堆按频率升序,堆大小超过 K 时弹出频率最小的元素。 + +这题分两层: + +1. 用 `HashMap` 统计每个元素的频率。 +2. 对“元素 + 频率”做 Top K。 + +如果面试官要求相同频率时按元素大小或字典序排序,比较器就要把第二排序规则写进去。比如前 K 高频单词通常要求频率高的在前,频率相同时字典序小的在前。 + +## 快排分区思路 + +快排分区适合找第 K 大,不要求输出有序的前 K 个元素。思路是每次把数组按 pivot 分成两边,根据 pivot 的排名决定继续搜索哪一边。平均时间复杂度是 `O(n)`,但最坏可能退化到 `O(n^2)`,实际写法通常会随机选 pivot。 + +快排分区的优势是不用维护堆,平均时间复杂度低;局限是它更适合内存中的一次性数据。如果数据流不断到来,或者数据太大不能一次性放进内存,堆方案更容易落地。 + +## 数据流场景 + +数据流题不能每来一个元素就重新排序。常见做法是持续维护一个数据结构: + +- 数据流第 K 大:维护大小为 K 的小顶堆。 +- 数据流中位数:维护两个堆,左边大顶堆放较小的一半,右边小顶堆放较大的一半。 +- 滑动窗口中位数:还要处理过期元素,普通堆删除任意元素不方便,通常需要延迟删除或有序集合。 + +## 过程示意和边界样例 + +以数组 `[3, 2, 1, 5, 6, 4]` 求第 2 大为例,维护大小为 2 的小顶堆: + +| 读入元素 | 堆内容 | 超过 K 后处理 | +| -------- | ----------- | --------------------- | +| 3 | `[3]` | 不处理 | +| 2 | `[2, 3]` | 不处理 | +| 1 | `[1, 3, 2]` | 弹出 1,保留 `[2, 3]` | +| 5 | `[2, 3, 5]` | 弹出 2,保留 `[3, 5]` | +| 6 | `[3, 5, 6]` | 弹出 3,保留 `[5, 6]` | +| 4 | `[4, 6, 5]` | 弹出 4,保留 `[5, 6]` | + +最后堆顶是 `5`,也就是第 2 大。 + +常见错误写法: + +```java +PriorityQueue heap = new PriorityQueue<>((a, b) -> b - a); +``` + +这个比较器在极端整数值下可能溢出。更稳妥的写法是: + +```java +PriorityQueue heap = new PriorityQueue<>((a, b) -> Integer.compare(b, a)); +``` + +## 易错点 + +- 找前 K 大通常用小顶堆,找前 K 小通常用大顶堆。 +- `PriorityQueue` 默认是小顶堆。 +- 前 K 高频要先统计频率,再对频率做 Top K。 +- 如果要输出有序结果,堆或快排分区后还需要额外排序。 +- 数据流场景不能把所有数据每次重新排序。 + +## 推荐练习题 + +- [215. 数组中的第 K 个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) +- [347. 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements/) +- [692. 前 K 个高频单词](https://leetcode.cn/problems/top-k-frequent-words/) +- [703. 数据流中的第 K 大元素](https://leetcode.cn/problems/kth-largest-element-in-a-stream/) +- [295. 数据流的中位数](https://leetcode.cn/problems/find-median-from-data-stream/) + + diff --git a/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md b/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md new file mode 100644 index 00000000000..26187819321 --- /dev/null +++ b/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md @@ -0,0 +1,236 @@ +--- +title: 双指针与滑动窗口面试题总结:数组、链表、字符串高频模板 +description: 双指针与滑动窗口面试题总结,讲解左右指针、快慢指针、读写指针、固定窗口、可变窗口、Java 模板和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 算法 +head: + - - meta + - name: keywords + content: 双指针,滑动窗口,快慢指针,左右指针,读写指针,固定窗口,可变窗口,数组算法,链表算法,字符串算法,LeetCode +--- + +双指针和滑动窗口经常放在一起复习,但它们解决的问题不完全一样。双指针更像一种移动策略,滑动窗口则强调维护一个连续区间里的状态。 + +一个实用判断:如果题目关心两个位置之间的关系,先想双指针;如果题目关心连续子数组或连续子串,并且窗口内有条件要维护,先想滑动窗口。 + +## 面试考察重点 + +- 能区分左右指针、快慢指针、读写指针。 +- 能维护滑动窗口里的计数、和、最大值或匹配情况。 +- 能解释为什么指针只向一个方向移动,时间复杂度是 `O(n)`。 +- 能处理空数组、单元素、重复元素和窗口收缩边界。 + +## 两者到底有什么区别? + +双指针是一种更宽泛的写法,只要用两个指针协作推进,都可以叫双指针。滑动窗口更具体,它维护的是一个连续区间 `[left, right]`,窗口里通常有一组状态,比如字符计数、元素和、最大值、匹配数量。 + +| 问题特征 | 更可能使用 | +| ----------------------------------- | ---------- | +| 有序数组里找两个数 | 左右指针 | +| 链表找环、找中点、找倒数第 K 个节点 | 快慢指针 | +| 原地删除或覆盖元素 | 读写指针 | +| 连续子数组/子串的最长、最短、计数 | 滑动窗口 | + +面试时先把指针含义说出来,比直接写代码更稳。比如“`left` 表示窗口左边界,`right` 表示正在尝试加入窗口的字符”,后面收缩窗口就不会乱。 + +## 左右指针 + +左右指针常用于有序数组或两端收缩问题: + +```java +int[] twoSumSorted(int[] nums, int target) { + int left = 0; + int right = nums.length - 1; + while (left < right) { + int sum = nums[left] + nums[right]; + if (sum == target) { + return new int[] {left, right}; + } else if (sum < target) { + left++; + } else { + right--; + } + } + return new int[] {-1, -1}; +} +``` + +如果数组无序,通常先排序,再用左右指针。排序后要记得复杂度变成 `O(nlogn)`。 + +左右指针能工作的原因,是每次比较后可以排除一部分答案。以有序数组两数之和为例: + +- 当前和太小,说明左指针指向的数太小,右指针再往左只会更小,所以只能左指针右移。 +- 当前和太大,说明右指针指向的数太大,左指针再往右只会更大,所以只能右指针左移。 + +三数之和也是同一个思路,只是先固定一个数,再在剩余区间里做两数之和。难点在去重:固定数要去重,左右指针找到答案后也要跳过重复值。 + +## 快慢指针 + +快慢指针常用于链表: + +```java +boolean hasCycle(ListNode head) { + ListNode slow = head; + ListNode fast = head; + while (fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + if (slow == fast) { + return true; + } + } + return false; +} +``` + +链表题的重点不是代码长,而是指针含义稳定。`fast != null && fast.next != null` 的顺序也不能反。 + +快慢指针常见有两种速度差: + +- `fast` 每次走 2 步,`slow` 每次走 1 步:用于环检测和找链表中点。 +- 一个指针先走 `k` 步,另一个指针再一起走:用于找倒数第 `k` 个节点。 + +找倒数第 `k` 个节点时,两个指针之间保持 `k` 个节点的距离。当前面的指针走到链表末尾,后面的指针刚好停在目标位置。删除倒数第 `N` 个节点时,通常会加虚拟头节点,避免删除头节点时单独处理。 + +## 读写指针 + +读写指针常用于原地修改数组: + +```java +int removeDuplicates(int[] nums) { + if (nums.length == 0) { + return 0; + } + int write = 1; + for (int read = 1; read < nums.length; read++) { + if (nums[read] != nums[read - 1]) { + nums[write] = nums[read]; + write++; + } + } + return write; +} +``` + +`read` 负责扫描原数组,`write` 指向下一个可写入位置。面试里最好先把这两个变量的含义说出来。 + +读写指针的核心是“读完整个数组,只把需要保留的内容写回前面”。这类题经常要求原地修改,返回新长度,而不是创建新数组。 + +判断写入时机时,可以问自己:当前 `read` 指向的元素是否应该保留?如果应该保留,就写到 `write`,然后 `write++`;如果不应该保留,只移动 `read`。 + +## 可变滑动窗口 + +以“无重复字符的最长子串”为例: + +```java +int lengthOfLongestSubstring(String s) { + Map count = new HashMap<>(); + int left = 0; + int ans = 0; + for (int right = 0; right < s.length(); right++) { + char c = s.charAt(right); + count.put(c, count.getOrDefault(c, 0) + 1); + while (count.get(c) > 1) { + char d = s.charAt(left); + count.put(d, count.get(d) - 1); + left++; + } + ans = Math.max(ans, right - left + 1); + } + return ans; +} +``` + +这个模板里,右指针负责扩大窗口,左指针负责在窗口不合法时收缩。每个字符最多进窗口一次、出窗口一次,所以时间复杂度是 `O(n)`。 + +可变窗口一般有一个固定节奏: + +1. 右指针加入新元素,更新窗口状态。 +2. 当窗口不满足条件时,不断移动左指针,并同步更新状态。 +3. 在窗口满足题意的位置更新答案。 + +最长问题和最短问题的更新时机不一样: + +- 求最长合法窗口:通常在窗口恢复合法后更新答案。 +- 求最短满足条件窗口:通常在窗口已经满足条件时更新答案,然后继续收缩左边界。 + +比如“最小覆盖子串”里,窗口一旦覆盖了目标字符,就要先更新答案,再尝试缩小窗口;“最长无重复子串”里,窗口有重复字符时要先缩到合法,再更新答案。 + +## 固定滑动窗口 + +固定窗口适合“长度为 k 的子数组/子串”: + +```java +int maxSum(int[] nums, int k) { + int window = 0; + for (int i = 0; i < k; i++) { + window += nums[i]; + } + int ans = window; + for (int right = k; right < nums.length; right++) { + window += nums[right]; + window -= nums[right - k]; + ans = Math.max(ans, window); + } + return ans; +} +``` + +固定窗口的重点是右侧进一个元素,左侧出一个元素。 + +固定窗口不用 `while` 收缩,因为窗口长度始终固定。它更像一个滚动统计: + +- 新元素进入窗口。 +- 离开窗口的旧元素被移除。 +- 更新当前窗口答案。 + +如果窗口里还要维护最大值或最小值,普通变量不够用,通常要用单调队列。比如“滑动窗口最大值”中,队列里存可能成为最大值的下标,队首就是当前窗口最大值。 + +## 过程示意和边界样例 + +以“无重复字符的最长子串”为例,字符串 `abba` 的窗口变化如下: + +| 右指针字符 | 加入后窗口 | 是否合法 | 左指针怎么动 | 当前最长 | +| ---------- | ---------- | -------- | ------------------------------------- | -------- | +| `a` | `a` | 合法 | 不动 | 1 | +| `b` | `ab` | 合法 | 不动 | 2 | +| `b` | `abb` | 不合法 | 移走 `a` 后仍不合法,再移走第一个 `b` | 2 | +| `a` | `ba` | 合法 | 不动 | 2 | + +滑动窗口建议至少检查这些边界: + +| 输入 | 重点 | +| -------------------- | ------------------------ | +| 空字符串或空数组 | 是否直接返回 0 | +| 全部字符相同 | 左边界是否持续收缩 | +| 没有重复字符 | 答案是否能更新到整个长度 | +| 最优窗口在开头或结尾 | 更新答案的时机是否正确 | + +常见错误写法: + +```java +if (count.get(c) > 1) { + left++; // 错:只移动一次不一定能恢复合法窗口 +} +``` + +可变窗口收缩时通常要用 `while`,直到窗口重新满足条件。只移动一次,遇到 `abba`、`aaabc` 这类输入就容易错。 + +## 易错点 + +- 双指针题先明确两个指针的含义,不要边写边猜。 +- 滑动窗口里,更新答案的时机要看题目问的是最长还是最短。 +- 窗口收缩时,窗口内的计数、和、匹配数都要同步更新。 +- 链表快慢指针要先判断 `fast` 和 `fast.next`。 +- 三数之和这类题,排序后的去重要单独处理。 + +## 推荐练习题 + +- [26. 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/) +- [15. 三数之和](https://leetcode.cn/problems/3sum/) +- [141. 环形链表](https://leetcode.cn/problems/linked-list-cycle/) +- [3. 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters/) +- [76. 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring/) + + diff --git a/docs/cs-basics/data-structure/README.md b/docs/cs-basics/data-structure/README.md index 2f7b065845f..5df241058f1 100644 --- a/docs/cs-basics/data-structure/README.md +++ b/docs/cs-basics/data-structure/README.md @@ -1,6 +1,6 @@ --- -title: 数据结构专题:数组、链表、栈、队列、树、图、堆、红黑树与布隆过滤器 -description: 数据结构面试与学习路线,涵盖数组、链表、栈、队列、树、图、堆、红黑树、布隆过滤器等常见数据结构和应用场景。 +title: 数据结构专题:面试复习路线、复杂度、Java 集合与工程场景 +description: 数据结构面试复习路线,涵盖数组、链表、栈、队列、哈希表、树、图、堆、Trie、并查集、跳表、红黑树、布隆过滤器、LRU 和 Java 后端工程场景。 category: 计算机基础 tag: - 数据结构 @@ -13,60 +13,98 @@ sitemap: head: - - meta - name: keywords - content: 数据结构,数据结构面试题,数组,链表,栈,队列,树,图,堆,红黑树,布隆过滤器,后端面试 + content: 数据结构,数据结构面试题,数组,链表,栈,队列,哈希表,树,图,堆,Trie,并查集,跳表,红黑树,布隆过滤器,LRU,Java集合,后端面试 --- -这份 **数据结构专题** 面向计算机基础学习和算法面试复习,整理数组、链表、栈、队列、树、图、堆、红黑树、布隆过滤器等常见结构。 +这份 **数据结构专题** 按面试和 Java 后端场景组织内容:先理解数据怎么存,再看常见操作复杂度,最后把结构和 Java 集合、MySQL 索引、Redis、缓存、消息队列这些工程问题连起来。 + +面试里问数据结构,很少只停在“数组是什么”。更常见的是追问:数组和链表为什么一个查询快、一个插入删除方便?`HashMap` 为什么需要扩容?B+ 树为什么适合索引?布隆过滤器为什么会误判?这些问题背后都在考同一件事:你是否理解结构选择带来的复杂度和场景取舍。 ## 适合谁看 -- 正在系统学习数据结构的后端开发者。 -- 准备算法题、Java 集合、数据库索引、缓存等相关面试的同学。 -- 对常见数据结构的操作复杂度和适用场景不够熟的读者。 -- 想把数据结构和真实工程组件联系起来的工程师。 +- 正在补数据结构基础,准备校招或社招后端面试的同学。 +- 刷算法题时经常卡在数组、链表、树、图、堆等结构上的读者。 +- 想把数据结构和 Java 集合、Redis、MySQL、缓存系统联系起来的工程师。 +- 已经看过概念,但回答面试题时容易停在定义层面的开发者。 -## 学习重点 +## 数据结构面试考什么 -- 数据结构的核心是“数据如何组织,以及这种组织方式带来什么复杂度和场景优势”。 -- 线性结构适合理解顺序存储、链式存储、栈队列模型和常见业务队列。 -- 树和图是很多算法、索引、路由、依赖关系和层级结构的基础。 -- 堆、红黑树、布隆过滤器属于工程中很常见的高频结构。 -- 学数据结构要配合算法题和工程场景,否则容易只记住定义。 +| 考察点 | 常见问法 | 复习重点 | +| ---------- | ---------------------------------------------------------- | ---------------------------- | +| 存储方式 | 顺序存储和链式存储有什么区别? | 内存连续性、指针、缓存友好性 | +| 操作复杂度 | 为什么数组查询是 O(1),链表查询是 O(n)? | 查询、插入、删除、遍历复杂度 | +| 结构对比 | 红黑树和 AVL 树怎么选?B 树和 B+ 树有什么区别? | 对比表 + 适用场景 | +| 工程关联 | HashMap、TreeMap、PriorityQueue、Redis ZSet 用了什么结构? | Java/数据库/缓存中的真实应用 | +| 算法承接 | 树遍历、图搜索、Top K、LRU 怎么写? | 和算法模板一起复习 | ## 建议阅读顺序 -1. [线性数据结构详解](./linear-data-structure.md):先掌握数组、链表、栈、队列这些最基础结构。 -2. [树结构详解](./tree.md):理解二叉树、二叉搜索树、AVL、B 树、B+ 树等结构。 -3. [图详解](./graph.md):掌握图的表示、遍历和常见路径问题。 -4. [堆详解](./heap.md):理解优先队列、堆排序和 Top K 问题。 -5. [红黑树详解](./red-black-tree.md) 和 [布隆过滤器详解](./bloom-filter.md):补齐 Java 集合、数据库、缓存、去重等工程场景中的高频结构。 +1. [线性数据结构详解](./linear-data-structure.md):先掌握数组、链表、栈、队列,理解顺序存储和链式存储。 +2. [哈希表面试题总结](./hash-table.md):理解哈希函数、冲突、扩容,并和 `HashMap` 连起来。 +3. [树结构详解](./tree.md):掌握二叉树、二叉搜索树、AVL、B 树、B+ 树,以及 MySQL 索引关联。 +4. [堆详解](./heap.md):理解优先队列、Top K、堆排序和 `PriorityQueue`。 +5. [图详解](./graph.md):理解图的存储、DFS、BFS、拓扑排序和最短路径入口。 +6. [Trie 前缀树面试题总结](./trie.md)、[并查集面试题总结](./union-find.md):补齐字符串集合和连通性问题。 +7. [跳表面试题总结](./skip-list.md)、[红黑树详解](./red-black-tree.md)、[布隆过滤器详解](./bloom-filter.md)、[LRU 缓存面试题总结](./lru-cache.md):面向 Java 集合、Redis、缓存和数据库场景复盘。 ## 核心文章 -- [线性数据结构详解](./linear-data-structure.md):讲解数组、链表、栈、队列的存储结构、操作方式和复杂度。 -- [树结构详解](./tree.md):讲解二叉树、二叉搜索树、AVL、B 树、B+ 树等常见树结构。 -- [图详解](./graph.md):讲解图的存储、DFS、BFS、最短路径等基础内容。 -- [堆详解](./heap.md):讲解最大堆、最小堆、优先队列、堆排序和 Top K。 -- [红黑树详解](./red-black-tree.md):讲解红黑树性质、旋转、插入修复以及典型应用。 -- [布隆过滤器详解](./bloom-filter.md):讲解布隆过滤器原理、误判率、实现方式和缓存穿透等场景。 +| 文章 | 重点 | 常见关联 | +| ---------------------------------------------- | ----------------------------- | ----------------------------------- | +| [线性数据结构详解](./linear-data-structure.md) | 数组、链表、栈、队列 | `ArrayList`、`LinkedList`、消息队列 | +| [哈希表面试题总结](./hash-table.md) | 哈希函数、冲突、扩容 | `HashMap`、缓存、去重 | +| [树结构详解](./tree.md) | 二叉树、BST、AVL、B 树、B+ 树 | MySQL 索引、表达式树 | +| [图详解](./graph.md) | 邻接表、邻接矩阵、DFS、BFS | 依赖关系、路由、推荐关系 | +| [堆详解](./heap.md) | 最大堆、最小堆、堆排序 | `PriorityQueue`、Top K、延迟队列 | +| [红黑树详解](./red-black-tree.md) | 近似平衡、旋转、变色 | `TreeMap`、`HashMap` 树化 | +| [布隆过滤器详解](./bloom-filter.md) | 位数组、哈希、误判 | 缓存穿透、去重、黑名单 | +| [跳表面试题总结](./skip-list.md) | 多级索引、范围查询 | Redis ZSet | +| [LRU 缓存面试题总结](./lru-cache.md) | 哈希表 + 双向链表 | 本地缓存、页面置换 | + +## 7 天复习路线 + +| 天数 | 重点 | 建议动作 | +| ------- | ------------------------ | --------------------------------------------- | +| 第 1 天 | 数组、链表 | 写复杂度表,手写反转链表和删除节点 | +| 第 2 天 | 栈、队列、哈希表 | 写括号匹配、用栈实现队列、两数之和 | +| 第 3 天 | 树 | 写二叉树遍历、最近公共祖先,复盘 B+ 树 | +| 第 4 天 | 堆 | 写 Top K、前 K 高频元素,理解 `PriorityQueue` | +| 第 5 天 | 图 | 写 DFS/BFS、岛屿数量、课程表 | +| 第 6 天 | 红黑树、跳表、布隆过滤器 | 重点准备工程场景追问 | +| 第 7 天 | LRU 和综合复盘 | 手写 LRU,整理所有结构的复杂度和应用场景 | + +## 30 天复习路线 + +| 阶段 | 时间 | 目标 | +| -------- | -------------- | -------------------------------------------------- | +| 第一阶段 | 第 1 到 6 天 | 线性结构和哈希表,能说清复杂度和 Java 集合关联 | +| 第二阶段 | 第 7 到 13 天 | 树、堆、图,配合 DFS/BFS 和 Top K 刷题 | +| 第三阶段 | 第 14 到 20 天 | Trie、并查集、跳表、红黑树,补齐进阶结构 | +| 第四阶段 | 第 21 到 25 天 | 布隆过滤器、LRU、工程场景题,连接 Redis/MySQL/缓存 | +| 第五阶段 | 第 26 到 30 天 | 做错题复盘和面试口述练习,每个结构准备 2 个追问 | -## 高频问题 +## 高频问题自测 -- 数组和链表有什么区别?各自适合什么场景? -- 栈和队列分别解决什么问题?如何用它们模拟业务流程? -- 二叉树、二叉搜索树、平衡二叉树有什么区别? +- 数组和链表的内存布局有什么区别?为什么数组随机访问快? +- `ArrayList` 和 `LinkedList` 在 Java 里怎么选? +- 栈和队列分别适合哪些场景?单调栈、单调队列解决什么问题? +- 哈希冲突有哪些解决方式?`HashMap` 为什么要扩容? +- 二叉搜索树、AVL 树、红黑树有什么区别? - B 树和 B+ 树为什么适合数据库索引? -- DFS 和 BFS 有什么区别?分别适合什么问题? -- 堆和普通二叉树有什么区别?优先队列如何实现? -- 红黑树为什么能保持近似平衡?Java 里哪些地方用到了红黑树? -- 布隆过滤器为什么会误判?适合解决什么工程问题? +- 堆和普通二叉树有什么区别?Top K 为什么常用堆? +- 图的邻接表和邻接矩阵怎么选?DFS 和 BFS 复杂度是多少? +- 跳表为什么适合范围查询?Redis 为什么使用跳表? +- 布隆过滤器为什么会误判?为什么删除困难? +- LRU 为什么常用哈希表加双向链表实现? ## 相关专题 - [计算机基础知识体系](../) - [算法专题](../algorithms/) +- [常见数据结构经典 LeetCode 题目推荐](../algorithms/common-data-structures-leetcode-recommendations.md) - [Java 集合](../../java/collection/java-collection-questions-01.md) - [MySQL 索引详解](../../database/mysql/mysql-index.md) - [Redis 常见面试题总结](../../database/redis/redis-questions-01.md) +- [面试准备](../../interview-preparation/) diff --git a/docs/cs-basics/data-structure/bloom-filter.md b/docs/cs-basics/data-structure/bloom-filter.md index 5b14d914460..1387a2f0b6c 100644 --- a/docs/cs-basics/data-structure/bloom-filter.md +++ b/docs/cs-basics/data-structure/bloom-filter.md @@ -318,4 +318,31 @@ root@21396d02c252:/data# redis-cli (integer) 0 ``` +## 面试复盘重点 + +布隆过滤器面试最常见的 4 个问题是:为什么快、为什么省空间、为什么会误判、为什么不好删除。 + +| 问题 | 回答要点 | +| ---------------- | ----------------------------------------------------- | +| 为什么省空间? | 用位数组和多个哈希函数表示集合,不存储原始元素 | +| 为什么会误判? | 多个元素可能把同一批 bit 置为 1,查询时误以为目标存在 | +| 会不会漏判? | 标准布隆过滤器不会把已加入元素判断为不存在 | +| 为什么删除困难? | 一个 bit 可能被多个元素共享,清零会影响其他元素 | + +典型工程场景: + +- 缓存穿透:先用布隆过滤器判断 key 是否可能存在,不存在就不查数据库。 +- 大规模去重:比如 URL 去重、黑名单过滤、推荐系统已读过滤。 +- 分布式场景:单机 Guava 方案简单,但跨节点共享通常会考虑 RedisBloom。 + +回答时要主动补一句局限:布隆过滤器适合“允许少量误判,但不能接受漏判”的场景。如果业务要求 100% 精确存在性判断,就不能只靠布隆过滤器。 + +## 常见追问 + +- 误判率和位数组大小、哈希函数个数有什么关系? +- 布隆过滤器能不能删除元素? +- 缓存穿透、缓存击穿、缓存雪崩分别是什么? +- Guava 布隆过滤器和 RedisBloom 怎么选? +- 如果容量预估错了,会发生什么? + diff --git a/docs/cs-basics/data-structure/graph.md b/docs/cs-basics/data-structure/graph.md index c18b1a360f7..c113d8851ba 100644 --- a/docs/cs-basics/data-structure/graph.md +++ b/docs/cs-basics/data-structure/graph.md @@ -164,4 +164,29 @@ head: ![深度优先搜索6](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/depth-first-search6.png) +## 面试复盘重点 + +图题先选存储方式,再选遍历方式。面试里最常见的 4 类图题是:连通块、最短步数、依赖关系和判环。 + +| 存储方式 | 空间复杂度 | 判断两点是否相邻 | 遍历某点邻居 | 适合场景 | +| -------- | ---------- | ---------------- | ------------ | ------------------ | +| 邻接矩阵 | `O(V^2)` | `O(1)` | `O(V)` | 稠密图、节点数较少 | +| 邻接表 | `O(V + E)` | 取决于邻接表结构 | 和度数有关 | 稀疏图、算法题常用 | + +DFS/BFS 模板可以参考 [DFS 与 BFS 面试题总结](../algorithms/dfs-bfs.md)。这里再补几个面试回答点: + +- 邻接表下,DFS 和 BFS 的时间复杂度通常是 `O(V + E)`。 +- 无权图求最短步数,优先考虑 BFS。 +- 有向图依赖关系常用拓扑排序,典型题是课程表。 +- 无向图连通性和判环可以用 DFS/BFS,也可以用并查集。 +- 带权最短路径不是普通 BFS,常见算法有 Dijkstra、Bellman-Ford、Floyd,面试中按题目范围选择。 + +## 推荐练习题 + +- [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) +- [695. 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island/) +- [994. 腐烂的橘子](https://leetcode.cn/problems/rotting-oranges/) +- [207. 课程表](https://leetcode.cn/problems/course-schedule/) +- [547. 省份数量](https://leetcode.cn/problems/number-of-provinces/) + diff --git a/docs/cs-basics/data-structure/hash-table.md b/docs/cs-basics/data-structure/hash-table.md new file mode 100644 index 00000000000..acee0c2e5b5 --- /dev/null +++ b/docs/cs-basics/data-structure/hash-table.md @@ -0,0 +1,110 @@ +--- +title: 哈希表面试题总结:哈希冲突、扩容与 Java HashMap +description: 哈希表面试题总结,讲解哈希函数、哈希冲突、拉链法、开放寻址法、负载因子、扩容、Java HashMap 和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 数据结构 +head: + - - meta + - name: keywords + content: 哈希表,HashMap,哈希函数,哈希冲突,拉链法,开放寻址法,负载因子,扩容,Java集合,数据结构面试题 +--- + +哈希表的面试价值很高,因为它一头连着算法题里的快速查找和计数,另一头连着 Java `HashMap`、缓存、去重和分布式系统里的分片路由。 + +这个问题问的是:如何把一个 key 快速映射到数组下标,并在冲突、扩容和极端数据下仍然保持可接受的查询效率。 + +## 面试考察重点 + +- 哈希函数负责把 key 映射成数组下标。 +- 哈希冲突无法完全避免,只能设计策略处理。 +- 哈希表平均查询、插入、删除是 `O(1)`,最坏情况可能退化。 +- Java `HashMap` 使用数组 + 链表 + 红黑树,JDK 8 后链表过长会树化。 +- 哈希表常用于快速查找、计数、去重、缓存索引。 + +## 哈希表怎么工作? + +哈希表通常由数组和哈希函数组成: + +1. 对 key 计算哈希值。 +2. 根据数组长度把哈希值映射成下标。 +3. 如果该位置为空,直接放入。 +4. 如果发生冲突,按冲突解决策略继续处理。 + +```java +int index = hash(key) & (table.length - 1); +``` + +`HashMap` 的容量是 2 的幂时,可以用位运算替代取模。位运算更快,也方便扩容后重新分布。 + +## 哈希冲突怎么解决? + +| 方法 | 思路 | 典型应用 | 注意点 | +| ---------- | ------------------------ | ---------------- | ------------------------ | +| 拉链法 | 数组位置上挂链表或树 | Java `HashMap` | 链表过长会影响查询 | +| 开放寻址法 | 冲突后继续探测下一个位置 | 一些高性能哈希表 | 删除和负载因子处理更复杂 | +| 再哈希 | 冲突后换一个哈希函数 | 理论方案较常见 | 实现成本更高 | + +Java `HashMap` 主要使用拉链法。JDK 8 开始,当链表长度达到阈值并且数组容量足够大时,会把链表转换成红黑树,降低极端冲突下的查询成本。 + +## 负载因子和扩容 + +负载因子表示哈希表使用程度: + +```text +负载因子 = 元素数量 / 数组容量 +``` + +`HashMap` 默认负载因子是 `0.75`。当元素数量超过 `capacity * loadFactor` 时触发扩容,容量通常变为原来的 2 倍。 + +扩容会带来一次 rehash 成本。面试里可以这样回答:哈希表单次插入平均是 `O(1)`,但触发扩容的那次会搬迁元素;从摊还角度看,多次插入仍然可以看作平均 `O(1)`。 + +## 和 Java HashMap 的关系 + +`HashMap` 常见追问: + +- 初始容量为什么建议设置成 2 的幂? +- 默认负载因子为什么是 `0.75`? +- JDK 8 为什么引入红黑树? +- `HashMap` 为什么线程不安全? +- `HashMap` 和 `ConcurrentHashMap` 有什么区别? + +这些问题已经超出纯数据结构,但底层仍然是哈希表:数组负责定位,链表或红黑树负责处理冲突,扩容负责控制负载。 + +## 常见算法题模板 + +两数之和: + +```java +int[] twoSum(int[] nums, int target) { + Map map = new HashMap<>(); + for (int i = 0; i < nums.length; i++) { + int need = target - nums[i]; + if (map.containsKey(need)) { + return new int[] {map.get(need), i}; + } + map.put(nums[i], i); + } + return new int[] {-1, -1}; +} +``` + +这段代码体现了哈希表最常见的用法:用空间换时间,把一次查找从 `O(n)` 降到平均 `O(1)`。 + +## 易错点 + +- 哈希表平均 `O(1)` 不等于任何情况下都是 `O(1)`。 +- 自定义对象作为 key 时,要正确重写 `equals()` 和 `hashCode()`。 +- 可变对象不适合直接作为哈希表 key。 +- 统计频率时,数组计数比 `HashMap` 更适合字符集很小的场景。 +- 哈希表能加速查找,但会带来额外空间。 + +## 推荐练习题 + +- [1. 两数之和](https://leetcode.cn/problems/two-sum/) +- [242. 有效的字母异位词](https://leetcode.cn/problems/valid-anagram/) +- [49. 字母异位词分组](https://leetcode.cn/problems/group-anagrams/) +- [560. 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k/) +- [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/) + + diff --git a/docs/cs-basics/data-structure/heap.md b/docs/cs-basics/data-structure/heap.md index ab1c926bdc9..7924006c4cd 100644 --- a/docs/cs-basics/data-structure/heap.md +++ b/docs/cs-basics/data-structure/heap.md @@ -206,4 +206,42 @@ head: 堆排序完成! +## 面试复盘重点 + +堆在面试里常和优先队列、Top K、定时任务、延迟队列放在一起问。 + +| 操作 | 时间复杂度 | 说明 | +| -------- | ---------- | ------------------------------ | +| 查看堆顶 | `O(1)` | 最大堆堆顶最大,最小堆堆顶最小 | +| 插入元素 | `O(logn)` | 插入末尾后上浮 | +| 删除堆顶 | `O(logn)` | 末尾元素换到堆顶后下沉 | +| 建堆 | `O(n)` | 从最后一个非叶子节点开始下沉 | +| 堆排序 | `O(nlogn)` | 原地排序,但不稳定 | + +Java 里的 `PriorityQueue` 默认是小顶堆: + +```java +PriorityQueue minHeap = new PriorityQueue<>(); +PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> b - a); +``` + +需要注意的是,`b - a` 可能溢出,更稳妥的写法是: + +```java +PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> Integer.compare(b, a)); +``` + +Top K 问题常见选择: + +- 求第 K 大:维护大小为 K 的小顶堆。 +- 求前 K 高频:先用哈希表计数,再用小顶堆保留 K 个高频元素。 +- 数据流中位数:一个大顶堆维护较小的一半,一个小顶堆维护较大的一半。 + +## 推荐练习题 + +- [215. 数组中的第 K 个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) +- [347. 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements/) +- [703. 数据流中的第 K 大元素](https://leetcode.cn/problems/kth-largest-element-in-a-stream/) +- [295. 数据流的中位数](https://leetcode.cn/problems/find-median-from-data-stream/) + diff --git a/docs/cs-basics/data-structure/linear-data-structure.md b/docs/cs-basics/data-structure/linear-data-structure.md index b3fc8d3e31e..45a62e573cb 100644 --- a/docs/cs-basics/data-structure/linear-data-structure.md +++ b/docs/cs-basics/data-structure/linear-data-structure.md @@ -324,7 +324,7 @@ myStack.pop();//报错:java.lang.IllegalArgumentException: Stack is empty. 关于堆的具体实现可以看 [堆](https://javaguide.cn/cs-basics/data-structure/heap.html) 这一节。 -总而言之,不论我们进行什么操作,优先队列都能按照**某种排序方式**进行一系列堆的相关操作,从而保证整个集合的**有序性**。 +不论进行什么操作,优先队列都能按照**某种排序方式**进行一系列堆的相关操作,从而保证整个集合的**有序性**。 虽然优先队列的底层并非严格的线性结构,但是在我们使用的过程中,我们是感知不到**堆**的,从使用者的眼中优先队列可以被认为是一种线性的数据结构:一种会自动排序的线性队列。 @@ -341,4 +341,30 @@ myStack.pop();//报错:java.lang.IllegalArgumentException: Stack is empty. - 消息队列 - 等等…… +## 面试复盘重点 + +线性结构是算法题和 Java 集合的基础,面试里常把数组、链表、栈、队列放在一起对比。 + +| 结构 | 查询 | 插入/删除 | 典型 Java 类型 | 高频题型 | +| ---- | ------------- | ----------------- | ---------------------- | ---------------------------- | +| 数组 | 按下标 `O(1)` | 中间位置 `O(n)` | `ArrayList` 底层数组 | 二分、双指针、前缀和 | +| 链表 | `O(n)` | 已知节点时 `O(1)` | `LinkedList` | 反转链表、快慢指针、合并链表 | +| 栈 | 栈顶 `O(1)` | 栈顶 `O(1)` | `ArrayDeque` | 括号匹配、单调栈、DFS | +| 队列 | 队头 `O(1)` | 入队/出队 `O(1)` | `ArrayDeque`、阻塞队列 | BFS、生产者消费者、任务排队 | + +几个回答面试题时很有用的点: + +- 数组随机访问快,是因为内存连续,可以通过基地址和下标直接计算地址。 +- 链表插入删除快有前提:已经拿到要操作位置的节点;如果还要先查找,整体仍然是 `O(n)`。 +- Java 中不推荐继续使用 `Stack`,更常见的选择是 `Deque`,比如 `ArrayDeque`。 +- 队列在工程里不只用于算法 BFS,也用于线程池任务队列、消息队列、限流削峰等场景。 +- 循环队列的关键是区分队空和队满,常见做法是浪费一个位置或单独维护元素数量。 + +## 推荐练习题 + +- 数组:[704. 二分查找](https://leetcode.cn/problems/binary-search/)、[26. 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/) +- 链表:[206. 反转链表](https://leetcode.cn/problems/reverse-linked-list/)、[19. 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list/) +- 栈:[20. 有效的括号](https://leetcode.cn/problems/valid-parentheses/)、[739. 每日温度](https://leetcode.cn/problems/daily-temperatures/) +- 队列:[102. 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)、[239. 滑动窗口最大值](https://leetcode.cn/problems/sliding-window-maximum/) + diff --git a/docs/cs-basics/data-structure/lru-cache.md b/docs/cs-basics/data-structure/lru-cache.md new file mode 100644 index 00000000000..2cc513a6307 --- /dev/null +++ b/docs/cs-basics/data-structure/lru-cache.md @@ -0,0 +1,158 @@ +--- +title: LRU 缓存面试题总结:哈希表、双向链表与 LinkedHashMap +description: LRU 缓存面试题总结,讲解 LRU 淘汰策略、哈希表加双向链表实现、Java LinkedHashMap 写法、复杂度和缓存场景。 +category: 计算机基础 +tag: + - 数据结构 +head: + - - meta + - name: keywords + content: LRU缓存,LRU,缓存淘汰,哈希表,双向链表,LinkedHashMap,Java LRU,页面置换,数据结构面试题 +--- + +LRU 是 Least Recently Used 的缩写,意思是最近最少使用。当缓存容量满了,需要淘汰最久没有被访问的数据。 + +面试里手写 LRU 很高频,因为它把哈希表和双向链表结合在一起:哈希表负责 `O(1)` 查找节点,双向链表负责 `O(1)` 移动节点和删除尾节点。 + +## 面试考察重点 + +- 能说清为什么只用哈希表或只用链表都不够。 +- 能写 `get` 和 `put`。 +- 能解释双向链表头尾分别代表什么。 +- 能处理容量满、更新已有 key、删除尾节点等边界。 +- 能知道 Java `LinkedHashMap` 可以实现 LRU。 + +## 数据结构设计 + +| 组件 | 作用 | +| ------------------------ | ------------------------------------------------ | +| `HashMap` | 根据 key 快速找到链表节点 | +| 双向链表 | 按访问时间排序,头部是最近使用,尾部是最久未使用 | +| 虚拟头尾节点 | 简化插入和删除边界 | + +访问一个 key 后,需要把它移动到链表头部。插入新 key 时,也放到头部。容量超限时,删除尾部前一个节点。 + +## 手写 LRU + +```java +class LRUCache { + private final int capacity; + private final Map map = new HashMap<>(); + private final Node head = new Node(0, 0); + private final Node tail = new Node(0, 0); + + LRUCache(int capacity) { + this.capacity = capacity; + head.next = tail; + tail.prev = head; + } + + int get(int key) { + Node node = map.get(key); + if (node == null) { + return -1; + } + moveToHead(node); + return node.value; + } + + void put(int key, int value) { + Node node = map.get(key); + if (node != null) { + node.value = value; + moveToHead(node); + return; + } + Node newNode = new Node(key, value); + map.put(key, newNode); + addToHead(newNode); + if (map.size() > capacity) { + Node removed = removeTail(); + map.remove(removed.key); + } + } + + private void moveToHead(Node node) { + remove(node); + addToHead(node); + } + + private void addToHead(Node node) { + node.prev = head; + node.next = head.next; + head.next.prev = node; + head.next = node; + } + + private void remove(Node node) { + node.prev.next = node.next; + node.next.prev = node.prev; + } + + private Node removeTail() { + Node node = tail.prev; + remove(node); + return node; + } + + private static class Node { + int key; + int value; + Node prev; + Node next; + + Node(int key, int value) { + this.key = key; + this.value = value; + } + } +} +``` + +`get` 和 `put` 的时间复杂度都是 `O(1)`,空间复杂度是 `O(capacity)`。 + +## LinkedHashMap 实现 + +Java 的 `LinkedHashMap` 支持按访问顺序维护元素: + +```java +class LRUCacheWithLinkedHashMap extends LinkedHashMap { + private final int capacity; + + LRUCacheWithLinkedHashMap(int capacity) { + super(capacity, 0.75f, true); + this.capacity = capacity; + } + + @Override + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > capacity; + } +} +``` + +构造函数里的第三个参数 `accessOrder` 设置为 `true`,表示按照访问顺序排序,而不是插入顺序。 + +## 工程场景 + +- 本地缓存淘汰。 +- 操作系统页面置换。 +- 热点数据缓存。 +- 网关、客户端 SDK 或中间件里的小容量结果缓存。 + +真实工程里还要考虑线程安全、过期时间、最大内存、统计指标和淘汰回调。面试手写 LRU 主要考数据结构组合,不需要把这些都写进代码。 + +## 易错点 + +- 更新已有 key 时,也要移动到头部。 +- 删除尾节点后,别忘了从哈希表里删除 key。 +- 双向链表删除节点时要同时改前后两个指针。 +- 虚拟头尾节点可以减少空链表边界判断。 +- `LinkedHashMap` 的 `accessOrder` 要设为 `true`。 + +## 推荐练习题 + +- [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/) +- [460. LFU 缓存](https://leetcode.cn/problems/lfu-cache/) + + diff --git a/docs/cs-basics/data-structure/red-black-tree.md b/docs/cs-basics/data-structure/red-black-tree.md index 6550dafaac1..effd473e9a2 100644 --- a/docs/cs-basics/data-structure/red-black-tree.md +++ b/docs/cs-basics/data-structure/red-black-tree.md @@ -97,4 +97,24 @@ public class Node { - [《红黑树深入剖析及 Java 实现》 - 美团点评技术团队](https://zhuanlan.zhihu.com/p/24367771) - [漫画:什么是红黑树? - 程序员小灰](https://juejin.im/post/5a27c6946fb9a04509096248#comment)(也介绍到了二叉查找树,非常推荐) +## 面试复盘重点 + +红黑树面试一般不会要求完整手写插入删除修复,更常见的是让你说清性质、为什么近似平衡、和 AVL 树有什么区别、Java 里哪里用到了。 + +| 对比点 | AVL 树 | 红黑树 | +| -------- | ------------------ | ------------------------------------ | +| 平衡要求 | 更严格 | 相对宽松 | +| 查询性能 | 更稳定 | 也能保持 `O(logn)` | +| 插入删除 | 旋转调整可能更多 | 调整次数通常更少 | +| 常见应用 | 读多写少的搜索结构 | `TreeMap`、`TreeSet`、`HashMap` 树化 | + +面试回答可以按这个顺序组织: + +1. 普通二叉搜索树在有序插入时会退化成链表。 +2. 红黑树通过颜色规则限制树高,保证查询、插入、删除仍然是 `O(logn)`。 +3. 它不是完全平衡,而是近似平衡,所以插入删除时调整成本比 AVL 树更低。 +4. Java 中 `TreeMap`、`TreeSet` 基于红黑树,JDK 8 后 `HashMap` 链表过长时也会树化为红黑树。 + +`HashMap` 树化还要满足容量条件,并不是链表长度到阈值就一定树化。这个细节在 Java 集合面试里经常被追问。 + diff --git a/docs/cs-basics/data-structure/skip-list.md b/docs/cs-basics/data-structure/skip-list.md new file mode 100644 index 00000000000..e574f35bfd4 --- /dev/null +++ b/docs/cs-basics/data-structure/skip-list.md @@ -0,0 +1,90 @@ +--- +title: 跳表面试题总结:多级索引、范围查询与 Redis ZSet +description: 跳表面试题总结,讲解 SkipList 多级索引、查询、插入、删除、复杂度、范围查询、红黑树对比和 Redis ZSet 底层实现。 +category: 计算机基础 +tag: + - 数据结构 +head: + - - meta + - name: keywords + content: 跳表,SkipList,Redis ZSet,有序集合,范围查询,多级索引,红黑树对比,Redis面试题,数据结构面试题 +--- + +跳表可以理解为“带多级索引的有序链表”。普通有序链表查询需要从头扫到尾,时间复杂度是 `O(n)`;跳表在链表上方加了多层索引,查询时可以从高层快速跳过一批节点,再逐层下降。 + +Redis 的有序集合 ZSet 底层就使用了跳表和哈希表的组合,所以跳表在后端面试里经常和 Redis 一起出现。 + +## 面试考察重点 + +- 能说清跳表为什么比普通链表查询快。 +- 能描述查找、插入、删除的大致过程。 +- 能说明跳表平均查询、插入、删除是 `O(logn)`。 +- 能解释跳表和红黑树的取舍。 +- 能关联 Redis ZSet 的范围查询场景。 + +## 跳表怎么查找? + +查找时从最高层索引开始: + +1. 如果当前节点的下一个节点小于目标值,就向右走。 +2. 如果下一个节点大于目标值或为空,就下降一层。 +3. 到最底层后继续查找目标节点。 + +这个过程有点像在有序数组里二分,但跳表底层仍然是链表结构。 + +## 插入和删除 + +插入一个节点时,需要先找到每一层中它的前驱节点,然后把新节点接进去。新节点能提升到多少层,通常由随机函数决定。 + +删除节点时,也要找到各层前驱节点,再把指针绕过目标节点。 + +跳表不靠旋转维持平衡,而是靠随机层数让索引高度保持在合理范围内。这也是它实现起来比红黑树更容易的地方。 + +## 复杂度 + +| 操作 | 平均复杂度 | 说明 | +| -------- | ------------- | ------------------------------- | +| 查找 | `O(logn)` | 通过多级索引跳过节点 | +| 插入 | `O(logn)` | 查找位置后更新多层指针 | +| 删除 | `O(logn)` | 查找前驱后断开指针 | +| 范围查询 | `O(logn + k)` | 先定位起点,再顺序返回 k 个元素 | + +空间复杂度是 `O(n)` 级别,但会比普通链表多一些索引指针。 + +## 跳表和红黑树怎么选? + +| 对比点 | 跳表 | 红黑树 | +| ---------- | ---------------------- | ------------------------------ | +| 平衡方式 | 随机层数 | 旋转和变色 | +| 实现难度 | 相对更直接 | 插入删除修复更复杂 | +| 范围查询 | 顺着底层链表扫,很方便 | 中序遍历也可以,但实现更绕 | +| 最坏复杂度 | 依赖随机性 | 有严格平衡约束 | +| 工程代表 | Redis ZSet | Java `TreeMap`、`HashMap` 树化 | + +## Redis ZSet 为什么用跳表? + +ZSet 需要支持: + +- 按 member 快速查 score。 +- 按 score 排序。 +- 按 score 范围查询。 +- 获取排名。 + +哈希表适合按 member 查 score,跳表适合按 score 排序和范围查询。两者组合后,ZSet 能同时支持快速查找和有序遍历。 + +## 易错点 + +- 跳表不是数组,也不是二叉树,它的底层是链表。 +- 跳表平均复杂度是 `O(logn)`,不是靠严格平衡保证。 +- 范围查询是跳表的强项,先定位起点,再沿底层链表遍历。 +- Redis ZSet 不是只用跳表,还配合了哈希表。 + +## 高频问题自测 + +- 跳表为什么查询快? +- 跳表和红黑树有什么区别? +- Redis ZSet 为什么不用红黑树? +- 跳表的层数怎么决定? +- 跳表范围查询复杂度是多少? + + diff --git a/docs/cs-basics/data-structure/tree.md b/docs/cs-basics/data-structure/tree.md index a9bb6491791..f09060ec3a8 100644 --- a/docs/cs-basics/data-structure/tree.md +++ b/docs/cs-basics/data-structure/tree.md @@ -141,7 +141,7 @@ public void preOrder(TreeNode root){ if(root == null){ return; } - system.out.println(root.data); + System.out.println(root.data); preOrder(root.left); preOrder(root.right); } @@ -163,7 +163,7 @@ public void inOrder(TreeNode root){ return; } inOrder(root.left); - system.out.println(root.data); + System.out.println(root.data); inOrder(root.right); } ``` @@ -183,8 +183,51 @@ public void postOrder(TreeNode root){ } postOrder(root.left); postOrder(root.right); - system.out.println(root.data); + System.out.println(root.data); } ``` +## 面试复盘重点 + +树结构面试通常会从二叉树遍历开始,逐步追问二叉搜索树、平衡树、B 树和 B+ 树。 + +| 结构 | 特点 | 常见追问 | +| ---------- | ---------------------------------------- | ------------------------------ | +| 二叉树 | 每个节点最多两个子节点 | 前中后序遍历、层序遍历、树高 | +| 二叉搜索树 | 左子树小于根,右子树大于根 | 中序遍历有序、退化成链表 | +| AVL 树 | 高度平衡 | 查询快,插入删除旋转更频繁 | +| 红黑树 | 近似平衡 | Java `TreeMap`、`HashMap` 树化 | +| B 树 | 多路平衡搜索树 | 磁盘 IO 友好 | +| B+ 树 | 数据通常在叶子节点,叶子节点有序链表相连 | MySQL 索引、范围查询 | + +二叉树遍历模板要能手写: + +```java +void dfs(TreeNode root) { + if (root == null) { + return; + } + // 前序位置 + dfs(root.left); + // 中序位置 + dfs(root.right); + // 后序位置 +} +``` + +BST 高频回答: + +- 中序遍历二叉搜索树可以得到递增序列。 +- 如果插入数据本身有序,普通 BST 会退化成链表。 +- AVL 树比红黑树更严格平衡,查询更稳定;红黑树平衡要求宽一些,插入删除调整成本更低。 +- B+ 树适合数据库索引,一个节点能存更多 key,树高更低,叶子节点有序链表适合范围查询。 + +## 推荐练习题 + +- [144. 二叉树的前序遍历](https://leetcode.cn/problems/binary-tree-preorder-traversal/) +- [102. 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/) +- [98. 验证二叉搜索树](https://leetcode.cn/problems/validate-binary-search-tree/) +- [236. 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/) +- [105. 从前序与中序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/) + diff --git a/docs/cs-basics/data-structure/trie.md b/docs/cs-basics/data-structure/trie.md new file mode 100644 index 00000000000..69c503644a3 --- /dev/null +++ b/docs/cs-basics/data-structure/trie.md @@ -0,0 +1,121 @@ +--- +title: Trie 前缀树面试题总结:字典树原理、前缀匹配与 Java 实现 +description: Trie 前缀树面试题总结,讲解字典树节点结构、插入、查询、前缀匹配、复杂度、搜索提示、敏感词过滤和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 数据结构 +head: + - - meta + - name: keywords + content: Trie,前缀树,字典树,前缀匹配,字符串算法,搜索提示,敏感词过滤,Java Trie,LeetCode Trie,数据结构面试题 +--- + +Trie,也叫前缀树或字典树,适合处理大量字符串的前缀匹配问题。搜索提示、词典查询、敏感词过滤、路由前缀匹配,都能看到它的影子。 + +它的核心思路很直接:把字符串按字符拆开,共享相同前缀。比如 `app`、`apple`、`apply` 会共用 `a -> p -> p` 这条路径。 + +## 面试考察重点 + +- 能说清 Trie 为什么适合前缀查询。 +- 能写插入、完整单词查询、前缀查询。 +- 能分析时间复杂度和字符串长度有关。 +- 能说明 Trie 的空间开销可能比较大。 +- 能和哈希表做对比。 + +## 节点结构 + +如果只处理小写英文字母,可以用长度为 26 的数组: + +```java +class TrieNode { + TrieNode[] children = new TrieNode[26]; + boolean isWord; +} +``` + +如果字符集不固定,可以用 `Map`,空间更灵活,但每次访问有哈希表成本。 + +## 基础实现 + +```java +class Trie { + private final TrieNode root = new TrieNode(); + + public void insert(String word) { + TrieNode node = root; + for (char c : word.toCharArray()) { + int index = c - 'a'; + if (node.children[index] == null) { + node.children[index] = new TrieNode(); + } + node = node.children[index]; + } + node.isWord = true; + } + + public boolean search(String word) { + TrieNode node = find(word); + return node != null && node.isWord; + } + + public boolean startsWith(String prefix) { + return find(prefix) != null; + } + + private TrieNode find(String text) { + TrieNode node = root; + for (char c : text.toCharArray()) { + int index = c - 'a'; + if (node.children[index] == null) { + return null; + } + node = node.children[index]; + } + return node; + } +} +``` + +## 复杂度 + +设字符串长度为 `L`: + +- 插入:`O(L)` +- 查询完整单词:`O(L)` +- 查询前缀:`O(L)` + +空间复杂度取决于节点数量。最坏情况下,如果字符串几乎没有公共前缀,空间开销会接近所有字符数量之和。 + +## Trie 和哈希表怎么选? + +| 场景 | Trie | 哈希表 | +| ---------------- | ------------------ | ------------ | +| 完整字符串查询 | 可以做,但空间更大 | 更直接 | +| 前缀查询 | 很适合 | 需要额外处理 | +| 按前缀枚举所有词 | 很适合 | 不方便 | +| 字符集很大 | 需要优化节点结构 | 更省心 | + +如果只是判断一个词是否存在,哈希表通常更简单。如果要频繁查前缀,Trie 更合适。 + +## 工程场景 + +- 搜索框自动补全:根据用户输入前缀找到候选词。 +- 敏感词匹配:Trie 可以配合 AC 自动机做多模式匹配。 +- IP 路由匹配:最长前缀匹配可以借鉴 Trie 思路。 +- 词典校验:快速判断单词或前缀是否存在。 + +## 易错点 + +- `isWord` 不能省,否则无法区分 `app` 和 `apple`。 +- 字符集不一定只有小写字母,面试时要根据题目调整。 +- 删除单词比插入查询复杂,需要判断节点是否还能被其他单词复用。 +- Trie 查询复杂度和字符串长度有关,不直接和词典大小成正比。 + +## 推荐练习题 + +- [208. 实现 Trie](https://leetcode.cn/problems/implement-trie-prefix-tree/) +- [211. 添加与搜索单词](https://leetcode.cn/problems/design-add-and-search-words-data-structure/) +- [212. 单词搜索 II](https://leetcode.cn/problems/word-search-ii/) +- [648. 单词替换](https://leetcode.cn/problems/replace-words/) + + diff --git a/docs/cs-basics/data-structure/union-find.md b/docs/cs-basics/data-structure/union-find.md new file mode 100644 index 00000000000..1dcef1d45b9 --- /dev/null +++ b/docs/cs-basics/data-structure/union-find.md @@ -0,0 +1,111 @@ +--- +title: 并查集面试题总结:路径压缩、连通性与 Java 模板 +description: 并查集面试题总结,讲解 Union Find、find、union、路径压缩、按大小合并、连通性、判环、省份数量和 LeetCode 高频题。 +category: 计算机基础 +tag: + - 数据结构 +head: + - - meta + - name: keywords + content: 并查集,Union Find,路径压缩,按大小合并,连通性,图算法,判环,省份数量,Java并查集,LeetCode +--- + +并查集专门解决“分组”和“连通性”问题。两个元素是否属于同一组?合并两个集合后还有几个连通分量?图里加一条边是否会成环?这些都可以用并查集处理。 + +面试里它的代码不长,但 `find` 写不好会直接影响复杂度。 + +## 面试考察重点 + +- 能写 `find` 和 `union`。 +- 能解释路径压缩的作用。 +- 能用并查集统计连通分量。 +- 能处理图中判环、朋友圈、省份数量、等式关系。 +- 能说明并查集适合动态合并,不适合频繁删除。 + +## 基础模板 + +```java +class UnionFind { + private final int[] parent; + private final int[] size; + private int count; + + UnionFind(int n) { + parent = new int[n]; + size = new int[n]; + count = n; + for (int i = 0; i < n; i++) { + parent[i] = i; + size[i] = 1; + } + } + + int find(int x) { + if (parent[x] != x) { + parent[x] = find(parent[x]); + } + return parent[x]; + } + + boolean union(int a, int b) { + int rootA = find(a); + int rootB = find(b); + if (rootA == rootB) { + return false; + } + if (size[rootA] < size[rootB]) { + parent[rootA] = rootB; + size[rootB] += size[rootA]; + } else { + parent[rootB] = rootA; + size[rootA] += size[rootB]; + } + count--; + return true; + } + + boolean connected(int a, int b) { + return find(a) == find(b); + } + + int count() { + return count; + } +} +``` + +`parent[x]` 表示 `x` 的父节点。根节点的父节点是自己。路径压缩会让查找路径上的节点直接挂到根节点下面,后续查询更快。 + +## 复杂度 + +使用路径压缩和按大小合并后,并查集单次操作的均摊复杂度可以看作接近 `O(1)`。面试里一般说“近似常数时间”即可。 + +空间复杂度是 `O(n)`,主要来自 `parent` 和 `size` 数组。 + +## 典型场景 + +| 场景 | 处理方式 | +| -------------------- | -------------------------------------- | +| 判断两个节点是否连通 | 比较 `find(a)` 和 `find(b)` | +| 合并两个集合 | `union(a, b)` | +| 统计连通分量个数 | 初始化为 `n`,每次成功合并减 1 | +| 判断无向图是否有环 | 如果一条边两端已连通,再加边就成环 | +| 等式方程 | 先合并相等关系,再检查不等关系是否冲突 | + +## 易错点 + +- `find` 里要返回根节点,不是返回父节点。 +- 路径压缩不要写丢递归返回值。 +- `union` 时只有两个集合原本不连通,连通分量数量才减 1。 +- 并查集适合合并,不擅长删除关系。 +- 二维网格题需要把 `(i, j)` 映射成一维编号,例如 `i * cols + j`。 + +## 推荐练习题 + +- [547. 省份数量](https://leetcode.cn/problems/number-of-provinces/) +- [684. 冗余连接](https://leetcode.cn/problems/redundant-connection/) +- [990. 等式方程的可满足性](https://leetcode.cn/problems/satisfiability-of-equality-equations/) +- [1319. 连通网络的操作次数](https://leetcode.cn/problems/number-of-operations-to-make-network-connected/) +- [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) + + diff --git a/docs/database/mysql/mysql-index.md b/docs/database/mysql/mysql-index.md index cd9bc38c089..7c75909612d 100644 --- a/docs/database/mysql/mysql-index.md +++ b/docs/database/mysql/mysql-index.md @@ -123,6 +123,8 @@ AVL 树采用了旋转操作来保持平衡。主要有四种旋转操作:LL **红黑树的应用还是比较广泛的,TreeMap、TreeSet 以及 JDK1.8 的 HashMap 底层都用到了红黑树。对于数据在内存中的这种情况来说,红黑树的表现是非常优异的。** +关于二叉搜索树、AVL 树、红黑树、B 树和 B+ 树的基础对比,可以先看 [树结构详解](../../cs-basics/data-structure/tree.md) 和 [红黑树详解](../../cs-basics/data-structure/red-black-tree.md)。 + ### B 树& B+ 树 B 树也称 B- 树,全称为 **多路平衡查找树**,B+ 树是 B 树的一种变体。B 树和 B+ 树中的 B 是 `Balanced`(平衡)的意思。 @@ -138,6 +140,8 @@ B 树也称 B- 树,全称为 **多路平衡查找树**,B+ 树是 B 树的一 综上,B+ 树与 B 树相比,具备更少的 IO 次数、更稳定的查询效率和更适于范围查询这些优势。 +如果只想从数据结构角度快速复盘 B 树和 B+ 树,可以回到 [树结构详解](../../cs-basics/data-structure/tree.md) 的面试复盘部分。 + 在 MySQL 中,MyISAM 引擎和 InnoDB 引擎都是使用 B+Tree 作为索引结构,但是,两者的实现方式不太一样。(下面的内容整理自《Java 工程师修炼之道》) > MyISAM 引擎中,B+Tree 叶节点的 data 域存放的是数据记录的地址。在索引检索的时候,首先按照 B+Tree 搜索算法搜索索引,如果指定的 Key 存在,则取出其 data 域的值,然后以 data 域的值为地址读取相应的数据记录。这被称为“**非聚簇索引(非聚集索引)**”。 diff --git a/docs/database/redis/redis-questions-01.md b/docs/database/redis/redis-questions-01.md index 28c434d63c4..bbb403da8d0 100644 --- a/docs/database/redis/redis-questions-01.md +++ b/docs/database/redis/redis-questions-01.md @@ -350,7 +350,7 @@ Redis 中有一个叫做 `Sorted Set`(有序集合)的数据类型经常被 - 红黑树 vs 跳表:相比较于红黑树来说,跳表的实现也更简单一些,不需要通过旋转和染色(红黑变换)来保证黑平衡。并且,按照区间来查找数据这个操作,红黑树的效率没有跳表高。 - B+ 树 vs 跳表:B+ 树更适合作为数据库和文件系统中常用的索引结构之一,它的核心思想是通过可能少的 IO 定位到尽可能多的索引来获得查询数据。对于 Redis 这种内存数据库来说,它对这些并不感冒,因为 Redis 作为内存数据库它不可能存储大量的数据,所以对于索引不需要通过 B+ 树这种方式进行维护,只需按照概率进行随机维护即可,节约内存。而且使用跳表实现 zset 时相较前者来说更简单一些,在进行插入时只需通过索引将数据插入到链表中合适的位置再随机维护一定高度的索引即可,也不需要像 B+ 树那样插入时发现失衡时还需要对节点分裂与合并。 -另外,我还单独写了一篇文章从有序集合的基本使用到跳表的源码分析和实现,让你会对 Redis 的有序集合底层实现的跳表有着更深刻的理解和掌握:[Redis 为什么用跳表实现有序集合](https://javaguide.cn/database/redis/redis-skiplist.html)。 +另外,我还单独写了一篇文章从有序集合的基本使用到跳表的源码分析和实现,让你会对 Redis 的有序集合底层实现的跳表有着更深刻的理解和掌握:[Redis 为什么用跳表实现有序集合](https://javaguide.cn/database/redis/redis-skiplist.html)。如果只想先过一遍跳表的基础结构、复杂度和范围查询,可以看 [跳表面试题总结](https://javaguide.cn/cs-basics/data-structure/skip-list.html)。 ### Set 的应用场景是什么? @@ -461,6 +461,8 @@ Bloom Filter 的简单原理图如下: 如果我们需要判断某个字符串是否在布隆过滤器中时,只需要对给定字符串再次进行相同的哈希计算,得到值之后判断位数组中的每个元素是否都为 1,如果值都为 1,那么说明这个值在布隆过滤器中,如果存在一个值不为 1,说明该元素不在布隆过滤器中。 +关于布隆过滤器的误判、删除困难、Guava 和 RedisBloom 使用,可以继续看 [布隆过滤器详解](https://javaguide.cn/cs-basics/data-structure/bloom-filter.html)。 + ## ⭐️Redis 持久化机制(重要) Redis 持久化机制(RDB 持久化、AOF 持久化、RDB 和 AOF 的混合持久化)相关的问题比较多,也比较重要,于是我单独抽了一篇文章来总结 Redis 持久化机制相关的知识点和问题:[Redis 持久化机制详解](https://javaguide.cn/database/redis/redis-persistence.html)。 diff --git a/docs/database/redis/redis-skiplist.md b/docs/database/redis/redis-skiplist.md index d50ee58706f..777fa3e8748 100644 --- a/docs/database/redis/redis-skiplist.md +++ b/docs/database/redis/redis-skiplist.md @@ -16,6 +16,8 @@ head: 本文就以这道大厂常问的面试题为切入点,带大家详细了解一下跳表这个数据结构。 +如果你只是想先快速了解跳表的多级索引、查询复杂度和面试回答框架,可以先看 [跳表面试题总结](../../cs-basics/data-structure/skip-list.md),再回到本文看 Redis ZSet 的源码实现。 + 本文整体脉络如下图所示,笔者会从有序集合的基本使用到跳表的源码分析和实现,让你会对 Redis 的有序集合底层实现的跳表有着更深刻的理解和掌握。 ![](https://oss.javaguide.cn/javaguide/database/redis/skiplist/202401222005468.png) diff --git a/docs/interview-preparation/backend-interview-plan.md b/docs/interview-preparation/backend-interview-plan.md index 5b1c9d96c62..a60c84421f6 100644 --- a/docs/interview-preparation/backend-interview-plan.md +++ b/docs/interview-preparation/backend-interview-plan.md @@ -168,10 +168,10 @@ head: **目标字节、腾讯等重算法/基础的厂**:适当多留时间,算法与代码题要单独刷(LeetCode 热题、剑指 Offer 等等);**目标中小厂**:可压缩或后置。 -- **算法与代码题**(面字节、快手等必留时间):[剑指 Offer 题解](https://javaguide.cn/cs-basics/algorithms/the-sword-refers-to-offer.html)、LeetCode 热题 100、常见手写(如 LRU、生产者消费者、单例等)。建议每天至少 1 道,保持手感。 +- **算法与代码题**(面字节、快手等必留时间):先过 [算法专题](https://javaguide.cn/cs-basics/algorithms/) 建立路线,再重点手写 [二分查找](https://javaguide.cn/cs-basics/algorithms/binary-search.html)、[双指针与滑动窗口](https://javaguide.cn/cs-basics/algorithms/two-pointers-and-sliding-window.html)、[DFS/BFS](https://javaguide.cn/cs-basics/algorithms/dfs-bfs.html)、[回溯](https://javaguide.cn/cs-basics/algorithms/backtracking.html)、[动态规划](https://javaguide.cn/cs-basics/algorithms/dynamic-programming.html)、[Top K](https://javaguide.cn/cs-basics/algorithms/top-k.html) 这些模板;配合 [剑指 Offer 题解](https://javaguide.cn/cs-basics/algorithms/the-sword-refers-to-offer.html)、LeetCode 热题 100 和常见手写(如 LRU、生产者消费者、单例等)。建议每天至少 1 道,保持手感。 - **网络**:[计网常见面试题(上)](https://javaguide.cn/cs-basics/network/other-network-questions.html)、[(下)](https://javaguide.cn/cs-basics/network/other-network-questions2.html)、[访问网页全过程](https://javaguide.cn/cs-basics/network/the-whole-process-of-accessing-web-pages.html)、[应用层常见协议](https://javaguide.cn/cs-basics/network/application-layer-protocol.html)、[HTTP/HTTPS](https://javaguide.cn/cs-basics/network/http-vs-https.html)、[HTTP 1.0 vs 1.1](https://javaguide.cn/cs-basics/network/http1.0-vs-http1.1.html)、[DNS](https://javaguide.cn/cs-basics/network/dns.html)、[TCP 三次握手与四次挥手](https://javaguide.cn/cs-basics/network/tcp-connection-and-disconnection.html)、[TCP 可靠性](https://javaguide.cn/cs-basics/network/tcp-reliability-guarantee.html)、[ARP](https://javaguide.cn/cs-basics/network/arp.html) - **操作系统**:[操作系统常见面试题(上)](https://javaguide.cn/cs-basics/operating-system/operating-system-basic-questions-01.html)、[(下)](https://javaguide.cn/cs-basics/operating-system/operating-system-basic-questions-02.html)、[Linux 基础](https://javaguide.cn/cs-basics/operating-system/linux-intro.html) -- **数据结构**:[数组/链表/栈/队列](https://javaguide.cn/cs-basics/data-structure/linear-data-structure.html)、[图](https://javaguide.cn/cs-basics/data-structure/graph.html)、[堆](https://javaguide.cn/cs-basics/data-structure/heap.html)、[树](https://javaguide.cn/cs-basics/data-structure/tree.html)、[红黑树](https://javaguide.cn/cs-basics/data-structure/red-black-tree.html)、[布隆过滤器](https://javaguide.cn/cs-basics/data-structure/bloom-filter.html) +- **数据结构**:先过 [数据结构专题](https://javaguide.cn/cs-basics/data-structure/),再重点复盘 [数组/链表/栈/队列](https://javaguide.cn/cs-basics/data-structure/linear-data-structure.html)、[哈希表](https://javaguide.cn/cs-basics/data-structure/hash-table.html)、[树](https://javaguide.cn/cs-basics/data-structure/tree.html)、[图](https://javaguide.cn/cs-basics/data-structure/graph.html)、[堆](https://javaguide.cn/cs-basics/data-structure/heap.html)、[Trie](https://javaguide.cn/cs-basics/data-structure/trie.html)、[并查集](https://javaguide.cn/cs-basics/data-structure/union-find.html)、[跳表](https://javaguide.cn/cs-basics/data-structure/skip-list.html)、[红黑树](https://javaguide.cn/cs-basics/data-structure/red-black-tree.html)、[布隆过滤器](https://javaguide.cn/cs-basics/data-structure/bloom-filter.html)、[LRU](https://javaguide.cn/cs-basics/data-structure/lru-cache.html)。 **自测**:能画访问网页全过程、TCP 握手挥手等等;算法题能手写常见套路;OS 进程/线程、内存、死锁能说清概念与例子。 diff --git a/docs/java/collection/README.md b/docs/java/collection/README.md index f531c21715f..91f0404eefc 100644 --- a/docs/java/collection/README.md +++ b/docs/java/collection/README.md @@ -55,6 +55,8 @@ Java 集合是业务开发中使用频率最高的基础库之一,也是 Java - [HashMap 源码分析](./hashmap-source-code.md):理解数组、链表、红黑树、扰动函数、扩容和树化。 - [LinkedHashMap 源码分析](./linkedhashmap-source-code.md):理解访问顺序、插入顺序和 LRU 场景。 +如果对底层结构还不熟,可以先看 [线性数据结构详解](../../cs-basics/data-structure/linear-data-structure.md)、[哈希表面试题总结](../../cs-basics/data-structure/hash-table.md)、[红黑树详解](../../cs-basics/data-structure/red-black-tree.md) 和 [LRU 缓存面试题总结](../../cs-basics/data-structure/lru-cache.md),再回来看集合源码会顺很多。 + ### 并发集合与队列 - [ConcurrentHashMap 源码分析](./concurrent-hash-map-source-code.md):理解分段锁到 CAS + synchronized 的演进。 @@ -82,5 +84,7 @@ Java 集合是业务开发中使用频率最高的基础库之一,也是 Java - [Java 并发编程专题](../concurrent/) - [JVM 专题](../jvm/) - [数据结构](../../cs-basics/data-structure/) +- [哈希表面试题总结](../../cs-basics/data-structure/hash-table.md) +- [LRU 缓存面试题总结](../../cs-basics/data-structure/lru-cache.md) diff --git a/docs/java/collection/java-collection-questions-01.md b/docs/java/collection/java-collection-questions-01.md index 003447ab360..ad6d14f797d 100644 --- a/docs/java/collection/java-collection-questions-01.md +++ b/docs/java/collection/java-collection-questions-01.md @@ -57,8 +57,8 @@ Java 集合框架如下图所示: #### Map -- `HashMap`:JDK1.8 之前 `HashMap` 由数组+链表组成的,数组是 `HashMap` 的主体,链表则是主要为了解决哈希冲突而存在的(“拉链法”解决冲突)。JDK1.8 以后在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为 8)(将链表转换成红黑树前会判断,如果当前数组的长度小于 64,那么会选择先进行数组扩容,而不是转换为红黑树)时,将链表转化为红黑树,以减少搜索时间。详细可以查看:[HashMap 源码分析](./hashmap-source-code.md)。 -- `LinkedHashMap`:`LinkedHashMap` 继承自 `HashMap`,所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外,`LinkedHashMap` 在上面结构的基础上,增加了一条双向链表,使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作,实现了访问顺序相关逻辑。详细可以查看:[LinkedHashMap 源码分析](./linkedhashmap-source-code.md) +- `HashMap`:JDK1.8 之前 `HashMap` 由数组+链表组成的,数组是 `HashMap` 的主体,链表则是主要为了解决哈希冲突而存在的(“拉链法”解决冲突)。JDK1.8 以后在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为 8)(将链表转换成红黑树前会判断,如果当前数组的长度小于 64,那么会选择先进行数组扩容,而不是转换为红黑树)时,将链表转化为红黑树,以减少搜索时间。详细可以查看:[HashMap 源码分析](./hashmap-source-code.md),基础概念可以先看 [哈希表面试题总结](../../cs-basics/data-structure/hash-table.md)。 +- `LinkedHashMap`:`LinkedHashMap` 继承自 `HashMap`,所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外,`LinkedHashMap` 在上面结构的基础上,增加了一条双向链表,使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作,实现了访问顺序相关逻辑。详细可以查看:[LinkedHashMap 源码分析](./linkedhashmap-source-code.md),LRU 手写题可以看 [LRU 缓存面试题总结](../../cs-basics/data-structure/lru-cache.md)。 - `Hashtable`:数组+链表组成的,数组是 `Hashtable` 的主体,链表则是主要为了解决哈希冲突而存在的。 - `TreeMap`:红黑树(自平衡的排序二叉树)。 @@ -572,6 +572,8 @@ Output: `PriorityQueue` 在面试中可能更多的会出现在手撕算法的时候,典型例题包括堆排序、求第 K 大的数、带权图的遍历等,所以需要会熟练使用才行。 +如果想先补堆和 Top K 的算法模板,可以看 [堆详解](../../cs-basics/data-structure/heap.md) 和 [Top K 问题面试题总结](../../cs-basics/algorithms/top-k.md)。 + ### 什么是 BlockingQueue? `BlockingQueue` (阻塞队列)是一个接口,继承自 `Queue`。`BlockingQueue`阻塞的原因是其支持当队列没有元素时一直阻塞,直到有元素;还支持如果队列已满,一直等到队列可以放入新元素时再放入。 From 7282891b1c17585b16f54e9512d17df64ca7cb42 Mon Sep 17 00:00:00 2001 From: Guide Date: Thu, 11 Jun 2026 18:08:37 +0800 Subject: [PATCH 011/116] docs: polish interview and tooling guides --- README_EN.md | 12 +- docs/REVIEW.md | 394 ++++++++++++++++++ .../10-classical-sorting-algorithms.md | 10 +- docs/cs-basics/algorithms/backtracking.md | 12 +- docs/cs-basics/algorithms/binary-search.md | 66 +++ .../algorithms/complexity-analysis.md | 18 +- .../algorithms/dynamic-programming.md | 68 +++ docs/cs-basics/algorithms/greedy.md | 11 + .../algorithms/string-algorithm-problems.md | 2 +- docs/cs-basics/algorithms/top-k.md | 16 +- .../two-pointers-and-sliding-window.md | 79 ++++ docs/cs-basics/data-structure/hash-table.md | 56 +++ docs/cs-basics/data-structure/heap.md | 8 +- docs/cs-basics/data-structure/lru-cache.md | 54 +++ docs/cs-basics/operating-system/ipc.md | 6 +- .../operating-system-basic-questions-01.md | 2 +- .../operating-system/process-and-thread.md | 6 +- docs/high-performance/README.md | 15 +- docs/high-performance/cdn.md | 23 +- .../data-cold-hot-separation.md | 27 +- .../deep-pagination-optimization.md | 19 +- .../high-performance-interview-questions.md | 18 + ...-performance-system-interview-questions.md | 18 +- docs/high-performance/load-balancing.md | 34 ++ docs/high-performance/message-queue/README.md | 13 + .../message-queue/disruptor-questions.md | 24 +- .../message-queue/kafka-questions-01.md | 57 ++- .../message-queue/message-queue.md | 72 +++- .../message-queue/rabbitmq-questions.md | 30 +- .../message-queue/rocketmq-questions.md | 39 +- ...d-write-separation-and-library-subtable.md | 30 +- docs/high-performance/sql-optimization.md | 32 +- docs/java/concurrent/virtual-thread.md | 13 +- docs/tools/README.md | 26 +- docs/tools/docker/README.md | 8 +- docs/tools/docker/docker-in-action.md | 116 +++--- docs/tools/docker/docker-intro.md | 205 +++++---- docs/tools/git/README.md | 8 +- docs/tools/git/git-intro.md | 56 ++- docs/tools/git/github-tips.md | 88 ++-- docs/tools/gradle/gradle-core-concepts.md | 53 +-- docs/tools/maven/README.md | 10 +- docs/tools/maven/maven-best-practices.md | 86 ++-- docs/tools/maven/maven-core-concepts.md | 6 +- 44 files changed, 1536 insertions(+), 410 deletions(-) create mode 100644 docs/REVIEW.md diff --git a/README_EN.md b/README_EN.md index d5aa5de2fa1..fad6425c5c0 100644 --- a/README_EN.md +++ b/README_EN.md @@ -11,7 +11,7 @@ An open-source guide for backend developers on AI application development, AI pr ## Backend Interview Preparation -- [⭐Java Backend Interview Preparation Plan (Covering General Backend System)](./docs/interview-preparation/backend-interview-plan.md) (Must-see :+1:) +- [⭐Java Backend Interview Preparation Plan (Covering General Backend System)](./docs/interview-preparation/backend-interview-plan.md) (Must-read :+1:) - [How to Efficiently Prepare for Java Interviews?](./docs/interview-preparation/teach-you-how-to-prepare-for-the-interview-hand-in-hand.md) - [Key Summary of Java Backend Interviews](./docs/interview-preparation/key-points-of-interview.md) - [Java Learning Roadmap (Latest, 4w+ Words)](./docs/interview-preparation/java-roadmap.md) @@ -24,7 +24,7 @@ An open-source guide for backend developers on AI application development, AI pr ### Basics -**Knowledge Points/Interview Questions Summary** (Must-see:+1:): +**Knowledge Points/Interview Questions Summary** (Must-read :+1:): - [Summary of Common Java Basics Knowledge Points & Interview Questions (Part 1)](./docs/java/basis/java-basic-questions-01.md) - [Summary of Common Java Basics Knowledge Points & Interview Questions (Part 2)](./docs/java/basis/java-basic-questions-02.md) @@ -46,8 +46,8 @@ An open-source guide for backend developers on AI application development, AI pr **Knowledge Points/Interview Questions Summary**: -- [Summary of Common Java Collection Knowledge Points & Interview Questions (Part 1)](./docs/java/collection/java-collection-questions-01.md) (Must-see :+1:) -- [Summary of Common Java Collection Knowledge Points & Interview Questions (Part 2)](./docs/java/collection/java-collection-questions-02.md) (Must-see :+1:) +- [Summary of Common Java Collection Knowledge Points & Interview Questions (Part 1)](./docs/java/collection/java-collection-questions-01.md) (Must-read :+1:) +- [Summary of Common Java Collection Knowledge Points & Interview Questions (Part 2)](./docs/java/collection/java-collection-questions-02.md) (Must-read :+1:) - [Summary of Java Container Usage Precautions](./docs/java/collection/java-collection-precautions-for-use.md) **Source Code Analysis**: @@ -219,7 +219,7 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo ### Redis -**Knowledge Points/Interview Questions Summary** (Must-read:+1:): +**Knowledge Points/Interview Questions Summary** (Must-read :+1:): - [Redis Common Knowledge Points & Interview Questions Summary (Part 1)](./docs/database/redis/redis-questions-01.md) - [Redis Common Knowledge Points & Interview Questions Summary (Part 2)](./docs/database/redis/redis-questions-02.md) @@ -284,7 +284,7 @@ Additionally, [GeeksforGeeks](https://www.geeksforgeeks.org/fundamentals-of-algo #### Spring/SpringBoot (Must-read :+1:) -**Knowledge Points/Interview Questions Summary** : +**Knowledge Points/Interview Questions Summary**: - [Summary of Common Spring Knowledge Points and Interview Questions](./docs/system-design/framework/spring/spring-knowledge-and-questions-summary.md) - [Summary of Common SpringBoot Knowledge Points and Interview Questions](./docs/system-design/framework/spring/springboot-knowledge-and-questions-summary.md) diff --git a/docs/REVIEW.md b/docs/REVIEW.md new file mode 100644 index 00000000000..364e9a440ad --- /dev/null +++ b/docs/REVIEW.md @@ -0,0 +1,394 @@ +# 代码审核报告 + +> 审核时间:2026-06-11 +> 审核范围:最近 3 次提交 + 本地未提交改动(共 45 个文件,约 +4000 行) + +--- + +## 审核范围概览 + +| 审核范围 | 提交/状态 | 文件数 | 改动量 | +| --------------------------------------- | ---------- | ------ | -------- | +| 提交 1:算法和数据结构面试文章优化 | `a2cea626` | 34 | +2851 行 | +| 提交 2:新增进程线程和 IPC 指南 | `0cb5d7c2` | 8 | +512 行 | +| 提交 3:优化 Java 虚拟线程和 OS 文章 | `8b95e8bc` | 11 | +669 行 | +| 本地改动:cs-basics 目录 | 未提交 | 6 | +314 行 | +| 本地改动:high-performance + tools 目录 | 未提交 | 17 | +580 行 | + +--- + +## P0 必修问题(共 3 个) + +### P0-1:`virtual-thread.md` — JEP 491 在 JDK 24 中是 Preview 特性 + +**来源**:提交 3(`8b95e8bc`) + +**位置**:`docs/java/concurrent/virtual-thread.md` 第 274、303、443 行等多处 + +**问题**:JEP 491(Synchronize Virtual Threads without Pinning)在 JDK 24 中以 **Preview** 状态交付,需要启动时加 `--enable-preview` 才能生效。但文中多处表述为"已解决""已经基本解决",会让读者误以为升级到 JDK 24 就自动受益。 + +**原文摘录**: + +> "JDK 24 的 JEP 491 改进了这一点,使虚拟线程在 `synchronized` 中阻塞时也能释放底层平台线程,消除了绝大多数由 `synchronized` 带来的 Pinning 场景。" + +**修复建议**:在首次提到 JEP 491 时加上一句说明,例如: + +> "JEP 491 目前在 JDK 24 中以预览特性提供,需要在启动时加 `--enable-preview` 参数才能生效。" + +后续提到时可用"JDK 24+ 预期解决"等措辞。 + +--- + +### P0-2:`README_EN.md` — 引用了不存在的 AIGuide 项目 + +**来源**:提交 3(`8b95e8bc`) + +**位置**:`README_EN.md` 第 23-29 行 + +**问题**:新增了一段 AI Guide 项目描述,指向 `https://github.com/Snailclimb/AIGuide`,但 JavaGuide 仓库中并无此项目。 + +**修复建议**:如果是后续计划,在正式上线前不应出现在 README 中;如果是误提交,删除这段内容。 + +--- + +### P0-3:`docker-intro.md` — Docker Compose 示例 volume 名不匹配 + +**来源**:本地未提交改动 + +**位置**:`docs/tools/docker/docker-intro.md` Compose YAML 示例 + +**问题**:顶层 `volumes` 声明了 `db_data`,但服务中引用的是 `web_data`,名称不一致,运行时会报错。 + +**修复建议**:将服务中的 `web_data` 改为 `db_data`,或统一命名。 + +--- + +## P1 建议修复(共 15 个) + +### P1-1:`greedy.md` — 区间贪心模板缺少空数组边界检查 + +**来源**:提交 1(`a2cea626`) + +**位置**:`docs/cs-basics/algorithms/greedy.md` 第 14 行 + +**问题**:`eraseOverlapIntervals` 模板直接访问 `intervals[0][1]`,如果 `intervals` 为空会抛 `ArrayIndexOutOfBoundsException`。 + +```java +int eraseOverlapIntervals(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt(a -> a[1])); + int count = 1; + int end = intervals[0][1]; // 空数组会崩 +``` + +**修复建议**:在方法开头加 `if (intervals.length == 0) return 0;`,或在易错点里提到这个边界。 + +--- + +### P1-2:`top-k.md` — 小顶堆过程示意不够严谨 + +**来源**:提交 1(`a2cea626`) + +**位置**:`docs/cs-basics/algorithms/top-k.md` 过程示意表 + +**问题**:读入 `1` 后堆内容标注为 `[1, 3, 2]`。Java 的 `PriorityQueue` 内部数组顺序不一定完全反映堆的层序结构。 + +**修复建议**:改为更关注"堆顶和堆大小"而非"堆内容数组",或加一句说明这是简化表示。 + +--- + +### P1-3:`top-k.md` + `greedy.md` — 缺少"高频问题自测"章节 + +**来源**:提交 1(`a2cea626`) + +**位置**:`docs/cs-basics/algorithms/top-k.md`、`docs/cs-basics/algorithms/greedy.md` + +**问题**:所有新增的模板文章都有"高频问题自测"章节,但 `top-k.md` 和 `greedy.md` 没有,结构不一致。 + +**修复建议**:补上自测问题,例如: + +- `top-k.md`:堆和快排分区的复杂度对比?小顶堆和大顶堆怎么选?数据流中位数怎么用双堆? +- `greedy.md`:贪心和动态规划怎么区分?区间排序字段怎么选? + +--- + +### P1-4:多篇模板文章 — "代表题精讲"缺少完整 walkthrough + +**来源**:提交 1(`a2cea626`) + +**位置**:`binary-search.md`、`dynamic-programming.md` 等模板文章 + +**问题**:"代表题精讲"部分更多是代码模板 + 文字解释,缺少一道题从题目描述 → 思路推导 → 代码实现的完整 walkthrough。 + +**修复建议**:在每篇模板文章中选一道代表题做 2-3 段的精讲,至少覆盖思路推导和边界处理。 + +--- + +### P1-5:`ipc.md` 第 21 行 — "的/得"语法错误 + +**来源**:提交 2(`0cb5d7c2`) + +**位置**:`docs/cs-basics/operating-system/ipc.md` 第 21 行 + +**问题**:"做不**的**"应为"做不**得**"。 + +**修复建议**:改为"做不得"。 + +--- + +### P1-6:`process-and-thread.md` — 三处图片 alt 文本缺失 + +**来源**:提交 2(`0cb5d7c2`) + +**位置**:`docs/cs-basics/operating-system/process-and-thread.md` 三处图片 + +**问题**:`![ ](...)` 的 alt 文本为空,影响可访问性。 + +**修复建议**:为每张图片补充有意义的 alt 描述文本。 + +--- + +### P1-7:面试题与专题文章内容重复度过高 + +**来源**:提交 2(`0cb5d7c2`) + +**位置**:`operating-system-basic-questions-01.md` vs `process-and-thread.md` / `ipc.md` + +**问题**:fork/exec/wait、管道、信号量等内容在面试题文章和新增的专题文章中重复度很高。 + +**修复建议**:面试题文章保留简短回答 + 链接指向专题文章,专题文章做详细展开,减少维护成本。 + +--- + +### P1-8:`virtual-thread.md` 第 259 行 — 调度器模式描述不精确 + +**来源**:提交 3(`8b95e8bc`) + +**位置**:`docs/java/concurrent/virtual-thread.md` 第 259 行 + +**问题**:调度器只说"FIFO 模式的 ForkJoinPool",JEP 444 原文描述调度器为 FIFO 提交队列 + **work-stealing** 的 ForkJoinPool。只说"FIFO 模式"可能让人误以为是简单的先进先出调度。 + +**修复建议**:改为"调度器是一个采用 FIFO 提交策略的 `ForkJoinPool`(底层仍为 work-stealing 模式)"。 + +--- + +### P1-9:`README_EN.md` — 大小写不统一 + 多余冒号 + +**来源**:提交 3(`8b95e8bc`) + +**位置**:`README_EN.md` 第 67、91、138、162、183、186 行 + +**问题**: + +- `Must-read` / `Must-Read` 大小写不统一 +- 第 67 行 `Must-see:+1:):` 括号/冒号组合错误 +- 第 186 行 `Summary** :` 冒号位置错误 + +**修复建议**:统一为 `Must-read` 或 `Must-Read`,清理多余冒号。 + +--- + +### P1-10:`virtual-thread.md` — 缺少 header/footer include + +**来源**:提交 3(`8b95e8bc`) + +**位置**:`docs/java/concurrent/virtual-thread.md` 开头和结尾 + +**问题**:其他同类文章有 `@include: @article-header.snippet.md` 和 `@article-footer.snippet.md`,但虚拟线程文章没有,会导致站点上缺少页脚组件。 + +**修复建议**:在文件开头和结尾分别加上对应的 include 片段。 + +--- + +### P1-11:`10-classical-sorting-algorithms.md` — 移除"本文转自"声明后丢失出处归属 + +**来源**:本地未提交改动 + +**位置**:`docs/cs-basics/algorithms/10-classical-sorting-algorithms.md` + +**问题**:移除了"本文转自:"声明。虽然文章末尾"参考文章"仍保留了同源链接,但正文顶部不再有出处信息,可能让读者误以为全文为原创。 + +**修复建议**:在"参考文章"部分将第一个链接标注为主参考来源,或在 frontmatter 后保留一行引用说明。 + +--- + +### P1-12:`dynamic-programming.md` — `coinChange` 缺少 import 说明 + +**来源**:本地未提交改动 + +**位置**:`docs/cs-basics/algorithms/dynamic-programming.md` 第 176-189 行 + +**问题**:`Arrays.fill(dp, max)` 需要导入 `java.util.Arrays`,但代码块中没有 import 语句或说明。 + +**修复建议**:在代码块前加一句"需要导入 `java.util.Arrays`",或在代码顶部加上 import 语句。 + +--- + +### P1-13:`binary-search.md` — 重复代码缺少注释说明 + +**来源**:本地未提交改动 + +**位置**:`docs/cs-basics/algorithms/binary-search.md` 第 214-250 行 + +**问题**:"代表题精讲"中重复了 `lowerBound` 和 `upperBound` 的完整实现,虽然从教学角度看重复是合理的,但缺少注释说明与上文模板一致。 + +**修复建议**:在重复代码上方加一句:"这两个辅助方法与上文模板一致,此处不再重复解释。" + +--- + +### P1-14:`docker-intro.md` — Compose 示例网络声明不一致 + +**来源**:本地未提交改动 + +**位置**:`docs/tools/docker/docker-intro.md` Compose YAML 示例 + +**问题**:网络声明方式在示例中不一致,有的声明了自定义网络,有的使用默认网络。 + +**修复建议**:统一 Compose 示例中的网络声明方式。 + +--- + +### P1-15:`maven-best-practices.md` — `maven.compiler.release` 缺少版本前提 + +**来源**:本地未提交改动 + +**位置**:`docs/tools/maven/maven-best-practices.md` + +**问题**:推荐使用 `maven.compiler.release` 但没有说明这个属性需要 Java 9+。 + +**修复建议**:加一句说明"该属性需要 Java 9+,如果项目仍需兼容 Java 8,请继续使用 `source` 和 `target`"。 + +--- + +## P2 可选优化(共 15 个) + +### P2-1:`10-classical-sorting-algorithms.md` — 桶排序描述偏模糊 + +**来源**:提交 1 + +**问题**:桶排序最坏时间复杂度写"可能退化",建议明确写为 `O(n²)`(所有元素进同一个桶)。 + +--- + +### P2-2:`string-algorithm-problems.md` — KMP 说法过于绝对 + +**来源**:提交 1 + +**问题**:"面试中不一定要求从零推导"可能让读者误以为 KMP 不重要。建议改为"通常不要求从零推导 `next` 数组的手工计算过程,但要理解它的作用是跳过已匹配前缀"。 + +--- + +### P2-3:`complexity-analysis.md` — `O(2^n)` 描述不准确 + +**来源**:提交 1 + +**问题**:"结果数量本身就是指数级"不完全准确。建议改为"子集枚举的搜索空间是指数级"。 + +--- + +### P2-4:`binary-search.md` — 答案二分最大速度上限假设 + +**来源**:提交 1 + +**问题**:示例中 `right` 取 `max(piles)` 在 `h >= piles.length` 时成立,建议加一句说明该题约束条件。 + +--- + +### P2-5:`heap.md` — 大顶堆比较器首选写法 + +**来源**:提交 1 + +**问题**:先给了 `(a, b) -> b - a` 的有隐患写法再纠正,建议直接把 `Integer.compare(b, a)` 作为首选。 + +--- + +### P2-6:`backtracking.md` — 去重章节与子集模板去重内容重复 + +**来源**:提交 1 + +**问题**:子集模板部分已讲了去重代码,"去重怎么做"章节又重复了同一段代码。建议合并或让去重章节更综合地总结三种策略差异。 + +--- + +### P2-7:`classical-algorithm-problems-recommendations.md` — 7/30 天路线三处重复 + +**来源**:提交 1 + +**问题**:三份文件各自有"7 天速刷"和"30 天路线"表格,内容高度重复,增加维护成本。建议集中在 README.md 里,其他两篇只放链接。 + +--- + +### P2-8:`tree.md` — 面试复盘内容相对单薄 + +**来源**:提交 1 + +**问题**:树结构只新增了约 49 行"面试复盘重点",而其他结构(哈希表、LRU、并查集)都是完整的独立文章(100-160 行)。建议后续补充覆盖遍历、路径、构造、LCA 等高频题型。 + +--- + +### P2-9:两篇新 OS 文章 — "小 G"自称不一致 + +**来源**:提交 2 + +**问题**:`process-and-thread.md` 和 `ipc.md` 中"小 G"的使用方式不完全一致。 + +--- + +### P2-10:`virtual-thread.md` — Scoped Values 缺少 JEP 编号 + +**来源**:提交 3 + +**问题**:提到 Scoped Values 但没有给 JEP 编号(JEP 429 / JEP 481)。建议改为"JEP 481 中的 Scoped Values(第三次预览)也值得关注"。 + +--- + +### P2-11:`virtual-thread.md` — 协程面试题可补充 Go goroutine 对比 + +**来源**:提交 3 + +**问题**:面试中经常追问与 Go goroutine 的对比,可补一句区分。 + +--- + +### P2-12:`operating-system-basic-questions-01.md` — Windows Event 同步原语被隐去 + +**来源**:提交 3 + +**问题**:原"事件(Event)"被替换为"条件变量/事件通知",Windows Event 的概念被隐去了。建议补一句"Windows 中的 Event 对象也属于这类通知机制的特化实现"。 + +--- + +### P2-13:`hash-table.md` — "先查再加"解释可补具体例子 + +**来源**:本地改动 + +**问题**:`k = 0` 的边界场景解释准确但缺少具体例子。建议补一个例子,如 `nums = [1]`, `k = 0`,先查再加返回 0(正确),先加再查返回 1(错误)。 + +--- + +### P2-14:`lru-cache.md` — 操作过程示意表缺少初始状态 + +**来源**:本地改动 + +**问题**:表格直接从 `put(1, 1)` 开始,缺少初始空缓存状态行。建议在第一行前添加"初始状态 → (空) → 虚拟头尾相连,缓存为空"。 + +--- + +### P2-15:`kafka-questions-01.md` — KRaft 保留的版本锚点丢失 + +**来源**:本地改动 + +**问题**:修改后丢失了 KRaft 模式相关的具体版本信息,建议保留版本锚点以便读者确认。 + +--- + +## 整体评价 + +| 维度 | 评分 | 说明 | +| ---------- | ---- | ------------------------------------------------------------------------- | +| 代码正确性 | 优 | 所有代码示例逻辑正确(在题目约束范围内),仅 greedy.md 有空数组边界遗漏 | +| 内容准确性 | 优 | 技术解释准确,"面试手写路径"等新增模块实用性强 | +| 排版规范 | 优 | Markdown 格式统一,代码块标注一致,与原文风格高度统一 | +| 改动质量 | 优 | 虚拟线程重写、OS 文章修正、Docker 重写均为实质性提升 | +| 维护成本 | 中 | 部分内容存在跨文件重复(7/30 天路线、fork/exec/wait),后续需关注同步问题 | + +**结论**:修复 3 个 P0 后即可合并。P1 建议在本次或下次提交中逐步修复。P2 可按需优化。 diff --git a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md index 1fa95ae45d0..280255d1406 100644 --- a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md +++ b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md @@ -10,8 +10,6 @@ head: content: 排序算法,快速排序,归并排序,堆排序,冒泡排序,选择排序,插入排序,希尔排序,桶排序,计数排序,基数排序,时间复杂度,空间复杂度,稳定性 --- -> 本文转自:,JavaGuide 对其做了补充完善。 - ## 引言 @@ -58,9 +56,9 @@ head: 比较类排序的优势是,适用于各种规模的数据,也不在乎数据的分布,都能进行排序。可以说,比较排序适用于一切需要排序的情况。 -而**计数排序**、**基数排序**、**桶排序**则属于**非比较类排序算法**。非比较排序不通过比较来决定元素间的相对次序,而是通过确定每个元素之前,应该有多少个元素来排序。由于它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。 非比较排序只要确定每个元素之前的已有的元素个数即可,所有一次遍历即可解决。算法时间复杂度 $O(n)$。 +而**计数排序**、**基数排序**、**桶排序**则属于**非比较类排序算法**。非比较排序不通过比较来决定元素间的相对次序,而是通过确定每个元素之前,应该有多少个元素来排序。由于它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。非比较排序只要确定每个元素之前已有的元素个数即可,所以一次遍历即可解决。算法时间复杂度 $O(n)$。 -非比较排序时间复杂度底,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。 +非比较排序时间复杂度低,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。 ## 冒泡排序 (Bubble Sort) @@ -771,7 +769,7 @@ public static int[] radixSort(int[] arr) { ## 参考文章 -- +- [排序算法总结(本文主要参考来源)](https://www.cnblogs.com/guoyaohua/p/8600214.html) - - @@ -788,7 +786,7 @@ public static int[] radixSort(int[] arr) { | 快速排序 | `O(nlogn)` | `O(n^2)` | `O(logn)` | 不稳定 | 是 | | 堆排序 | `O(nlogn)` | `O(nlogn)` | `O(1)` | 不稳定 | 是 | | 计数排序 | `O(n+k)` | `O(n+k)` | `O(n+k)` | 稳定 | 否 | -| 桶排序 | 和数据分布有关 | 可能退化 | `O(n+k)` | 取决于桶内排序 | 否 | +| 桶排序 | 和数据分布有关 | `O(n^2)` | `O(n+k)` | 取决于桶内排序 | 否 | | 基数排序 | `O(nk)` | `O(nk)` | `O(n+k)` | 稳定 | 否 | 几个高频追问: diff --git a/docs/cs-basics/algorithms/backtracking.md b/docs/cs-basics/algorithms/backtracking.md index 8bf95957cb7..1c90bdd2963 100644 --- a/docs/cs-basics/algorithms/backtracking.md +++ b/docs/cs-basics/algorithms/backtracking.md @@ -146,15 +146,11 @@ if (i > start && nums[i] == nums[i - 1]) { ## 去重怎么做? -如果输入有重复元素,通常先排序,再在同一层跳过重复选择: +如果输入有重复元素,通常先排序,再根据题型选择去重策略: -```java -if (i > start && nums[i] == nums[i - 1]) { - continue; -} -``` - -这句的含义是:同一层里,前一个相同数字已经作为开头尝试过了,当前数字再作为开头会产生重复结果。 +- 子集、组合这类按下标向后选择的题,跳过同一层重复元素,例如 `i > start && nums[i] == nums[i - 1]`。 +- 全排列这类每层都可能从头扫描的题,通常还要结合 `used[]`,避免同一个位置被重复使用。 +- 去重判断要区分“同一层重复选择”和“同一路径重复使用”。前者会产生重复答案,后者可能正是题目允许的选择。 ## 过程示意和边界样例 diff --git a/docs/cs-basics/algorithms/binary-search.md b/docs/cs-basics/algorithms/binary-search.md index 291508d9e3c..52ff9695488 100644 --- a/docs/cs-basics/algorithms/binary-search.md +++ b/docs/cs-basics/algorithms/binary-search.md @@ -148,6 +148,8 @@ int upperBound(int[] nums, int target) { 1. 确定答案范围。比如速度最小是 `1`,最大不超过最大那堆香蕉数。 2. 写 `check` 函数。给定一个速度,判断能不能在 `h` 小时内吃完。 +这个上界成立依赖题目约束:`h >= piles.length`。因为速度等于最大堆大小时,每堆香蕉最多 1 小时吃完,总耗时不会超过堆数。 + ```java int minEatingSpeed(int[] piles, int h) { int left = 1; @@ -189,6 +191,70 @@ boolean canFinish(int[] piles, int h, int speed) { 如果题目里有“第一个”“最后一个”“最小可行”“最大可行”,不要急着写基础二分,先判断是不是边界问题。 +## 面试手写路径 + +二分题的代码不长,面试里更容易被追问的是“你为什么敢丢掉一半”。手写时可以按这个顺序来: + +1. 先说明搜索空间:是在数组下标里找,还是在答案范围里找。 +2. 再说明单调性:`mid` 左右两侧为什么可以排除一边。 +3. 明确区间含义:闭区间 `[left, right]` 还是左闭右开 `[left, right)`。 +4. 写更新规则:`mid` 还能不能成为答案,决定写 `right = mid` 还是 `right = mid - 1`。 +5. 最后说返回值:循环结束时 `left`、`right` 分别代表什么。 + +一个很实用的自检问题是:**当 `nums[mid]` 正好满足条件时,我有没有把可能的答案删掉?** 左边界、答案二分里,`mid` 经常仍然可能是答案,所以不能随手写成 `right = mid - 1`。 + +## 代表题精讲:查找第一个和最后一个位置 + +[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/) 是边界二分的典型题。题目要求返回 `target` 的起始和结束位置,如果不存在返回 `[-1, -1]`。 + +这题不要写成“找到一个 target 后向两边扫描”。虽然能过一些用例,但最坏情况下会退化成 `O(n)`。更稳的写法是做两次边界查找: + +- 第一次找第一个大于等于 `target` 的位置。 +- 第二次找第一个大于 `target` 的位置,再减 1。 + +下面两个辅助方法与上文模板一致,这里保留完整代码,方便把返回值含义和主逻辑放在一起对照。 + +```java +int[] searchRange(int[] nums, int target) { + int left = lowerBound(nums, target); + if (left == nums.length || nums[left] != target) { + return new int[] {-1, -1}; + } + int right = upperBound(nums, target) - 1; + return new int[] {left, right}; +} + +int lowerBound(int[] nums, int target) { + int left = 0; + int right = nums.length; + while (left < right) { + int mid = left + (right - left) / 2; + if (nums[mid] >= target) { + right = mid; + } else { + left = mid + 1; + } + } + return left; +} + +int upperBound(int[] nums, int target) { + int left = 0; + int right = nums.length; + while (left < right) { + int mid = left + (right - left) / 2; + if (nums[mid] > target) { + right = mid; + } else { + left = mid + 1; + } + } + return left; +} +``` + +面试里这题常见追问是:如果数组中全是 `target` 怎么办?如果 `target` 不存在但应该插在中间怎么办?这两个问题其实都在考返回值含义。`lowerBound` 返回的是第一个满足条件的位置,不保证这个位置上的值一定等于 `target`,所以返回前要再检查一次。 + ## 过程示意和边界样例 以左边界模板为例,数组 `[1, 2, 2, 2, 4]` 中找第一个大于等于 `2` 的位置: diff --git a/docs/cs-basics/algorithms/complexity-analysis.md b/docs/cs-basics/algorithms/complexity-analysis.md index c17a9754e9d..5fee7d8b98c 100644 --- a/docs/cs-basics/algorithms/complexity-analysis.md +++ b/docs/cs-basics/algorithms/complexity-analysis.md @@ -36,15 +36,15 @@ head: ## 常见复杂度量级 -| 复杂度 | 常见场景 | 面试备注 | -| ---------- | ---------------------------------------- | ---------------------- | -| `O(1)` | 数组按下标访问、栈顶操作、哈希表平均查询 | 哈希表最坏可能退化 | -| `O(logn)` | 二分查找、堆上浮/下沉、平衡树查询 | 每轮把规模缩小一部分 | -| `O(n)` | 单次遍历数组、链表、字符串 | 看是否真的只扫一遍 | -| `O(nlogn)` | 快排平均、归并排序、堆排序 | 排序题最常见量级 | -| `O(n^2)` | 双重循环、枚举两两组合 | 面试中要警惕是否能优化 | -| `O(2^n)` | 子集枚举、部分回溯 | 结果数量本身就是指数级 | -| `O(n!)` | 全排列、旅行商暴力解 | 只适合小规模输入 | +| 复杂度 | 常见场景 | 面试备注 | +| ---------- | ---------------------------------------- | -------------------------- | +| `O(1)` | 数组按下标访问、栈顶操作、哈希表平均查询 | 哈希表最坏可能退化 | +| `O(logn)` | 二分查找、堆上浮/下沉、平衡树查询 | 每轮把规模缩小一部分 | +| `O(n)` | 单次遍历数组、链表、字符串 | 看是否真的只扫一遍 | +| `O(nlogn)` | 快排平均、归并排序、堆排序 | 排序题最常见量级 | +| `O(n^2)` | 双重循环、枚举两两组合 | 面试中要警惕是否能优化 | +| `O(2^n)` | 子集枚举、部分回溯 | 子集枚举的搜索空间是指数级 | +| `O(n!)` | 全排列、旅行商暴力解 | 只适合小规模输入 | 一般来说,算法题输入规模会暗示可接受复杂度: diff --git a/docs/cs-basics/algorithms/dynamic-programming.md b/docs/cs-basics/algorithms/dynamic-programming.md index b6dafdb6bae..c517e15c68f 100644 --- a/docs/cs-basics/algorithms/dynamic-programming.md +++ b/docs/cs-basics/algorithms/dynamic-programming.md @@ -149,6 +149,65 @@ int unboundedKnapsack(int[] weights, int[] values, int capacity) { 如果一开始想不清遍历顺序,可以先写记忆化搜索。等状态关系清楚后,再改成递推。很多树形 DP、区间 DP,用记忆化搜索更容易写对。 +## 面试手写路径 + +DP 题不建议直接从代码开始。面试手写时,可以先把下面 4 句话讲清楚: + +1. `dp` 数组的含义是什么,答案最终落在哪个位置。 +2. 当前状态依赖哪些旧状态,为什么这些旧状态已经算过。 +3. 初始化为什么这样写,尤其是 `0`、`1`、无穷大分别代表什么。 +4. 遍历顺序为什么不会提前使用未计算或不该重复使用的状态。 + +如果这 4 句话说不清,代码大概率是靠记忆写出来的,遇到变体就容易散。 + +## 代表题精讲:零钱兑换 + +[322. 零钱兑换](https://leetcode.cn/problems/coin-change/) 是完全背包里很适合面试的一题。题目给定硬币面额和目标金额,问凑成目标金额最少需要多少枚硬币,每种硬币可以使用无限次。 + +状态定义可以这样说: + +```text +dp[j] 表示凑成金额 j 所需的最少硬币数。 +``` + +初始化是这题的关键。`dp[0] = 0`,表示凑成金额 0 不需要硬币;其他金额先设成一个不可能的较大值,表示暂时不可达。 + +代码里用到 `Arrays.fill`,需要导入 `java.util.Arrays`。 + +```java +int coinChange(int[] coins, int amount) { + int max = amount + 1; + int[] dp = new int[amount + 1]; + Arrays.fill(dp, max); + dp[0] = 0; + + for (int coin : coins) { + for (int j = coin; j <= amount; j++) { + dp[j] = Math.min(dp[j], dp[j - coin] + 1); + } + } + + return dp[amount] == max ? -1 : dp[amount]; +} +``` + +为什么容量正序遍历?因为一枚硬币可以用多次。计算 `dp[j]` 时使用 `dp[j - coin]`,如果 `dp[j - coin]` 已经在本轮被当前硬币更新过,就代表当前硬币可以继续被使用,这正好符合完全背包。 + +如果题目变成“每种硬币只能用一次”,容量就要倒序遍历。遍历方向不是格式问题,而是在控制同一件物品能不能重复参与转移。 + +## 状态定义对比 + +DP 题经常不是不会写转移,而是状态含义选错。下面几组状态看起来接近,但写法完全不同: + +| 题型 | 状态含义 | 常见转移关注点 | +| -------------- | ---------------------------------------- | ------------------------------ | +| 最长递增子序列 | `dp[i]` 表示以 `nums[i]` 结尾的 LIS 长度 | 必须选 `nums[i]`,向前找更小值 | +| 打家劫舍 | `dp[i]` 表示前 `i` 间房子的最大金额 | 第 `i` 间偷或不偷 | +| 最长公共子序列 | `dp[i][j]` 表示两个前缀的 LCS 长度 | 比较两个前缀最后一个字符 | +| 回文子串 | `dp[i][j]` 表示区间 `[i, j]` 是否回文 | 依赖内部区间 `[i + 1, j - 1]` | + +面试里可以主动说一句:这里的 `dp[i]` 是“以 i 结尾”,不是“前 i 个元素里的最优值”。这句话能避免很多子序列题写错。 + ## 过程示意和边界样例 以爬楼梯为例,`n = 5` 时的状态变化如下: @@ -188,6 +247,15 @@ for (int j = weights[i]; j <= capacity; j++) { - 求方案数和求最值的初始化不同。 - 子序列题经常需要区分“以 i 结尾”和“前 i 个元素内”。 +## 高频问题自测 + +- 为什么 DP 的第一步一定是定义状态? +- 记忆化搜索和递推的区别是什么?什么时候先写记忆化更稳? +- 0-1 背包为什么容量要倒序遍历? +- 完全背包为什么容量可以正序遍历? +- `dp[i]` 表示“以 i 结尾”和表示“前 i 个元素”时,转移有什么区别? +- 求最少次数、最大价值、方案数时,初始化分别要注意什么? + ## 推荐练习题 - [70. 爬楼梯](https://leetcode.cn/problems/climbing-stairs/) diff --git a/docs/cs-basics/algorithms/greedy.md b/docs/cs-basics/algorithms/greedy.md index 61daf254660..defac291001 100644 --- a/docs/cs-basics/algorithms/greedy.md +++ b/docs/cs-basics/algorithms/greedy.md @@ -74,6 +74,9 @@ boolean canJump(int[] nums) { ```java int eraseOverlapIntervals(int[][] intervals) { + if (intervals.length == 0) { + return 0; + } Arrays.sort(intervals, Comparator.comparingInt(a -> a[1])); int count = 1; int end = intervals[0][1]; @@ -115,6 +118,14 @@ int eraseOverlapIntervals(int[][] intervals) { - 跳跃游戏 II 里“步数增加”的时机和当前覆盖边界有关。 - 贪心策略要能解释,不要只说“每次选最优”。 +## 高频问题自测 + +- 贪心和动态规划怎么区分? +- 区间题为什么经常按右端点排序? +- 跳跃游戏里为什么只维护最远可达位置就够了? +- 贪心题怎样用交换或反证说明策略正确? +- 区间边界允许相等时,判断条件应该怎么写? + ## 推荐练习题 - [455. 分发饼干](https://leetcode.cn/problems/assign-cookies/) diff --git a/docs/cs-basics/algorithms/string-algorithm-problems.md b/docs/cs-basics/algorithms/string-algorithm-problems.md index 6b1612c3812..bafcf375c8e 100644 --- a/docs/cs-basics/algorithms/string-algorithm-problems.md +++ b/docs/cs-basics/algorithms/string-algorithm-problems.md @@ -487,6 +487,6 @@ public class Main { - Java 中 `String` 不可变,频繁拼接建议使用 `StringBuilder`。 - `char` 处理 Unicode 字符时可能不够,普通算法题多数只考 ASCII 或小写字母。 - 回文子串和回文子序列不是一类题,前者常用中心扩展,后者常用 DP。 -- KMP 面试中不一定要求从零推导,但要知道 `next` 数组用于避免重复匹配。 +- KMP 面试中通常不要求从零推导 `next` 数组的手工计算过程,但要理解它的作用是跳过已匹配前缀,避免重复匹配。 diff --git a/docs/cs-basics/algorithms/top-k.md b/docs/cs-basics/algorithms/top-k.md index 57d8413872c..cd88be2b519 100644 --- a/docs/cs-basics/algorithms/top-k.md +++ b/docs/cs-basics/algorithms/top-k.md @@ -118,16 +118,16 @@ int[] topKFrequent(int[] nums, int k) { ## 过程示意和边界样例 -以数组 `[3, 2, 1, 5, 6, 4]` 求第 2 大为例,维护大小为 2 的小顶堆: +以数组 `[3, 2, 1, 5, 6, 4]` 求第 2 大为例,维护大小为 2 的小顶堆。表中为了方便阅读,按值升序展示堆中的元素,不代表 Java `PriorityQueue` 的内部数组顺序。 -| 读入元素 | 堆内容 | 超过 K 后处理 | +| 读入元素 | 候选元素 | 超过 K 后处理 | | -------- | ----------- | --------------------- | | 3 | `[3]` | 不处理 | | 2 | `[2, 3]` | 不处理 | -| 1 | `[1, 3, 2]` | 弹出 1,保留 `[2, 3]` | +| 1 | `[1, 2, 3]` | 弹出 1,保留 `[2, 3]` | | 5 | `[2, 3, 5]` | 弹出 2,保留 `[3, 5]` | | 6 | `[3, 5, 6]` | 弹出 3,保留 `[5, 6]` | -| 4 | `[4, 6, 5]` | 弹出 4,保留 `[5, 6]` | +| 4 | `[4, 5, 6]` | 弹出 4,保留 `[5, 6]` | 最后堆顶是 `5`,也就是第 2 大。 @@ -151,6 +151,14 @@ PriorityQueue heap = new PriorityQueue<>((a, b) -> Integer.compare(b, a - 如果要输出有序结果,堆或快排分区后还需要额外排序。 - 数据流场景不能把所有数据每次重新排序。 +## 高频问题自测 + +- 找第 K 大为什么通常维护大小为 K 的小顶堆? +- 小顶堆和大顶堆分别适合哪些 Top K 场景? +- 堆方案和快排分区方案的时间复杂度、空间复杂度有什么区别? +- 前 K 高频元素为什么要先做频率统计? +- 数据流中位数为什么适合用两个堆维护? + ## 推荐练习题 - [215. 数组中的第 K 个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) diff --git a/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md b/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md index 26187819321..96dbe8b5941 100644 --- a/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md +++ b/docs/cs-basics/algorithms/two-pointers-and-sliding-window.md @@ -187,6 +187,77 @@ int maxSum(int[] nums, int k) { 如果窗口里还要维护最大值或最小值,普通变量不够用,通常要用单调队列。比如“滑动窗口最大值”中,队列里存可能成为最大值的下标,队首就是当前窗口最大值。 +## 面试手写路径 + +双指针和滑动窗口题,面试里最怕指针含义写到一半变了。建议按这个顺序写: + +1. 先判断题型:是两端收缩、快慢追赶、原地覆盖,还是连续窗口。 +2. 明确指针含义:`left`、`right`、`slow`、`fast`、`write` 分别指向哪里。 +3. 明确窗口状态:窗口内维护的是和、计数、最大值,还是匹配数量。 +4. 明确移动条件:什么时候右指针扩张,什么时候左指针收缩。 +5. 明确答案更新时机:合法后更新最长,满足条件时更新最短。 + +一句话区分最长和最短:**最长题通常先修复窗口再更新答案,最短题通常先记录答案再继续收缩。** + +## 代表题精讲:最小覆盖子串 + +[76. 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring/) 是滑动窗口里最能考细节的一题。题目要求在 `s` 中找到最短子串,使它覆盖 `t` 中所有字符和对应次数。 + +这题的关键不是会不会用窗口,而是能不能说清两个计数: + +- `need`:目标字符串 `t` 里每个字符需要多少个。 +- `window`:当前窗口里每个字符已经有多少个。 +- `valid`:有多少种字符已经满足所需次数。 + +当 `valid == need.size()` 时,说明当前窗口已经覆盖 `t`,这时要更新答案,并尝试收缩左边界。 + +```java +String minWindow(String s, String t) { + Map need = new HashMap<>(); + Map window = new HashMap<>(); + for (char c : t.toCharArray()) { + need.put(c, need.getOrDefault(c, 0) + 1); + } + + int left = 0; + int valid = 0; + int start = 0; + int minLen = Integer.MAX_VALUE; + + for (int right = 0; right < s.length(); right++) { + char in = s.charAt(right); + if (need.containsKey(in)) { + window.put(in, window.getOrDefault(in, 0) + 1); + if (window.get(in).equals(need.get(in))) { + valid++; + } + } + + while (valid == need.size()) { + if (right - left + 1 < minLen) { + start = left; + minLen = right - left + 1; + } + char out = s.charAt(left); + left++; + if (need.containsKey(out)) { + if (window.get(out).equals(need.get(out))) { + valid--; + } + window.put(out, window.get(out) - 1); + } + } + } + + return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen); +} +``` + +这里有两个容易写错的点: + +- `valid--` 要发生在减少 `window[out]` 之前,因为此时窗口还刚好满足条件。 +- 更新答案要放在 `while (valid == need.size())` 里面,因为只有当前窗口已经覆盖 `t`,才有资格参与最短答案比较。 + ## 过程示意和边界样例 以“无重复字符的最长子串”为例,字符串 `abba` 的窗口变化如下: @@ -225,6 +296,14 @@ if (count.get(c) > 1) { - 链表快慢指针要先判断 `fast` 和 `fast.next`。 - 三数之和这类题,排序后的去重要单独处理。 +## 高频问题自测 + +- 为什么双指针题通常是 `O(n)`,而不是两层循环的 `O(n^2)`? +- 三数之和为什么需要排序?去重分别发生在哪几个位置? +- 快慢指针找链表中点时,偶数长度返回前中点还是后中点? +- 滑动窗口什么时候用 `if` 收缩,什么时候必须用 `while` 收缩? +- 最长窗口和最短窗口的答案更新时机有什么区别? + ## 推荐练习题 - [26. 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/) diff --git a/docs/cs-basics/data-structure/hash-table.md b/docs/cs-basics/data-structure/hash-table.md index acee0c2e5b5..8e82f0607e0 100644 --- a/docs/cs-basics/data-structure/hash-table.md +++ b/docs/cs-basics/data-structure/hash-table.md @@ -91,6 +91,54 @@ int[] twoSum(int[] nums, int target) { 这段代码体现了哈希表最常见的用法:用空间换时间,把一次查找从 `O(n)` 降到平均 `O(1)`。 +## 代表题精讲:和为 K 的子数组 + +[560. 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k/) 很适合用来理解“前缀和 + 哈希表”。题目要求统计连续子数组和等于 `k` 的个数。 + +如果只枚举左右端点,复杂度是 `O(n^2)`。换个角度看,假设当前前缀和是 `sum`,想找到一个之前的前缀和 `prev`,使得: + +```text +sum - prev = k +``` + +也就是 `prev = sum - k`。所以只要用哈希表记录每个前缀和出现过几次,就能在遍历到当前位置时立刻知道有多少个子数组以当前位置结尾、和为 `k`。 + +```java +int subarraySum(int[] nums, int k) { + Map count = new HashMap<>(); + count.put(0, 1); + + int sum = 0; + int ans = 0; + for (int num : nums) { + sum += num; + ans += count.getOrDefault(sum - k, 0); + count.put(sum, count.getOrDefault(sum, 0) + 1); + } + return ans; +} +``` + +这里 `count.put(0, 1)` 很重要,它表示空前缀出现过一次。这样当从数组开头到当前位置的和刚好等于 `k` 时,也能被统计到。 + +另一个易错点是“先查再加”。如果先把当前 `sum` 加进哈希表,再查 `sum - k`,在 `k = 0` 时可能把当前前缀自己算进去,导致答案偏大。 + +比如 `nums = [1]`、`k = 0`。正确的“先查再加”不会找到和为 0 的非空子数组;如果先把当前前缀和 `1` 加进去,再查 `sum - k = 1`,就会把当前前缀和自己配对,错误地多算 1 次。 + +## Java HashMap 面试追问 + +哈希表文章只讲概念还不够,Java 后端面试里经常会继续追问 `HashMap`。可以按下面的层次准备: + +| 追问 | 回答重点 | +| ----------------------------- | --------------------------------------------------------------------- | +| 为什么容量通常是 2 的幂? | 方便用 `hash & (length - 1)` 定位,同时扩容后元素迁移更容易 | +| 为什么默认负载因子是 `0.75`? | 在空间利用率和冲突概率之间取折中,太小浪费空间,太大冲突增多 | +| 为什么 JDK 8 引入红黑树? | 极端冲突时链表查询会退化,树化后能把查询成本从链表长度级别降下来 | +| 为什么 `HashMap` 线程不安全? | 多线程并发修改会破坏结构一致性,读写也没有可见性和互斥保证 | +| 自定义 key 要注意什么? | `equals()` 和 `hashCode()` 要一致,参与计算的字段不要在放入后再被修改 | + +面试里不用把源码细节全部背下来,但要讲清楚一条主线:数组定位、冲突处理、扩容迁移、极端冲突优化,这四件事共同决定了 `HashMap` 的性能表现。 + ## 易错点 - 哈希表平均 `O(1)` 不等于任何情况下都是 `O(1)`。 @@ -99,6 +147,14 @@ int[] twoSum(int[] nums, int target) { - 统计频率时,数组计数比 `HashMap` 更适合字符集很小的场景。 - 哈希表能加速查找,但会带来额外空间。 +## 高频问题自测 + +- 哈希表为什么平均查询是 `O(1)`?什么情况下会退化? +- 拉链法和开放寻址法有什么区别? +- `HashMap` 为什么需要扩容?扩容成本怎么理解? +- 为什么自定义对象作为 key 时要同时重写 `equals()` 和 `hashCode()`? +- 前缀和 + 哈希表为什么要“先查再加”? + ## 推荐练习题 - [1. 两数之和](https://leetcode.cn/problems/two-sum/) diff --git a/docs/cs-basics/data-structure/heap.md b/docs/cs-basics/data-structure/heap.md index 7924006c4cd..eeee10518af 100644 --- a/docs/cs-basics/data-structure/heap.md +++ b/docs/cs-basics/data-structure/heap.md @@ -222,15 +222,11 @@ Java 里的 `PriorityQueue` 默认是小顶堆: ```java PriorityQueue minHeap = new PriorityQueue<>(); -PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> b - a); -``` - -需要注意的是,`b - a` 可能溢出,更稳妥的写法是: - -```java PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> Integer.compare(b, a)); ``` +不要写成 `b - a`,极端整数值下可能溢出,导致比较结果错误。 + Top K 问题常见选择: - 求第 K 大:维护大小为 K 的小顶堆。 diff --git a/docs/cs-basics/data-structure/lru-cache.md b/docs/cs-basics/data-structure/lru-cache.md index 2cc513a6307..9bc4e69686d 100644 --- a/docs/cs-basics/data-structure/lru-cache.md +++ b/docs/cs-basics/data-structure/lru-cache.md @@ -32,6 +32,18 @@ LRU 是 Least Recently Used 的缩写,意思是最近最少使用。当缓存 访问一个 key 后,需要把它移动到链表头部。插入新 key 时,也放到头部。容量超限时,删除尾部前一个节点。 +## 面试手写路径 + +LRU 的代码细节多,建议不要一上来就写完整类。面试时可以先把操作拆开: + +1. 先定义链表顺序:头部表示最近使用,尾部表示最久未使用。 +2. 再定义 `get`:查不到返回 `-1`,查到后移动到头部。 +3. 再定义 `put`:已有 key 更新值并移动到头部;新 key 插入头部。 +4. 最后处理淘汰:超过容量后删除尾部前一个节点,并从哈希表删除。 +5. 把链表操作封装成 `addToHead`、`remove`、`moveToHead`、`removeTail`。 + +这样写的好处是,`get` 和 `put` 都只组合几个基础链表操作,不会在主流程里反复改指针,出错概率低很多。 + ## 手写 LRU ```java @@ -111,6 +123,29 @@ class LRUCache { `get` 和 `put` 的时间复杂度都是 `O(1)`,空间复杂度是 `O(capacity)`。 +## 操作过程示意 + +假设容量为 2,按顺序执行: + +```text +put(1, 1) +put(2, 2) +get(1) +put(3, 3) +``` + +链表状态变化如下,左侧表示最近使用: + +| 操作 | 链表状态 | 说明 | +| ----------- | -------- | ------------------------ | +| 初始状态 | 空 | 虚拟头尾相连,缓存为空 | +| `put(1, 1)` | `1` | 新节点插入头部 | +| `put(2, 2)` | `2 -> 1` | `2` 是最近使用 | +| `get(1)` | `1 -> 2` | 访问 `1` 后移动到头部 | +| `put(3, 3)` | `3 -> 1` | 容量超限,淘汰尾部的 `2` | + +这张表能帮助检查两个点:访问已有节点要更新使用顺序;淘汰节点时,删除的是最久未使用的尾部节点,而不是刚插入的新节点。 + ## LinkedHashMap 实现 Java 的 `LinkedHashMap` 支持按访问顺序维护元素: @@ -142,6 +177,17 @@ class LRUCacheWithLinkedHashMap extends LinkedHashMap { 真实工程里还要考虑线程安全、过期时间、最大内存、统计指标和淘汰回调。面试手写 LRU 主要考数据结构组合,不需要把这些都写进代码。 +## 面试追问 + +| 追问 | 回答重点 | +| ------------------------------ | ---------------------------------------------------------------------- | +| 为什么不用单独的 `HashMap`? | `HashMap` 能查值,但不知道谁最久没被使用 | +| 为什么不用单独的链表? | 链表能维护顺序,但按 key 查找节点需要 `O(n)` | +| 为什么要用双向链表? | 删除任意节点时需要同时连接前驱和后继,单向链表无法 `O(1)` 找到前驱 | +| 为什么要用虚拟头尾节点? | 统一空链表、头节点、尾节点的插入删除逻辑,减少分支判断 | +| `LinkedHashMap` 怎么实现 LRU? | 构造时开启 `accessOrder`,重写 `removeEldestEntry` 控制容量 | +| 真实缓存还要考虑什么? | 线程安全、过期时间、最大内存、淘汰回调、命中率统计和缓存击穿等工程问题 | + ## 易错点 - 更新已有 key 时,也要移动到头部。 @@ -150,6 +196,14 @@ class LRUCacheWithLinkedHashMap extends LinkedHashMap { - 虚拟头尾节点可以减少空链表边界判断。 - `LinkedHashMap` 的 `accessOrder` 要设为 `true`。 +## 高频问题自测 + +- LRU 为什么需要哈希表和双向链表配合? +- `get` 操作为什么也要移动节点? +- 更新已有 key 时,为什么不能只改 value? +- 淘汰尾节点后,为什么还要从哈希表删除 key? +- `LinkedHashMap` 的插入顺序和访问顺序有什么区别? + ## 推荐练习题 - [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/) diff --git a/docs/cs-basics/operating-system/ipc.md b/docs/cs-basics/operating-system/ipc.md index 8f7dcd24c4d..7798bb5c56d 100644 --- a/docs/cs-basics/operating-system/ipc.md +++ b/docs/cs-basics/operating-system/ipc.md @@ -18,7 +18,7 @@ head: 所以 **IPC(Inter-Process Communication,进程间通信)** 绕不开操作系统。 -不要想的太复杂,我更习惯把 IPC 看成三件事:**怎么传数据、怎么同步控制流、怎么做命名和权限检查**。只记“管道、消息队列、共享内存”这些名字,很容易背完就忘。 +不要想得太复杂,我更习惯把 IPC 看成三件事:**怎么传数据、怎么同步控制流、怎么做命名和权限检查**。只记“管道、消息队列、共享内存”这些名字,很容易背完就忘。 ![进程地址空间隔离导致进程间通信需要借助内核提供的 IPC 机制](https://oss.javaguide.cn/github/javaguide/java/new-features/ipc-why-ipc.png) @@ -90,7 +90,7 @@ Socket 不只用于网络通信,也能做本机 IPC。 Unix Domain Socket 的接口接近网络 Socket,支持无亲缘关系进程通信;Linux 下既可以绑定文件系统路径,也可以使用 abstract namespace。它还可以借助 `sendmsg()` 的辅助数据和 `SCM_RIGHTS` 传文件描述符。对端身份这块,连接型 Unix Socket 常用 `SO_PEERCRED` 获取 pid、uid、gid;数据报场景也可以结合 `SO_PASSCRED` 和 `SCM_CREDENTIALS` 让凭据随消息传过来。 -如果问“管道和 Unix Domain Socket 怎么选”,小 G 一般会这么答:父子进程之间的简单字节流,用管道就够;要双向通信、请求响应、传 fd、服务端监听,Unix Domain Socket 更合适;要跨机器,换 TCP/UDP 或更上层的 RPC 框架。 +如果问“管道和 Unix Domain Socket 怎么选”,可以这样答:父子进程之间的简单字节流,用管道就够;要双向通信、请求响应、传 fd、服务端监听,Unix Domain Socket 更合适;要跨机器,换 TCP/UDP 或更上层的 RPC 框架。 ## Android Binder:把 IPC 做成系统服务调用 @@ -146,4 +146,4 @@ Mach 的代表设计是 port。port 可以理解成受内核保护的消息队 如果追问“Binder 为什么不适合传大对象”,可以补上 Android 官方文档里的 1 MB 事务缓冲限制,并说明这个缓冲由进程内进行中的事务共享。Binder 更适合传方法参数、返回值、对象引用和 fd;大块数据应该拆分、分页,或用共享内存传递。 -小 G 自己记 IPC 时不会把它背成一串名词,而是先问这几个问题:数据大不大?要不要保留消息边界?通信双方是不是都在本机?要不要双向请求响应?同步和权限谁来管?这些问题答完,方案基本也就出来了。 +记 IPC 时不要把它背成一串名词,可以先问这几个问题:数据大不大?要不要保留消息边界?通信双方是不是都在本机?要不要双向请求响应?同步和权限谁来管?这些问题答完,方案基本也就出来了。 diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md index 9875eb9762e..7850eef4a2e 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md @@ -228,7 +228,7 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 2. **读写锁(Read-Write Lock)**:允许多个线程同时读取共享资源,但只有一个线程可以对共享资源进行写操作。 3. **信号量(Semaphore)**:它允许同一时刻多个线程访问同一资源,但是需要控制同一时刻访问此资源的最大线程数量。 4. **屏障(Barrier)**:屏障是一种同步原语,用于等待多个线程到达某个点再一起继续执行。当一个线程到达屏障时,它会停止执行并等待其他线程到达屏障,直到所有线程都到达屏障后,它们才会一起继续执行。比如 Java 中的 `CyclicBarrier` 是这种机制。 -5. **条件变量(Condition Variable)/事件通知**:线程在条件不满足时等待,其他线程在条件变更后通知等待线程继续执行。它通常需要和互斥锁配合使用,避免“通知先发生、等待后发生”导致的丢通知问题。Java 中的 `Object.wait()/notify()`、`Condition.await()/signal()` 都属于这类思路。 +5. **条件变量(Condition Variable)/事件通知**:线程在条件不满足时等待,其他线程在条件变更后通知等待线程继续执行。它通常需要和互斥锁配合使用,避免“通知先发生、等待后发生”导致的丢通知问题。Java 中的 `Object.wait()/notify()`、`Condition.await()/signal()` 都属于这类思路;Windows 中的 Event 对象也可以看作事件通知类同步原语的一种实现。 ### PCB 是什么?包含哪些信息? diff --git a/docs/cs-basics/operating-system/process-and-thread.md b/docs/cs-basics/operating-system/process-and-thread.md index faff549720a..7afa6a3daa9 100644 --- a/docs/cs-basics/operating-system/process-and-thread.md +++ b/docs/cs-basics/operating-system/process-and-thread.md @@ -86,7 +86,7 @@ Linux 的实现有一点特别:它把进程和线程都看成 task,`task_str ## Linux 里 fork、exec、wait 分别做什么? -![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/fork-exec-wait-call-chain.png) +![fork、exec、wait 的调用链路](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/fork-exec-wait-call-chain.png) 在 Unix/Linux 编程里,进程创建常绕不开 `fork()`、`exec()`、`wait()` 这三个动作。 @@ -104,7 +104,7 @@ Shell 启动外部命令时,常见链路就是:Shell 调 `fork()` 创建子 ## 线程共享什么,又私有什么? -![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/thread-shared-and-private-content.png) +![线程共享资源和私有执行现场](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/thread-shared-and-private-content.png) 从操作系统角度看,同一进程内的线程共享进程的大部分资源,例如: @@ -166,7 +166,7 @@ Linux 的 POSIX 线程和 Windows 系统线程基本属于一对一模型。Linu ## 线程上下文切换和进程上下文切换有什么不同? -![](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/context-switch-cost-comparison.png) +![线程上下文切换和进程上下文切换成本对比](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/context-switch-cost-comparison.png) 上下文切换指 CPU 从一个执行实体切到另一个执行实体。操作系统需要保存当前实体的寄存器、程序计数器、栈指针等现场,再恢复下一个实体的现场。 diff --git a/docs/high-performance/README.md b/docs/high-performance/README.md index d82f2def492..2bbef8ebeb3 100644 --- a/docs/high-performance/README.md +++ b/docs/high-performance/README.md @@ -21,6 +21,8 @@ head: 如果你时间有限,建议先看 [高性能系统设计面试题总结](./high-performance-interview-questions.md),快速建立高频问题清单;如果你想系统补基础,可以按下面的阅读顺序推进。 +学习这部分内容时,不建议只记“加缓存、加 MQ、分库分表”这些方案名。高性能优化更像一条链路分析题:请求从用户侧进来,经过 CDN、负载均衡、应用服务、缓存、数据库、消息队列,每一段都有可能成为瓶颈。能讲清楚瓶颈在哪里、为什么选这个方案、会引入什么新问题,才算真的掌握。 + ## 适合谁看 - 正在系统学习高性能系统设计的后端开发者。 @@ -36,6 +38,17 @@ head: - Kafka、RocketMQ、RabbitMQ、Disruptor 的定位和选型差异是什么? - 面试中如何从“瓶颈定位 -> 方案选择 -> 取舍分析 -> 落地风险”回答高性能问题? +## 面试回答主线 + +回答高性能系统设计题时,可以按下面这条线展开: + +1. **先确认目标**:QPS、RT、P99、数据量、读写比例、一致性要求、成本约束。 +2. **再定位瓶颈**:入口带宽、应用线程池、慢 SQL、锁竞争、缓存命中率、MQ 积压、下游依赖。 +3. **然后选方案**:入口层用 CDN/负载均衡,应用层用缓存/限流/异步化,数据层用索引/读写分离/分库分表/冷热分离,削峰层用 MQ。 +4. **最后讲取舍**:方案带来的复杂度、一致性风险、运维成本、回滚方案和监控指标。 + +面试里最忌讳一上来就堆技术名词。比如“订单查询慢”不一定要分库分表,可能只是缺索引、深分页、历史数据太多或者热点商家查询集中。先把场景问清楚,再给方案,答案会稳很多。 + ## 建议阅读顺序 1. [高性能系统设计面试题总结](./high-performance-interview-questions.md):先建立缓存、数据库、消息队列、负载均衡等高频问题清单。 @@ -64,7 +77,7 @@ head: - [消息队列基础知识总结](./message-queue/message-queue.md):理解应用场景、消息模型、消息可靠性、顺序性、幂等和积压处理。 - [Kafka 常见问题总结](./message-queue/kafka-questions-01.md):掌握 Kafka 架构、高性能原理、消息可靠性、顺序性和 Rebalance。 - [RocketMQ 常见问题总结](./message-queue/rocketmq-questions.md):理解 RocketMQ 架构、消息类型、存储机制、可靠性和 5.x 新特性。 -- [RabbitMQ 常见问题总结](./message-queue/rabbitmq-questions.md):理解 AMQP、Exchange 类型、确认机制、死信队列、延迟队列和镜像队列。 +- [RabbitMQ 常见问题总结](./message-queue/rabbitmq-questions.md):理解 AMQP、Exchange 类型、确认机制、死信队列、延迟队列、Quorum Queue 和 Streams。 - [Disruptor 常见问题总结](./message-queue/disruptor-questions.md):理解 RingBuffer、Sequencer、WaitStrategy、无锁设计和缓存行填充。 ## 高频问题 diff --git a/docs/high-performance/cdn.md b/docs/high-performance/cdn.md index 29f0f5ed185..9e5ffdf81e5 100644 --- a/docs/high-performance/cdn.md +++ b/docs/high-performance/cdn.md @@ -54,6 +54,13 @@ head: 2. 如何找到最合适的 CDN 节点? 3. 如何防止静态资源被盗用? +在生产环境里,还要额外关注两个指标: + +- **缓存命中率**:命中率越高,用户越少回源,源站压力越小。 +- **回源耗时和回源错误率**:一旦回源链路变慢或源站错误增多,CDN 节点也会被拖慢。 + +所以,CDN 不是“接上就一定快”。如果缓存规则配置不合理、静态资源 URL 不稳定、频繁刷新缓存,反而可能让大量请求集中回源,源站压力比不用 CDN 时更大。 + ### 静态资源是如何被缓存到 CDN 节点中的? CDN 缓存静态资源的方式主要有两种:**预热**和**回源**。 @@ -79,6 +86,16 @@ CDN 缓存的完整生命周期如下图所示: - **命中率**:用户请求直接由 CDN 节点响应的比例,**越高越好**。 - **回源率**:用户请求需要回源站获取的比例,**越低越好**。 +常见的命中率优化手段: + +- **静态资源文件名带内容 hash**:例如 `app.8f3a1c.js`,内容变化后文件名变化,适合设置较长缓存时间。 +- **入口文件短缓存**:HTML、sitemap、robots 等入口文件不适合长期缓存,避免引用到已经删除的旧资源。 +- **热点资源提前预热**:大促、活动页、安装包发布前,将热点资源提前推送到 CDN 节点。 +- **减少无意义刷新**:全站刷新会让大量边缘节点同时回源,建议按 URL 或目录精确刷新。 +- **保留旧版本资源一段时间**:部署新版本后不要立即删除旧 hash 文件,避免旧 HTML 访问旧资源时出现 404。 + +如果命中率突然下降,可以优先排查缓存规则是否变更、资源 URL 是否带随机参数、是否发生了全量刷新、源站是否返回了禁止缓存的响应头。 + ### 如何找到最合适的 CDN 节点? **GSLB(Global Server Load Balance,全局负载均衡)** 是 CDN 的大脑,负责多个 CDN 节点之间的协调调度,最常用的实现方式是**基于 DNS 的 GSLB**。 @@ -191,6 +208,8 @@ http://cdn.example.com/video/123.mp4?wsSecret=79aead3bd7b5db4adeffb93a010298b5&w > **一句话总结**:动态加速 = 智能探测 + 动态选路 + 协议优化,让动态请求跑得又快又稳。 +动态加速也有边界:它优化的是网络传输链路,不会减少业务计算、数据库查询或第三方接口调用耗时。如果接口本身慢在 SQL、锁竞争或下游依赖,单靠动态加速解决不了根因。面试时可以这样回答:静态资源优先靠缓存命中,动态请求主要靠链路优化和源站自身性能治理,两者不是一类问题。 + ## CDN 如何优化 HTTPS 访问速度? HTTPS 虽然安全,但 TLS 握手和加解密过程会增加延迟。CDN 通过多种技术手段对 HTTPS 进行加速优化,在保障安全的同时提升访问速度。 @@ -209,7 +228,7 @@ CDN 服务商(如腾讯云、阿里云)通常提供**免费 SSL 证书**和* - **免运维**:用户无需手动更新证书,避免因证书过期导致的访问失败。 - **灵活配置**:支持在 CDN 控制台上传证书,或一键申请免费证书。 -- **多种加密模式**:可选择”**半程加密**”(用户到 CDN 为 HTTPS,CDN 到源站为 HTTP)或”**全程加密**”(两端均为 HTTPS)。 +- **多种加密模式**:可选择“**半程加密**”(用户到 CDN 为 HTTPS,CDN 到源站为 HTTP)或“**全程加密**”(两端均为 HTTPS)。 **HTTPS 加速的配置建议**: @@ -218,6 +237,8 @@ CDN 服务商(如腾讯云、阿里云)通常提供**免费 SSL 证书**和* 3. **安全增强**:如需更高安全等级,可开启 **HSTS**(强制浏览器使用 HTTPS 访问)。 4. **弱网优化**:开启 **QUIC** 协议支持,改善移动端弱网环境下的访问体验。 +生产环境还要注意证书和回源协议的一致性。如果用户到 CDN 是 HTTPS,但 CDN 到源站走 HTTP,链路中间仍然存在明文传输风险;如果源站强制 HTTPS,CDN 回源也要配置正确的证书校验和 SNI,否则容易出现回源失败。 + ## 总结 - **CDN 的核心价值**:将静态资源分发到多个不同的地方以实现**就近访问**,加快静态资源的访问速度,减轻源站服务器及带宽的负担。 diff --git a/docs/high-performance/data-cold-hot-separation.md b/docs/high-performance/data-cold-hot-separation.md index 878375aac6d..b9824100973 100644 --- a/docs/high-performance/data-cold-hot-separation.md +++ b/docs/high-performance/data-cold-hot-separation.md @@ -33,9 +33,11 @@ head: - 若数据价值与时间无关(如文章、商品、用户画像),需结合**访问频率**进行判定。 - 实际项目中,可将两者结合使用:以时间维度为主、访问频率为辅,覆盖更多业务场景。 +冷热判定规则不要只由技术团队拍脑袋决定。订单、账单、审计、客服、运营查询都会影响“冷数据还能不能查、多久能查出来、是否必须查全量”。落地前最好把核心查询路径列出来,再决定冷数据迁移时间点。 + ### 冷热分离的多级分层策略 -实际落地时,"冷"与"热"往往不是非此即彼的二分法,而是**渐进式多级分层**: +实际落地时,“冷”与“热”往往不是非此即彼的二分法,而是**渐进式多级分层**: | 层级 | 数据特性 | 判定规则示例 | 存储策略 | | ------------ | -------------------- | --------------------------- | ---------------------- | @@ -48,7 +50,7 @@ head: ### 冷数据被访问后如何处理? -如果冷数据突然被访问(如用户查询 3 年前的订单),是否需要"热升级"? +如果冷数据突然被访问(如用户查询 3 年前的订单),是否需要“热升级”? | 策略 | 适用场景 | 优点 | 缺点 | | ------------ | ---------------------- | -------------------- | ---------------------------- | @@ -56,7 +58,7 @@ head: | **缓存层** | 中等频率查询 | 加速查询、不改变存储 | 需要额外缓存组件 | | **异步回迁** | 高频查询、需要持续访问 | 彻底解决性能问题 | 实现复杂、可能产生一致性问题 | -**推荐做法**:绝大多数场景采用"**不回迁 + 缓存层**"的组合方案。冷数据查询时,先查缓存,命中则直接返回;未命中则查冷库并将结果写入缓存(针对偶发查询,设置 5~15 分钟的短暂 TTL 即可)。 +**推荐做法**:绝大多数场景采用“**不回迁 + 缓存层**”的组合方案。冷数据查询时,先查缓存,命中则直接返回;未命中则查冷库并将结果写入缓存(针对偶发查询,设置 5~15 分钟的短暂 TTL 即可)。 **⚠️注意**:为防止恶意攻击者利用随机参数频繁查询不存在的数据导致冷库被击穿,可以在缓存层前置**布隆过滤器(Bloom Filter)**或在缓存中设置**空值占位符**,避免恶意请求穿透到冷库。详细介绍参考 [Redis 常见面试题总结(下)](https://javaguide.cn/database/redis/redis-questions-02.html)(Redis 事务、性能优化、生产问题、集群、使用规范等)。 @@ -155,7 +157,7 @@ hotDb.execute("UPDATE orders SET migrate_status = 2 WHERE id = ? AND migrate_sta hotDb.execute("DELETE FROM orders WHERE id = ? AND migrate_status = 2", id); ``` -> **注意**:独立冷库场景下,标准 MySQL 无法直接执行跨库 `INSERT ... SELECT`,必须在应用层拆分为"读取热库 → 写入冷库"两步。 +> **注意**:独立冷库场景下,标准 MySQL 无法直接执行跨库 `INSERT ... SELECT`,必须在应用层拆分为“读取热库 → 写入冷库”两步。 **方案优势**: @@ -221,7 +223,7 @@ ALTER TABLE orders PARTITION p2022 PLACEMENT POLICY = cold_data; 这种方案的优势在于:**业务无需感知冷热分离逻辑**,数据路由由 TiDB 自动完成,大幅降低了应用层的复杂度。 -> **完整实践**:`Placement Rules` 指定了数据存放的介质类型,但数据如何从"热分区"流转到"冷分区"仍需结合**分区表(Range Partitioning)**。按时间跨度创建分区,为历史分区绑定 HDD 放置策略,为当前活跃分区绑定 SSD 放置策略。随着时间推移,只需维护分区的创建与销毁,底层数据即可在不同介质间自然流转。 +> **完整实践**:`Placement Rules` 指定了数据存放的介质类型,但数据如何从“热分区”流转到“冷分区”仍需结合**分区表(Range Partitioning)**。按时间跨度创建分区,为历史分区绑定 HDD 放置策略,为当前活跃分区绑定 SSD 放置策略。随着时间推移,只需维护分区的创建与销毁,底层数据即可在不同介质间自然流转。 ## 冷数据如何查询? @@ -245,7 +247,7 @@ ALTER TABLE orders PARTITION p2022 PLACEMENT POLICY = cold_data; **跨冷热查询的处理**: -若查询范围同时涉及冷热数据(如"查询近 2 年的订单"),有两种处理方式: +若查询范围同时涉及冷热数据(如“查询近 2 年的订单”),有两种处理方式: 1. **拆分查询**:分别查询热库和冷库,应用层合并结果。 2. **限制范围**:提示用户缩小查询范围,避免跨库查询。 @@ -268,6 +270,19 @@ ALTER TABLE orders PARTITION p2022 PLACEMENT POLICY = cold_data; > ⚠️ **风险提示**:引入 Proxy 层后,所有跨冷热库的聚合计算(如全局排序、`GROUP BY` 归并分页)都会压在 Proxy 节点的内存与 CPU 上。需严格限制此类操作的最大返回行数,否则极易导致 Proxy 节点 **OOM(内存溢出)**。 +## 监控与回滚 + +冷热分离上线后,至少要关注这些指标: + +- **迁移进度**:待迁移数量、迁移成功数、迁移失败数、重试次数。 +- **迁移延迟**:数据从热库满足冷却条件到真正迁移完成的时间。 +- **一致性校验**:冷热库记录数、关键字段摘要、金额类字段汇总。 +- **查询命中分布**:热库查询、冷库查询、跨冷热查询的比例。 +- **冷库压力**:冷库 QPS、RT、慢查询、连接数、存储增长速度。 +- **异常回流**:冷数据突然高频访问时,缓存命中率和冷库压力是否异常。 + +回滚策略也要提前设计。比较稳妥的做法是迁移初期只复制不删除,等查询路由和一致性校验稳定后,再延迟清理热库数据。这样即使冷库查询链路出问题,也可以临时切回热库。 + ## 冷热分离 vs 数据归档 vs 分区表 这三个概念容易混淆,需要区分清楚: diff --git a/docs/high-performance/deep-pagination-optimization.md b/docs/high-performance/deep-pagination-optimization.md index 57d238095f2..6b7089b405b 100644 --- a/docs/high-performance/deep-pagination-optimization.md +++ b/docs/high-performance/deep-pagination-optimization.md @@ -49,8 +49,8 @@ SELECT * FROM t_order WHERE id > 100000 ORDER BY id LIMIT 10 1. **不支持跳页**:无法直接跳转到第 N 页,只能逐页向后(或向前)翻页。 2. **排序字段受限**:如果查询需要按照其他字段(如创建时间)排序而非 ID 排序,需使用联合游标 `(sort_field, id)` 保证唯一性和顺序。 3. **并发场景**:当分页查询期间有新数据插入或删除时,可能出现: - - **数据遗漏**:查询第二页时,有新数据插入到第一页范围内,导致该数据被"挤"到第二页,但第二页查询已基于旧的最后 ID 跳过它。 - - **数据重复**:查询第二页时,第一页末尾有数据被删除,原第二页的第一条数据"升"到第一页末尾,导致第二页查询再次返回它。 + - **数据遗漏**:查询第二页时,有新数据插入到第一页范围内,导致该数据被“挤”到第二页,但第二页查询已基于旧的最后 ID 跳过它。 + - **数据重复**:查询第二页时,第一页末尾有数据被删除,原第二页的第一条数据“升”到第一页末尾,导致第二页查询再次返回它。 ### 子查询 @@ -137,11 +137,24 @@ LIMIT 1000000, 10; ## 生产落地建议 +分页优化首先要和产品形态对齐。后台管理系统常常需要跳页和精确总数,信息流、评论列表、订单列表通常只需要“上一页/下一页”或“加载更多”。如果业务不需要跳到第 10000 页,就不要为了兼容传统分页牺牲查询性能。 + +常见选择如下: + +| 业务形态 | 推荐方案 | 原因 | +| ---------------------- | ---------------- | -------------------------------- | +| 信息流、评论、消息列表 | 游标分页 | 只需要向前/向后翻页,性能稳定 | +| 后台列表、运营查询 | 延迟关联或子查询 | 兼容传统页码,但要限制最大页数 | +| 固定字段榜单 | 覆盖索引 | 查询字段少,可减少回表 | +| 复杂搜索、多条件排序 | 搜索引擎或 OLAP | MySQL 不适合承担大跨度检索和排序 | + ### 监控与告警 - **慢查询监控**:监控慢查询日志中 `LIMIT` 偏移量过大的 SQL,及时发现问题。 - **阈值告警**:设置 `long_query_time` 阈值捕获深度分页查询。 - **执行计划检查**:使用 `EXPLAIN` 定期检查关键分页 SQL 的执行计划,确保优化器按预期使用索引。 +- **接口限流**:对深页码请求单独限流,避免爬虫或异常请求拖垮数据库。 +- **最大页数限制**:例如只允许查询前 100 页,更深的数据引导用户缩小搜索条件。 ### 常见误区 @@ -167,7 +180,7 @@ LIMIT 1000000, 10; **方案选择建议**: - **优先使用延迟关联**:对于大多数需要支持传统 `LIMIT offset, size` 翻页逻辑的场景,延迟关联是性能和可维护性较好的选择。 -- **考虑范围查询(游标分页)**:如果业务允许使用"下一页"式的游标翻页(如社交媒体 feed 流、无限滚动),范围查询性能最佳且稳定。 +- **考虑范围查询(游标分页)**:如果业务允许使用“下一页”式的游标翻页(如社交媒体 feed 流、无限滚动),范围查询性能最佳且稳定。 - **覆盖索引作为补充**:当查询字段固定且数量不多时,可配合其他方案建立覆盖索引进一步优化。 **注意事项**: diff --git a/docs/high-performance/high-performance-interview-questions.md b/docs/high-performance/high-performance-interview-questions.md index d7191362c00..5ec73abe5d6 100644 --- a/docs/high-performance/high-performance-interview-questions.md +++ b/docs/high-performance/high-performance-interview-questions.md @@ -27,6 +27,16 @@ head: 面试回答时,不要一上来就说“加缓存”。更好的方式是先确认场景和指标:QPS 多大、RT 和 P99 要求是多少、读写比例如何、数据量级多大、瓶颈出现在 CPU、I/O、数据库还是外部依赖。只有先判断瓶颈在哪里,后面的方案才不会像硬套模板。 +一个比较稳的回答模板是: + +1. **明确目标**:先问清楚接口类型、读写比例、峰值流量、延迟要求、数据规模和一致性要求。 +2. **定位瓶颈**:结合监控、链路追踪、慢 SQL、线程池、连接池、MQ 积压等指标判断问题出在哪里。 +3. **分层优化**:入口层、应用层、数据层、消息层分别处理,不把所有问题都推给数据库或缓存。 +4. **说明取舍**:讲清楚方案会引入什么新问题,比如缓存一致性、主从延迟、分片复杂度、重复消费。 +5. **验证效果**:通过压测、灰度、监控、告警和回滚方案确认优化是否真的有效。 + +这个模板不需要在每道题里完整背出来,但它能帮你避免“只说方案、不说场景”的问题。 + ## 第一阶段:CDN 和负载均衡 入口层优化解决的是“流量怎么更快、更稳地进来”。这一层通常不直接改业务代码,但会明显影响用户访问延迟、源站压力和系统可用性。 @@ -126,3 +136,11 @@ head: 4. 最后看 [CDN 工作原理详解](https://javaguide.cn/high-performance/cdn.html) 和 [负载均衡原理及算法详解](https://javaguide.cn/high-performance/load-balancing.html),把入口层链路补齐,能够从用户访问一路讲到后端服务承接流量。 如果你能把这些内容串成一条完整链路:**入口流量如何进来、应用如何削峰、数据库如何减压、消息系统如何兜底、系统效果如何验证**,高性能系统设计题就会好答很多。 + +最后再做一遍自查: + +- 能不能解释“为什么这个方案能提升性能”,而不是只说它的定义? +- 能不能说出适用场景和不适用场景? +- 能不能讲清楚引入方案后的新问题,比如一致性、可用性、成本和运维复杂度? +- 能不能给出监控指标,比如 QPS、RT、P99、缓存命中率、慢 SQL 数量、MQ 堆积量? +- 能不能把单点优化放回完整系统链路里,而不是孤立地背八股? diff --git a/docs/high-performance/high-performance-system-interview-questions.md b/docs/high-performance/high-performance-system-interview-questions.md index cb90b0188df..120e174291a 100644 --- a/docs/high-performance/high-performance-system-interview-questions.md +++ b/docs/high-performance/high-performance-system-interview-questions.md @@ -12,7 +12,11 @@ head: content: 高性能面试题,高性能系统设计,CDN面试题,负载均衡面试题,读写分离面试题,分库分表面试题,SQL优化面试题,深度分页面试题,消息队列面试题,Kafka面试题,RocketMQ面试题,RabbitMQ面试题 --- -这部分内容摘自 [JavaGuide](https://javaguide.cn/) 下面几篇文章的重点: +这部分内容摘自 [JavaGuide](https://javaguide.cn/) 高性能专题的重点文章,适合在系统复习之后用来查漏补缺。 + +高性能面试题通常不会只考一个概念。面试官更关心你能不能把问题放回真实链路里:请求从入口进来,经过负载均衡、应用服务、缓存、数据库、消息队列之后,哪个环节慢了,哪个环节扛不住,哪个方案能解决,方案又会带来什么新问题。 + +建议按“是什么 -> 解决什么问题 -> 核心原理 -> 适用边界 -> 生产落地”这 5 个角度准备答案。这样既能回答基础概念,也能应对继续追问。 高性能基础: @@ -34,6 +38,18 @@ head: - [RabbitMQ 常见面试题总结](https://javaguide.cn/high-performance/message-queue/rabbitmq-questions.html) - [Disruptor 常见面试题总结](https://javaguide.cn/high-performance/message-queue/disruptor-questions.html) +## 回答高性能问题的通用思路 + +遇到高性能系统设计题,可以先按下面几个问题拆开: + +1. **目标是什么**:优化平均响应时间、P99、吞吐量、数据库压力,还是用户感知速度? +2. **瓶颈在哪里**:入口带宽、应用线程池、缓存命中率、慢 SQL、锁竞争、下游依赖、MQ 积压? +3. **方案放在哪一层**:CDN/负载均衡解决入口问题,缓存/限流/异步化解决应用压力,索引/读写分离/分库分表解决数据层压力,MQ 解决削峰和异步协作。 +4. **代价是什么**:缓存一致性、主从延迟、分片路由、重复消费、顺序性下降、运维复杂度都会跟着来。 +5. **怎么验证**:压测、灰度、监控、告警、回滚和容量预估必须一起讲。 + +如果题目没有给具体指标,不要急着报方案。先追问或主动假设业务量级,再说明在这个假设下怎么做。 + ## 高性能基础 ### ⭐️什么是 CDN?为什么 CDN 能提升访问速度? diff --git a/docs/high-performance/load-balancing.md b/docs/high-performance/load-balancing.md index a7724eff5e5..ca2f259f98b 100644 --- a/docs/high-performance/load-balancing.md +++ b/docs/high-performance/load-balancing.md @@ -18,6 +18,8 @@ head: 负载均衡是一种比较常用且实施起来较为简单的提高系统并发能力和可靠性的手段,不论是单体架构的系统还是微服务架构的系统几乎都会用到。 +不过,负载均衡解决的是“把请求分散到多个节点”的问题,不会自动解决慢 SQL、线程池耗尽、缓存击穿、下游接口变慢这些业务瓶颈。如果所有后端节点都慢,负载均衡只能把慢请求分得更均匀,不能让系统凭空变快。 + ## 负载均衡分为哪几种? 负载均衡可以简单分为 **服务端负载均衡** 和 **客户端负载均衡** 这两种。 @@ -61,6 +63,18 @@ head: 简单来说,**四层负载均衡性能很强,七层负载均衡功能更强!** 不过,对于绝大部分业务场景来说,四层负载均衡和七层负载均衡的性能差异基本可以忽略不计的。 +实际选型可以这样判断: + +| 对比维度 | 四层负载均衡 | 七层负载均衡 | +| -------- | -------------------------------- | ---------------------------------- | +| 工作层次 | TCP/UDP | HTTP/HTTPS | +| 转发依据 | IP、端口 | 域名、路径、Header、Cookie | +| 性能开销 | 更低 | 更高 | +| 灵活性 | 较弱 | 更强 | +| 典型场景 | 大流量入口、数据库代理、TCP 服务 | 网关、反向代理、灰度发布、路径路由 | + +如果只是转发 TCP 流量,四层更直接;如果需要根据 URL、Header、Cookie 做路由,或者做压缩、缓存、TLS 终止,七层更合适。 + 下面这段话摘自 Nginx 官网的 [What Is Layer 4 Load Balancing?](https://www.nginx.com/resources/glossary/layer-4-load-balancing/) 这篇文章。 > Layer 4 load balancing was a popular architectural approach to traffic handling when commodity hardware was not as powerful as it is now, and the interaction between clients and application servers was much less complex. It requires less computation than more sophisticated load balancing methods (such as Layer 7), but CPU and memory are now sufficiently fast and cheap that the performance advantage for Layer 4 load balancing has become negligible or irrelevant in most situations. @@ -179,6 +193,18 @@ Nginx 就是最常用的反向代理服务器,它可以将接收到的客户 ![](https://oss.javaguide.cn/github/javaguide/nginx-load-balance.png) +### 健康检查和摘流量 + +负载均衡真正上线后,健康检查比算法本身更重要。算法决定“正常情况下怎么分流”,健康检查决定“异常节点还能不能继续接流量”。 + +常见健康检查方式: + +- **TCP 检查**:端口能连通就认为节点可用,适合四层负载均衡,但无法判断业务是否真的正常。 +- **HTTP 检查**:定期访问 `/health`、`/actuator/health` 等接口,根据状态码和响应内容判断节点是否可用。 +- **业务探活**:检查数据库、缓存、依赖服务等关键组件状态,适合核心链路,但探活逻辑不能太重。 + +生产环境建议给后端节点设置预热和摘流量机制。新节点刚启动时,JIT、连接池、缓存都还没热起来,直接打满流量容易出现抖动;下线节点时,也要先停止接收新请求,再等待存量请求处理完。 + ## 客户端负载均衡通常是怎么做的? 我们上面也说了,客户端负载均衡可以使用现成的负载均衡组件来实现。 @@ -256,6 +282,14 @@ Spring Cloud 2020.0.0 版本移除了 Netflix 除 Eureka 外的所有组件。Sp **Spring Cloud Alibaba** 是一个不错的选择,尤其是对于国内的公司和个人开发者来说。 +## 生产落地建议 + +- **先看指标再调算法**:重点关注各节点 QPS、RT、P99、错误率、连接数和 CPU/内存,而不是只看请求数量是否平均。 +- **慢节点要及时隔离**:某个节点变慢时,最快响应时间、最少活跃等策略可能有帮助,但根因仍然要靠健康检查、熔断和摘流量处理。 +- **避免会话粘滞依赖**:如果必须使用 Cookie 或 IP Hash 固定会话,扩缩容和节点故障时要评估用户影响。更推荐把会话放到 Redis 等共享存储中。 +- **灰度发布要可回滚**:七层负载均衡常用于按 Header、Cookie、用户 ID 做灰度,灰度规则必须能快速关闭。 +- **跨地域流量要就近调度**:全国或全球业务通常需要结合 DNS/GSLB,把用户调度到更近的机房或可用区。 + ## 参考 - 干货 | eBay 的 4 层软件负载均衡实现: diff --git a/docs/high-performance/message-queue/README.md b/docs/high-performance/message-queue/README.md index 8a4531ae170..960f557040b 100644 --- a/docs/high-performance/message-queue/README.md +++ b/docs/high-performance/message-queue/README.md @@ -17,6 +17,8 @@ head: 消息队列是高性能和高可用系统里都非常常见的中间件,主要用于异步处理、应用解耦、削峰填谷和流量缓冲。学习消息队列时,不能只背 Kafka、RocketMQ、RabbitMQ 的特性,更要理解消息可靠性、顺序性、幂等性、积压处理和技术选型。 +如果你准备面试,可以把 MQ 问题拆成一条链路:生产者怎么保证发出去,Broker 怎么保证存得住,消费者怎么保证处理成功,失败后怎么重试和补偿。这样比单独背“消息不丢失、重复消费、顺序消费”更容易讲清楚。 + ## 适合谁看 - 想系统学习消息队列的后端开发者。 @@ -60,6 +62,17 @@ head: - RabbitMQ 的 Exchange 有哪些类型?各自适合什么场景? - Kafka、RocketMQ、RabbitMQ 应该如何选型? +## 选型速查 + +| 场景 | 常见选择 | 重点关注 | +| -------------------- | ------------- | ---------------------------------- | +| 日志、埋点、流式处理 | Kafka、Pulsar | 吞吐、分区扩展、生态 | +| 订单、交易、业务事件 | RocketMQ | 事务消息、延时消息、顺序消息 | +| 灵活路由、轻量接入 | RabbitMQ | Exchange、确认机制、队列类型 | +| 进程内低延迟事件处理 | Disruptor | RingBuffer、WaitStrategy、无锁设计 | + +选型时不要只比较吞吐量。团队运维经验、已有技术栈、消息语义、延迟要求、消息保留时间、是否需要重放,都会影响最终选择。 + ## 相关专题 - [高性能系统知识体系](../) diff --git a/docs/high-performance/message-queue/disruptor-questions.md b/docs/high-performance/message-queue/disruptor-questions.md index efd7f24be0b..4a3f0150d0a 100644 --- a/docs/high-performance/message-queue/disruptor-questions.md +++ b/docs/high-performance/message-queue/disruptor-questions.md @@ -73,6 +73,18 @@ Disruptor 真的很快,关于它为什么这么快这个问题,会在后文 - **Kafka**:分布式消息队列,一般用在系统或者服务之间的消息传递,还可以被用作流式处理平台。 - **Disruptor**:内存级别的消息队列,一般用在系统内部中线程间的消息传递。 +它们解决的问题不是一个层级: + +| 对比维度 | Kafka/RocketMQ/RabbitMQ | Disruptor | +| ------------ | ---------------------------- | -------------------------------- | +| 使用范围 | 跨进程、跨机器、跨服务 | 单 JVM 进程内 | +| 是否持久化 | 通常支持 | 不负责持久化 | +| 是否支持重放 | 通常支持 | 不负责历史重放 | +| 重点能力 | 可靠投递、削峰、解耦、消费组 | 低延迟、少锁竞争、高吞吐事件处理 | +| 典型场景 | 订单事件、日志采集、异步解耦 | 异步日志、撮合、进程内流水线 | + +所以,Disruptor 不能替代 Kafka、RocketMQ 这类分布式消息队列。它更适合放在服务内部,用来把一段高频事件处理链路做得更快。 + ## 哪些组件用到了 Disruptor? 用到 Disruptor 的开源项目还是挺多的,这里简单举几个例子: @@ -117,6 +129,14 @@ Disruptor 真的很快,关于它为什么这么快这个问题,会在后文 - `YieldingWaitStrategy`:二段式策略,第一阶段自旋,第二阶段执行 Thread.yield 交出 CPU; - `PhasedBackoffWaitStrategy`:四段式策略,第一阶段自旋指定次数,第二阶段自旋指定时间,第三阶段执行 `Thread.yield` 交出 CPU,第四阶段调用成员变量的`waitFor`方法,该成员变量可以被设置为`BlockingWaitStrategy`、`LiteBlockingWaitStrategy`、`SleepingWaitStrategy`三个中的一个。 +等待策略本质是在延迟和 CPU 消耗之间做取舍: + +- 延迟极敏感、机器资源独占时,可以评估 `BusySpinWaitStrategy` 或 `YieldingWaitStrategy`。 +- 普通业务服务更推荐从 `BlockingWaitStrategy` 开始,稳定性和资源占用更可控。 +- 如果既希望降低空转,又希望在短时间内快速响应,可以评估 `SleepingWaitStrategy` 或 `PhasedBackoffWaitStrategy`。 + +不要在共享业务机器上盲目使用忙等策略,否则很容易把 CPU 打满,影响同机其他服务。 + ## Disruptor 为什么这么快? - **RingBuffer(环形数组)** : Disruptor 内部的 RingBuffer 是通过数组实现的。由于这个数组中的所有元素在初始化时一次性全部创建,因此这些元素的内存地址一般来说是连续的。这样做的好处是,当生产者不断往 RingBuffer 中插入新的事件对象时,这些事件对象的内存地址就能够保持连续,从而利用 CPU 缓存的局部性原理,将相邻的事件对象一起加载到缓存中,提高程序的性能。这类似于 MySQL 的预读机制,将连续的几个页预读到内存里。除此之外,RingBuffer 基于数组还支持批量操作(一次处理多个元素)、还可以避免频繁的内存分配和垃圾回收(RingBuffer 是一个固定大小的数组,当向数组中添加新元素时,如果数组已满,则新元素将覆盖掉最旧的元素)。 @@ -125,6 +145,8 @@ Disruptor 真的很快,关于它为什么这么快这个问题,会在后文 综上所述,Disruptor 之所以能够如此快,是基于一系列优化策略的综合作用,既充分利用了现代 CPU 缓存结构的特点,又避免了常见的并发问题和性能瓶颈。 +不过,Disruptor 的性能优势也有前提:事件处理逻辑不能太重,消费者不能长时间阻塞,RingBuffer 容量要结合峰值流量评估。如果消费者里调用慢接口、慢 SQL 或长时间加锁,再快的队列也会被下游处理能力拖住。 + 关于 Disruptor 高性能队列原理的详细介绍,可以查看这篇文章:[Disruptor 高性能队列原理浅析](https://qin.news/disruptor/) (参考了美团技术团队的[高性能队列——Disruptor](https://tech.meituan.com/2016/11/18/disruptor.html)这篇文章)。 🌈 这里额外补充一点:**数组中对象元素地址连续为什么可以提高性能?** @@ -139,7 +161,7 @@ CPU 缓存是通过将最近使用的数据存储在高速缓存中来实现更 ## 参考 -- Disruptor 高性能之道-等待策略:< 高性能之道-等待策略/> +- Disruptor 高性能之道-等待策略: - 《Java 并发编程实战》- 40 | 案例分析(三):高性能队列 Disruptor: diff --git a/docs/high-performance/message-queue/kafka-questions-01.md b/docs/high-performance/message-queue/kafka-questions-01.md index b8034f7c875..205e385739c 100644 --- a/docs/high-performance/message-queue/kafka-questions-01.md +++ b/docs/high-performance/message-queue/kafka-questions-01.md @@ -100,30 +100,30 @@ Kafka 将生产者发布的消息发送到 **Topic(主题)** 中,需要这 1. Kafka 通过给特定 Topic 指定多个 Partition, 而各个 Partition 可以分布在不同的 Broker 上, 这样便能提供比较好的并发能力(负载均衡)。 2. Partition 可以指定对应的 Replica 数, 这也极大地提高了消息存储的安全性, 提高了容灾能力,不过也相应的增加了所需要的存储空间。 -## Zookeeper 和 Kafka +## ZooKeeper 和 Kafka -### Zookeeper 在 Kafka 中的作用是什么? +### ZooKeeper 在 Kafka 中的作用是什么? > 要想搞懂 zookeeper 在 Kafka 中的作用 一定要自己搭建一个 Kafka 环境然后自己进 zookeeper 去看一下有哪些文件夹和 Kafka 有关,每个节点又保存了什么信息。 一定不要光看不实践,这样学来的也终会忘记!这部分内容参考和借鉴了这篇文章: 。 -下图就是我的本地 Zookeeper ,它成功和我本地的 Kafka 关联上(以下文件夹结构借助 idea 插件 Zookeeper tool 实现)。 +下图就是我的本地 ZooKeeper,它成功和我本地的 Kafka 关联上(以下文件夹结构借助 idea 插件 ZooKeeper tool 实现)。 ZooKeeper 主要为 Kafka 提供元数据的管理的功能。 -从图中我们可以看出,Zookeeper 主要为 Kafka 做了下面这些事情: +从图中我们可以看出,ZooKeeper 主要为 Kafka 做了下面这些事情: -1. **Broker 注册**:在 Zookeeper 上会有一个专门**用来进行 Broker 服务器列表记录**的节点。每个 Broker 在启动时,都会到 Zookeeper 上进行注册,即到 `/brokers/ids` 下创建属于自己的节点。每个 Broker 就会将自己的 IP 地址和端口等信息记录到该节点中去 -2. **Topic 注册**:在 Kafka 中,同一个**Topic 的消息会被分成多个分区**并将其分布在多个 Broker 上,**这些分区信息及与 Broker 的对应关系**也都是由 Zookeeper 在维护。比如我创建了一个名字为 my-topic 的主题并且它有两个分区,对应到 zookeeper 中会创建这些文件夹:`/brokers/topics/my-topic/Partitions/0`、`/brokers/topics/my-topic/Partitions/1` -3. **负载均衡**:上面也说过了 Kafka 通过给特定 Topic 指定多个 Partition, 而各个 Partition 可以分布在不同的 Broker 上, 这样便能提供比较好的并发能力。 对于同一个 Topic 的不同 Partition,Kafka 会尽力将这些 Partition 分布到不同的 Broker 服务器上。当生产者产生消息后也会尽量投递到不同 Broker 的 Partition 里面。当 Consumer 消费的时候,Zookeeper 可以根据当前的 Partition 数量以及 Consumer 数量来实现动态负载均衡。 +1. **Broker 注册**:在 ZooKeeper 上会有一个专门**用来进行 Broker 服务器列表记录**的节点。每个 Broker 在启动时,都会到 ZooKeeper 上进行注册,即到 `/brokers/ids` 下创建属于自己的节点。每个 Broker 就会将自己的 IP 地址和端口等信息记录到该节点中去 +2. **Topic 注册**:在 Kafka 中,同一个**Topic 的消息会被分成多个分区**并将其分布在多个 Broker 上,**这些分区信息及与 Broker 的对应关系**也都是由 ZooKeeper 在维护。比如我创建了一个名字为 my-topic 的主题并且它有两个分区,对应到 ZooKeeper 中会创建这些文件夹:`/brokers/topics/my-topic/Partitions/0`、`/brokers/topics/my-topic/Partitions/1` +3. **负载均衡**:上面也说过了 Kafka 通过给特定 Topic 指定多个 Partition, 而各个 Partition 可以分布在不同的 Broker 上, 这样便能提供比较好的并发能力。 对于同一个 Topic 的不同 Partition,Kafka 会尽力将这些 Partition 分布到不同的 Broker 服务器上。当生产者产生消息后也会尽量投递到不同 Broker 的 Partition 里面。当 Consumer 消费的时候,ZooKeeper 可以根据当前的 Partition 数量以及 Consumer 数量来实现动态负载均衡。 4. …… -### 使用 Kafka 能否不引入 Zookeeper? +### 使用 Kafka 能否不引入 ZooKeeper? -在 Kafka 2.8 之前,Kafka 最被大家诟病的就是其重度依赖于 Zookeeper。在 Kafka 2.8 之后,引入了基于 Raft 协议的 KRaft 模式,不再依赖 Zookeeper,大大简化了 Kafka 的架构,让你可以以一种轻量级的方式来使用 Kafka。 +在 Kafka 2.8 之前,Kafka 最被大家诟病的就是其重度依赖于 ZooKeeper。Kafka 2.8 引入了基于 Raft 协议的 KRaft 模式,但当时还属于 Early Access;Kafka 3.3.x 开始,KRaft 面向新集群被标记为生产可用;Kafka 4.0 起,ZooKeeper 模式已经移除,Kafka 只支持 KRaft 模式。 -不过,要提示一下:**如果要使用 KRaft 模式的话,建议选择较高版本的 Kafka,因为这个功能还在持续完善优化中。Kafka 3.3.1 版本是第一个将 KRaft(Kafka Raft)共识协议标记为生产就绪的版本。** +不过,要提示一下:老集群从 ZooKeeper 模式迁移到 KRaft 模式需要按官方迁移流程执行,不能简单改配置重启。新集群建议优先按官方当前推荐模式部署。 ![](https://oss.javaguide.cn/github/javaguide/high-performance/message-queue/kafka3.3.1-kraft-production-ready.png) @@ -155,7 +155,14 @@ Kafka 中发送 1 条消息的时候,可以指定 topic, partition, key,data 1. 1 个 Topic 只对应一个 Partition。 2. (推荐)发送消息的时候指定 key/Partition。 -当然不仅仅只有上面两种方法,上面两种方法是我觉得比较好理解的, +当然不仅仅只有上面两种方法,上面两种方法是我觉得比较好理解的。 + +顺序消费还要注意两个边界: + +- **只能保证同一分区内有序**:多个分区之间天然并行,不保证全局顺序。 +- **失败重试可能打乱业务效果**:如果某条消息处理失败,而后续消息已经被处理,业务层仍然需要状态机或版本号兜底。 + +所以,生产上通常是“同一业务 key 进同一分区 + 单分区内顺序消费 + 消费端幂等/状态机校验”一起使用。 ### Kafka 如何保证消息不丢失? @@ -225,6 +232,14 @@ acks 的默认值即为 1,代表我们的消息被 leader 副本接收之后 我们最开始也说了我们发送的消息会被发送到 leader 副本,然后 follower 副本才能从 leader 副本中拉取消息进行同步。多个 follower 副本之间的消息同步情况不一样,当我们配置了 **unclean.leader.election.enable = false** 的话,当 leader 副本发生故障时就不会从 follower 副本中和 leader 同步程度达不到要求的副本中选择出 leader ,这样降低了消息丢失的可能性。 +生产环境还建议同时关注生产者端配置: + +- 开启幂等生产者,避免生产者重试导致重复写入同一分区。 +- 合理设置 `delivery.timeout.ms`、`request.timeout.ms` 和 `linger.ms`,在可靠性、延迟和吞吐之间取舍。 +- 对关键业务消息记录发送失败日志或本地消息表,方便后续补偿。 + +Kafka 的可靠性不是某一个参数决定的,而是 Topic 副本、ISR、Producer ACK、Consumer offset 提交时机和业务幂等一起决定的。 + ### Kafka 如何保证消息不重复消费? **kafka 出现消息重复消费的原因:** @@ -239,6 +254,20 @@ acks 的默认值即为 1,代表我们的消息被 leader 副本接收之后 - 处理完消息再提交:依旧有消息重复消费的风险,和自动提交一样 - 拉取到消息即提交:会有消息丢失的风险。允许消息延时的场景,一般会采用这种方式。然后,通过定时任务在业务不繁忙(比如凌晨)的时候做数据兜底。 +## Rebalance 有什么风险?如何减少影响? + +Consumer Group 中消费者数量变化、订阅 Topic 变化、消费者长时间没有发送心跳,都可能触发 Rebalance。Rebalance 期间,分区会被重新分配,部分消费者会暂停消费,严重时会造成消费抖动和重复消费。 + +常见优化思路: + +- 控制消费者实例的频繁上下线,发布时尽量滚动、分批。 +- 合理设置 `max.poll.interval.ms`,避免单批消息处理太久导致消费者被踢出组。 +- 控制单次拉取数量,避免一次拉太多导致处理时间超过心跳或 poll 间隔。 +- 使用静态成员或更平滑的分区分配策略,减少不必要的分区迁移。 +- 消费端必须幂等,因为 Rebalance 前后 offset 提交和业务处理之间仍然可能出现重复。 + +面试里如果被问到 Rebalance,不要只说“消费者重新分配分区”。更关键的是讲清楚它会带来短暂停顿、重复消费风险,以及如何通过参数、发布策略和幂等设计降低影响。 + ## Kafka 重试机制 在 Kafka 如何保证消息不丢失这里,我们提到了 Kafka 的重试机制。由于这部分内容较为重要,我们这里再来详细介绍一下。 @@ -289,9 +318,9 @@ acks 的默认值即为 1,代表我们的消息被 leader 副本接收之后 ```java @Override - public boolean recovered(ConsumerRecord << ? , ? > record, Exception exception, + public boolean recovered(ConsumerRecord record, Exception exception, @Nullable MessageListenerContainer container, - @Nullable Consumer << ? , ? > consumer) throws InterruptedException { + @Nullable Consumer consumer) throws InterruptedException { if (this.noRetries) { // 不支持重试 @@ -415,7 +444,7 @@ public class DelErrorHandler extends DefaultErrorHandler { 当达到最大重试次数后,数据会直接被跳过,继续向后进行。当代码修复后,如何重新消费这些重试失败的数据呢? -**死信队列(Dead Letter Queue,简称 DLQ)** 是消息中间件中的一种特殊队列。它主要用于处理无法被消费者正确处理的消息,通常是因为消息格式错误、处理失败、消费超时等情况导致的消息被"丢弃"或"死亡"的情况。当消息进入队列后,消费者会尝试处理它。如果处理失败,或者超过一定的重试次数仍无法被成功处理,消息可以发送到死信队列中,而不是被永久性地丢弃。在死信队列中,可以进一步分析、处理这些无法正常消费的消息,以便定位问题、修复错误,并采取适当的措施。 +**死信队列(Dead Letter Queue,简称 DLQ)** 是消息中间件中的一种特殊队列。它主要用于处理无法被消费者正确处理的消息,通常是因为消息格式错误、处理失败、消费超时等情况导致的消息被“丢弃”或“死亡”的情况。当消息进入队列后,消费者会尝试处理它。如果处理失败,或者超过一定的重试次数仍无法被成功处理,消息可以发送到死信队列中,而不是被永久性地丢弃。在死信队列中,可以进一步分析、处理这些无法正常消费的消息,以便定位问题、修复错误,并采取适当的措施。 `@RetryableTopic` 是 Spring Kafka 中的一个注解,它用于配置某个 Topic 支持消息重试,更推荐使用这个注解来完成重试。 diff --git a/docs/high-performance/message-queue/message-queue.md b/docs/high-performance/message-queue/message-queue.md index 113c52d1087..5e47371d868 100644 --- a/docs/high-performance/message-queue/message-queue.md +++ b/docs/high-performance/message-queue/message-queue.md @@ -126,6 +126,51 @@ RabbitMQ 内置了 MQTT 插件用于实现 MQTT 功能(默认不启用,需 - **系统复杂性提高:** 加入 MQ 之后,你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题! - **一致性问题:** 我上面讲了消息队列可以实现异步,消息队列带来的异步确实可以提高系统响应速度。但是,万一消息的真正消费者并没有正确消费消息怎么办?这样就会导致数据不一致的情况了! +判断一个链路是否适合引入 MQ,可以看下面几个问题: + +- 调用方是否必须立刻拿到下游处理结果?如果必须,RPC 可能更合适。 +- 业务是否能接受最终一致?如果不能,异步化会带来额外补偿成本。 +- 高峰流量是否明显超过下游处理能力?如果是,MQ 可以做缓冲和削峰。 +- 下游失败后是否需要重试、补偿和人工介入?如果需要,MQ 可以沉淀恢复链路。 +- 团队是否具备 MQ 运维、监控和故障处理能力?如果没有,复杂度可能超过收益。 + +简单说,MQ 适合“可以晚一点完成,但不能丢、能恢复、要解耦”的场景,不适合所有同步链路无脑改异步。 + +## 如何保证消息可靠性? + +消息可靠性要按链路拆,不要只说“开启持久化”: + +1. **生产者发送阶段**:开启发送确认,发送失败要重试;核心业务可以落本地消息表或事务消息,避免本地事务成功但消息没发出去。 +2. **Broker 存储阶段**:消息要持久化,关键 Topic/队列配置副本或高可用队列,刷盘策略和副本确认策略要和业务可靠性要求匹配。 +3. **消费者处理阶段**:业务处理成功后再 ACK 或提交 offset;处理失败要重试、进死信队列或进入补偿流程。 +4. **业务兜底阶段**:通过对账任务、补偿任务、告警和人工处理兜住极端异常。 + +不同 MQ 的实现细节不同,但思路都一样:**确认、持久化、重试、幂等、补偿**。 + +## 如何处理重复消费和幂等? + +生产环境通常很难保证消息绝对只被消费一次。更常见的语义是“至少一次投递”,也就是说消息可能重复,消费者必须做幂等。 + +常见幂等方案: + +- **唯一索引**:用订单号、支付单号、消息 ID 等业务唯一键防止重复写入。 +- **状态机**:只允许状态按合法方向流转,例如订单只能从“已支付”流转到“已发货”。 +- **消费记录表**:记录消息处理状态,重复消息直接跳过。 +- **Redis 去重**:适合短时间窗口内的去重,但要注意过期时间和持久化风险。 + +幂等的关键是使用业务唯一键,而不是依赖 MQ 自动生成的消息 ID。因为同一业务事件在重试、补偿、重新发送时,可能生成不同的消息 ID。 + +## 如何处理消息积压? + +消息积压时,先判断原因,再决定是否扩容: + +- **生产突增**:活动、大促、爬虫或上游异常导致消息写入速度暴涨。 +- **消费者变慢**:慢 SQL、外部接口慢、锁竞争、线程池不足、批处理太小。 +- **分区或队列不足**:消费者实例增加了,但同一队列/分区仍只能被有限消费者并行处理。 +- **Broker 异常**:磁盘、网络、Controller/NameServer、集群复制出现问题。 + +处理顺序通常是:先止血限流,再扩容消费者和分区,随后定位慢消费逻辑,最后对历史积压做临时批处理或重放。不要一上来只说“加消费者”,如果队列数量不足或消费逻辑串行,加实例也不会提升吞吐。 + ## JMS 和 AMQP ### JMS 是什么? @@ -164,13 +209,13 @@ AMQP,即 Advanced Message Queuing Protocol,一个提供统一消息服务的 ### JMS vs AMQP -| 对比方向 | JMS | AMQP | -| :----------: | :-------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| 定义 | Java API | 协议 | -| 跨语言 | 否 | 是 | -| 跨平台 | 否 | 是 | +| 对比方向 | JMS | AMQP | +| :----------: | :-------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 定义 | Java API | 协议 | +| 跨语言 | 否 | 是 | +| 跨平台 | 否 | 是 | | 支持消息类型 | 提供两种消息模型:①Peer-2-Peer;②Pub/sub | 提供了五种消息模型:①direct exchange;②fanout exchange;③topic exchange;④headers exchange;⑤system exchange。本质来讲,后四种和 JMS 的 pub/sub 模型没有太大差别,仅是在路由机制上做了更详细的划分; | -| 支持消息类型 | 支持多种消息类型 ,我们在上面提到过 | byte[](二进制) | +| 支持消息类型 | 支持多种消息类型 ,我们在上面提到过 | byte[](二进制) | **总结:** @@ -209,7 +254,7 @@ Kafka 是一个分布式系统,由通过高性能 TCP 网络协议进行通信 在 Kafka 2.8 之前,Kafka 最被大家诟病的就是其重度依赖于 Zookeeper 做元数据管理和集群的高可用。在 Kafka 2.8 之后,引入了基于 Raft 协议的 KRaft 模式,不再依赖 Zookeeper,大大简化了 Kafka 的架构,让你可以以一种轻量级的方式来使用 Kafka。 -不过,要提示一下:**如果要使用 KRaft 模式的话,建议选择较高版本的 Kafka,因为这个功能还在持续完善优化中。Kafka 3.3.1 版本是第一个将 KRaft(Kafka Raft)共识协议标记为生产就绪的版本。** +不过,要提示一下:老集群从 ZooKeeper 模式迁移到 KRaft 模式需要按官方迁移流程执行,不能简单改配置重启。新集群建议优先按官方当前推荐模式部署。 ![](https://oss.javaguide.cn/github/javaguide/high-performance/message-queue/kafka3.3.1-kraft-production-ready.png) @@ -251,7 +296,7 @@ RabbitMQ 发展到今天,被越来越多的人认可,这和它在易用性 - **可靠性:** RabbitMQ 使用一些机制来保证消息的可靠性,如持久化、传输确认及发布确认等。 - **灵活的路由:** 在消息进入队列之前,通过交换器来路由消息。对于典型的路由功能,RabbitMQ 己经提供了一些内置的交换器来实现。针对更复杂的路由功能,可以将多个交换器绑定在一起,也可以通过插件机制来实现自己的交换器。这个后面会在我们讲 RabbitMQ 核心概念的时候详细介绍到。 - **扩展性:** 多个 RabbitMQ 节点可以组成一个集群,也可以根据实际业务情况动态地扩展集群中节点。 -- **高可用性:** 队列可以在集群中的机器上设置镜像,使得在部分节点出现问题的情况下队列仍然可用。 +- **高可用性:** RabbitMQ 4.x 中 Classic Queue 不再通过镜像队列实现高可用,高可靠场景应优先考虑 Quorum Queue 或 Streams。 - **支持多种协议:** RabbitMQ 除了原生支持 AMQP 协议,还支持 STOMP、MQTT 等多种消息中间件协议。 - **多语言客户端:** RabbitMQ 几乎支持所有常用语言,比如 Java、Python、Ruby、PHP、C#、JavaScript 等。 - **易用的管理界面:** RabbitMQ 提供了一个易用的用户界面,使得用户可以监控和管理消息、集群中的节点等。在安装 RabbitMQ 的时候会介绍到,安装好 RabbitMQ 就自带管理界面。 @@ -310,6 +355,17 @@ Pulsar 更新记录(可以直观看到项目是否还在维护): - **3.8 前**:镜像队列(Classic Queue Mirroring)是主要高可用方案 > - **3.8+**:Quorum Queue 作为推荐替代方案,镜像队列被标记为 deprecated > - **3.13**:镜像队列仍可用但已废弃 -> - **4.0+**:镜像队列**完全移除**,Quorum Queue 成为默认高可用方案 +> - **4.0+**:镜像队列**完全移除**,需要复制和高可用队列时优先考虑 Quorum Queue 或 Streams > > **网络分区警告(严重)**:无论是普通集群还是早期的镜像集群,均依赖 Erlang 内部的分布式同步机制,对网络抖动极度敏感。在多机房或跨可用区部署时,极易发生**网络分区(Split-brain)**。必须在 `rabbitmq.conf` 中明确配置分区恢复策略: > @@ -419,15 +419,17 @@ Demo 级别的,一般就是你本地启动了玩玩儿的,没人生产用单 - 网络带宽压力和消耗重 - 不是真正的分布式架构,是主从复制 -**Quorum Queue**(3.8+ 推荐,4.0 后为默认高可用方案) +**Quorum Queue**(3.8+ 推荐,高可靠队列优先考虑) -基于 Raft 协议的复制队列,是 RabbitMQ 3.8+ 推荐的高可用方案,4.0 后成为默认选项: +基于 Raft 协议的复制队列,是 RabbitMQ 3.8+ 推荐的高可用方案。对于需要复制和高可用的队列,应该优先考虑 Quorum Queue: - **基于 Raft 协议**:通过日志复制和选举实现一致性 - **仲裁写入**:需要多数节点确认(N/2 + 1)才认为写入成功 - **更严格的一致性**:避免镜像队列的脑裂风险 - **适用场景**:对可靠性要求高的场景 +Quorum Queue 不适合所有场景。临时队列、高频创建删除队列、极低延迟场景、超大规模积压和大规模 fanout,更应该优先评估 Classic Queue 或 Streams。简单说:需要复制和高可用时优先考虑 Quorum Queue;需要反复读取、事件溯源或长时间保留时优先评估 Streams。 + **声明方式(客户端)**: Java: @@ -595,12 +597,12 @@ management.tcp.port = 15672 ### 核心技术架构演进 -| 版本里程碑 | 重要变化 | 生产影响 | -| ---------- | --------------------------------------- | -------------------------------------- | -| **3.8 前** | 镜像队列(Classic Queue Mirroring)时代 | 主从复制,脑裂风险 | -| **3.8+** | Quorum Queue 引入 | 基于 Raft,推荐用于高可靠场景 | -| **3.9+** | Streams 引入 | Kafka-like 架构,支持事件溯源 | -| **4.0+** | 镜像队列完全移除 | 新项目必须使用 Quorum Queue 或 Streams | +| 版本里程碑 | 重要变化 | 生产影响 | +| ---------- | --------------------------------------- | ------------------------------------------ | +| **3.8 前** | 镜像队列(Classic Queue Mirroring)时代 | 主从复制,脑裂风险 | +| **3.8+** | Quorum Queue 引入 | 基于 Raft,推荐用于高可靠场景 | +| **3.9+** | Streams 引入 | Kafka-like 架构,支持事件溯源 | +| **4.0+** | 镜像队列完全移除 | 高可靠队列优先考虑 Quorum Queue 或 Streams | ### 面试高频考点 @@ -631,7 +633,7 @@ management.tcp.port = 15672 **1. 队列类型选型** ``` -高可靠性需求 → Quorum Queue(默认推荐) +高可靠性需求 → Quorum Queue(优先考虑) 高吞吐量需求 → Classic Queue(单节点)或 Streams(3.9+) 事件溯源需求 → Streams(支持非破坏性消费) ``` diff --git a/docs/high-performance/message-queue/rocketmq-questions.md b/docs/high-performance/message-queue/rocketmq-questions.md index 03ad07e9b90..5acc091cca6 100644 --- a/docs/high-performance/message-queue/rocketmq-questions.md +++ b/docs/high-performance/message-queue/rocketmq-questions.md @@ -49,7 +49,7 @@ head: 当我们在食堂排队打饭时,我们和食堂工作人员之间就是一个同步模型。 -我们需要告诉工作人员:"请帮我加个鸡腿,再加个酸辣土豆丝,多打点饭"。 +我们需要告诉工作人员:“请帮我加个鸡腿,再加个酸辣土豆丝,多打点饭”。 然后工作人员帮我们打饭配菜,我们需要等待这个过程完成。 @@ -81,9 +81,9 @@ head: ![](https://oss.javaguide.cn/github/javaguide/high-performance/message-queue/16ef381f273a66bd.jpg) -这样频繁改动代码显然很麻烦,此时可以 **使用消息队列进行解耦** 。需要注意的是,后面的发送短信、发送邮件、添加积分等操作都依赖于 `result`,即购票的处理结果(如订单号、用户账号等),也就是说后续服务都需要相同的消息来进行处理。因此可以通过 **"广播消息"** 模式来实现。 +这样频繁改动代码显然很麻烦,此时可以 **使用消息队列进行解耦** 。需要注意的是,后面的发送短信、发送邮件、添加积分等操作都依赖于 `result`,即购票的处理结果(如订单号、用户账号等),也就是说后续服务都需要相同的消息来进行处理。因此可以通过 **“广播消息”** 模式来实现。 -这里所说的"广播"并不是真正的广播,而是下游系统作为消费者去 **订阅** 特定的主题。比如主题可以命名为 `订票`,购买系统作为生产者将消息发送到消息队列,消费者订阅该主题后,从消息队列中拉取消息并消费。在生产者端只需要关注 **生产消息到指定主题** ,**消费者只需要关注从指定主题中拉取消息** 。 +这里所说的“广播”并不是真正的广播,而是下游系统作为消费者去 **订阅** 特定的主题。比如主题可以命名为 `订票`,购买系统作为生产者将消息发送到消息队列,消费者订阅该主题后,从消息队列中拉取消息并消费。在生产者端只需要关注 **生产消息到指定主题** ,**消费者只需要关注从指定主题中拉取消息** 。 ![](https://oss.javaguide.cn/github/javaguide/high-performance/message-queue/16ef382674b66892.jpg) @@ -176,6 +176,8 @@ RocketMQ 是一个 **队列模型** 的消息中间件,具有**高性能、高 RocketMQ 具备高吞吐、低延迟、高可用的特点,经过了双十一等大规模场景的验证。 +从 RocketMQ 5.x 开始,官方更强调云原生架构:Proxy 层支持 gRPC、多语言 SDK 和多协议接入,Broker 更专注消息存储和高可用。这意味着新项目选型时,除了看传统的 NameServer、Broker、Producer、Consumer,也要关注是否需要 Proxy、gRPC SDK、Kubernetes 部署和云原生可观测能力。 + ## 队列模型和主题模型是什么? 在谈 RocketMQ 的技术架构之前,我们先来了解一下两个名词概念——**队列模型** 和 **主题模型** 。 @@ -211,7 +213,7 @@ flowchart LR linkStyle default stroke-width:1.5px,opacity:0.8 ``` -在一开始我跟你提到了一个 **"广播"** 的概念,也就是说如果我们此时我们需要将一个消息发送给多个消费者(比如此时我需要将信息发送给短信系统和邮件系统),这个时候单个队列即不能满足需求了。 +在一开始我跟你提到了一个 **“广播”** 的概念,也就是说如果我们此时我们需要将一个消息发送给多个消费者(比如此时我需要将信息发送给短信系统和邮件系统),这个时候单个队列即不能满足需求了。 当然你可以让 Producer 生产消息放入多个队列中,然后每个队列去对应每一个消费者。问题是可以解决,创建多个队列并且复制多份消息是会很影响资源和性能的。而且,这样子就会导致生产者需要知道具体消费者个数然后去复制对应数量的消息队列,这就违背我们消息中间件的 **解耦** 这一原则。 @@ -403,7 +405,7 @@ flowchart TB ### NameServer(注册中心) -NameServer 负责元数据的存储,扮演着集群"中枢神经系统"的角色,其核心作用是为生产者和消费者提供路由信息,帮助它们找到对应的 Broker 地址。 +NameServer 负责元数据的存储,扮演着集群“中枢神经系统”的角色,其核心作用是为生产者和消费者提供路由信息,帮助它们找到对应的 Broker 地址。 **核心功能:** @@ -578,6 +580,8 @@ RocketMQ 5.0 引入了 **Proxy** 组件,这是 **计算与存储分离** 架 > **注意**:在 5.0 版本中,使用新版 SDK(gRPC 协议)的客户端需要通过 Proxy 接入,而旧版 SDK(Remoting 协议)仍然可以直连 Broker。 +Proxy 的价值不只是“多一层代理”。在云原生场景下,它可以把协议接入、认证鉴权、流量治理、消费管理这类计算逻辑从 Broker 中剥离出来,让 Broker 更稳定地承担存储职责。代价是链路多了一跳,需要额外关注 Proxy 的水平扩容、延迟、限流和监控。 + ### 为什么必须要 NameServer? 先看一个简单的架构模型: @@ -898,7 +902,7 @@ flowchart TB ``` 1. 生产者将消息发送至 RocketMQ 服务端 -2. 服务端将消息持久化成功之后,向生产者返回 Ack 确认消息已经发送成功,此时消息被标记为"暂不能投递",这种状态下的消息即为**半事务消息** +2. 服务端将消息持久化成功之后,向生产者返回 Ack 确认消息已经发送成功,此时消息被标记为“暂不能投递”,这种状态下的消息即为**半事务消息** 3. 生产者开始执行本地事务逻辑 4. 生产者根据本地事务执行结果向服务端提交二次确认结果(Commit 或 Rollback) 5. 如果服务端未收到二次确认结果,或收到的结果为 Unknown,经过固定时间后,服务端将对消息生产者发起**消息回查** @@ -926,7 +930,9 @@ flowchart TB **使用建议** 1. **避免大量未决事务导致超时**:生产者应该尽量避免本地事务返回未知结果,大量的事务检查会导致系统性能受损 -2. **正确处理"进行中"的事务**:消息回查时,对于正在进行中的事务不要返回 Rollback 或 Commit 结果,应继续保持 Unknown 的状态 +2. **正确处理“进行中”的事务**:消息回查时,对于正在进行中的事务不要返回 Rollback 或 Commit 结果,应继续保持 Unknown 的状态 +3. **本地事务状态要可查询**:事务回查依赖生产者查询本地事务最终状态,建议落库或写可靠存储,不要只放进进程内存。 +4. **下游消费仍需幂等**:事务消息解决的是“本地事务和消息发送”的一致性,不保证消费者业务一定成功,消费端仍然要有重试、幂等和补偿。 ### 关于发送消息 @@ -1270,7 +1276,9 @@ RocketMQ 服务端 3.x/4.x 历史版本:上述消费逻辑由消费者客户 在上面我介绍 RocketMQ 的技术架构的时候我已经向你展示了 **它是如何保证高可用的** ,这里不涉及运维方面的搭建,如果你感兴趣可以自己去官网上照着例子搭建属于你自己的 RocketMQ 集群。 -> 其实 Kafka 的架构基本和 RocketMQ 类似,只是它注册中心使用了 Zookeeper、它的 **分区** 就相当于 RocketMQ 中的 **队列** 。还有一些小细节不同会在后面提到。 +> 其实 Kafka 的架构基本和 RocketMQ 类似,只是早期 Kafka 依赖 ZooKeeper 管理元数据,而它的 **分区** 就相当于 RocketMQ 中的 **队列**。还有一些小细节不同会在后面提到。 + +> 补充:早期 Kafka 依赖 ZooKeeper 管理元数据,新版本已经引入 KRaft 模式。这里对比的是“分区/队列用于提升并行度”的架构思路,不应再简单认为 Kafka 一定依赖 ZooKeeper。 ### 顺序消费 @@ -1363,6 +1371,8 @@ producer.setRetryTimesWhenSendFailed(5); 不过最主要的还是需要 **根据特定场景使用特定的解决方案** ,你要知道你的消息消费是否是完全不可重复消费还是可以忍受重复消费的,然后再选择强校验和弱校验的方式。毕竟在 CS 领域还是很少有技术银弹的说法。 +RocketMQ 消费端幂等可以优先按业务唯一键设计,而不是只依赖消息 ID。比如订单支付消息用支付单号或订单号做唯一键,库存扣减消息用业务流水号做唯一键。这样即使消息重试、补偿或重新投递,只要业务唯一键不变,就能避免重复写入。 + 而在整个互联网领域,幂等不仅仅适用于消息队列的重复消费问题,这些实现幂等的方法,也同样适用于,**在其他场景中来解决重复请求或者重复调用的问题** 。比如将 HTTP 服务设计成幂等的,**解决前端或者 APP 重复提交表单数据的问题** ,也可以将一个微服务设计成幂等的,解决 RPC 框架自动重试导致的 **重复调用问题** 。 ## RocketMQ 如何实现分布式事务? @@ -1380,7 +1390,7 @@ producer.setRetryTimesWhenSendFailed(5); **事务消息处理流程详解** 1. **发送半事务消息**:生产者将消息发送至 RocketMQ 服务端 -2. **服务端确认**:服务端将消息持久化成功之后,向生产者返回 Ack 确认消息已经发送成功,此时消息被标记为"暂不能投递",这种状态下的消息即为**半事务消息** +2. **服务端确认**:服务端将消息持久化成功之后,向生产者返回 Ack 确认消息已经发送成功,此时消息被标记为“暂不能投递”,这种状态下的消息即为**半事务消息** 3. **执行本地事务**:生产者开始执行本地事务逻辑 4. **提交二次确认**:生产者根据本地事务执行结果向服务端提交二次确认结果(Commit 或 Rollback) 5. **事务回查**:如果服务端未收到二次确认结果,或收到的结果为 Unknown,经过固定时间后,服务端将对消息生产者发起**消息回查** @@ -1621,6 +1631,16 @@ public class ConsumerAddViewHistory implements RocketMQListener { ![](https://oss.javaguide.cn/github/javaguide/high-performance/message-queue/16ef387d939ab66d.jpg) +生产排查消息堆积时,可以按这个顺序来: + +1. **先确认堆积范围**:是单个 Topic、单个队列,还是整个 Broker 都堆积。 +2. **看生产速度和消费速度**:生产突增要限流或削峰,消费下降要查消费者。 +3. **查消费者耗时**:重点看慢 SQL、外部接口、锁竞争、线程池和批量大小。 +4. **看队列和消费者匹配关系**:4.x 需要关注队列数是否限制了并发,5.x 还要关注消息粒度负载均衡策略。 +5. **做临时扩容和补偿**:必要时临时扩容消费者、增加队列、拆分 Topic,历史积压用批处理任务慢慢追。 + +不要只盯着“加消费者”。如果单队列顺序消费卡住,或者业务处理本身很慢,加消费者也不会明显改善。 + ## 什么是回溯消费? 回溯消费是指 Consumer 已经消费成功的消息,由于业务上需求需要重新消费,在 RocketMQ 中, Broker 在向 Consumer 投递成功消息后,**消息仍然需要保留** 。并且重新消费一般是按照时间维度,例如由于 Consumer 系统故障,恢复后需要重新消费 1 小时前的数据,那么 Broker 要提供一种机制,可以按照时间维度来回退消费进度。RocketMQ 支持按照时间回溯消费,时间维度精确到毫秒。 @@ -1800,6 +1820,7 @@ RocketMQ 这么做的原因是 **提高数据的写入效率** ,不分 Topic - **消息粒度负载均衡**:解决长尾效应问题,消息动态分配给空闲消费者 - **计算与存储分离**:Proxy 组件承担协议适配和计算逻辑,Broker 专注存储 - **任意精度定时消息**:不再受限于固定延迟等级,支持毫秒级定时 +- **gRPC 多语言 SDK**:降低多语言客户端接入成本,更适合云原生和多协议场景 **高性能设计** diff --git a/docs/high-performance/read-and-write-separation-and-library-subtable.md b/docs/high-performance/read-and-write-separation-and-library-subtable.md index 8cf3e27c248..cbaa7b25393 100644 --- a/docs/high-performance/read-and-write-separation-and-library-subtable.md +++ b/docs/high-performance/read-and-write-separation-and-library-subtable.md @@ -96,7 +96,7 @@ hintManager.setMasterRouteOnly(); // 继续JDBC操作 ``` -> ⚠️ **注意**:严禁大范围使用此方案!读写分离的初衷就是为了分担主库的读压力,若大量读请求因延迟而回退到主库,在促销、秒杀等高并发场景下极易压垮主库导致全站宕机。**正确的 Trade-off**:仅核心强一致链路读主库,非核心链路必须在业务层容忍最终一致性(如页面提示"数据同步中")。 +> ⚠️ **注意**:严禁大范围使用此方案!读写分离的初衷就是为了分担主库的读压力,若大量读请求因延迟而回退到主库,在促销、秒杀等高并发场景下极易压垮主库导致全站宕机。**正确的 Trade-off**:仅核心强一致链路读主库,非核心链路必须在业务层容忍最终一致性(如页面提示“数据同步中”)。 ```java HintManager hintManager = HintManager.getInstance(); @@ -161,6 +161,15 @@ MySQL 主从同步延时是指从库的数据落后于主库的数据,这种 答案之一就是 **分库分表**。 +在决定分库分表之前,建议先确认这几件事: + +1. 慢 SQL、索引、分页、缓存、读写分离是否已经优化过。 +2. 单表数据量、单库容量、连接数、写入 QPS 是否真的接近瓶颈。 +3. 核心查询是否能通过一个稳定的分片键覆盖。 +4. 业务是否能接受跨分片查询、分布式事务、数据迁移带来的复杂度。 + +分库分表不是数据库优化的第一步,更像是常规优化都扛不住之后的容量扩展方案。 + ### 什么是分库? **分库** 就是将数据库中的数据分散到不同的数据库上,可以垂直分库,也可以水平分库。 @@ -231,6 +240,17 @@ MySQL 主从同步延时是指从库的数据落后于主库的数据,这种 实际项目中,分片键很难满足上面提到的所有特点,需要权衡一下。并且,分片键可以是表中多个字段的组合,例如取用户 ID 后四位作为订单 ID 后缀。 +常见业务的分片键选择可以参考: + +| 业务场景 | 候选分片键 | 注意事项 | +| ---------- | ------------------------- | ---------------------------------------------- | +| 订单系统 | 用户 ID、商家 ID、订单 ID | 看主要查询路径,用户查订单和商家查订单可能冲突 | +| IM 消息 | 会话 ID、用户 ID | 同一会话顺序和热点群聊要重点评估 | +| 多租户系统 | 租户 ID | 大租户容易形成热点,需要大租户单独拆分 | +| 支付流水 | 用户 ID、交易单号 | 强一致查询和对账链路要提前设计 | + +如果一个业务天然存在多条高频查询路径,可以考虑冗余一份查询维度数据,或者把部分查询交给搜索引擎、宽表、报表系统,而不是强行让一个分片键满足所有需求。 + ### 分库分表会带来什么问题呢? 记住,你在公司做的任何技术决策,不光是要考虑这个技术能不能满足我们的要求,是否适合当前业务场景,还要重点考虑其带来的成本。 @@ -294,6 +314,14 @@ ShardingSphere 的优势如下(摘自 ShardingSphere 官方文档: EXPLAIN SELECT `score`,`name` FROM `cus_order` ORDER BY `score` DESC; 删除长期未使用的索引,不用的索引的存在会造成不必要的性能损耗 MySQL 5.7 可以通过查询 sys 库的 schema_unused_indexes 视图来查询哪些索引从未被使用 +## 生产优化注意事项 + +- **不要在高峰期直接加大索引**:大表加索引可能长时间占用资源,生产环境需要评估在线 DDL、备份、回滚和业务低峰窗口。 +- **不要为了一个低频查询牺牲写入性能**:索引越多,写入、更新和删除的维护成本越高。 +- **不要忽略数据分布**:同一条 SQL 在测试库很快,到了生产库可能因为数据倾斜、统计信息陈旧而走完全不同的执行计划。 +- **不要只优化 SQL 文本**:有些问题需要产品侧限制查询范围,有些需要缓存,有些需要异步报表或数仓承接。 +- **优化后继续观察**:上线后持续观察慢查询数量、CPU、I/O、Buffer Pool 命中率、连接数和锁等待。 + ## 参考 - MySQL 8.2 Optimizing SQL Statements:https://dev.mysql.com/doc/refman/8.0/en/statement-optimization.html diff --git a/docs/java/concurrent/virtual-thread.md b/docs/java/concurrent/virtual-thread.md index 9bd47eb1212..7d4028cf199 100644 --- a/docs/java/concurrent/virtual-thread.md +++ b/docs/java/concurrent/virtual-thread.md @@ -10,6 +10,8 @@ head: content: Java虚拟线程,Virtual Threads,Project Loom,Java 21新特性,轻量级线程,协程,虚拟线程原理 --- + + 一个 Web 请求进来,代码要查数据库、调远程接口、读写文件。按传统的同步写法,这个请求会占住一个平台线程,哪怕大部分时间都在等 I/O。 线程池能缓解线程创建成本,但不能改变一个事实:平台线程数量仍然受操作系统线程数量、内存和调度成本限制。当并发请求继续增加时,线程池里的线程会被排队任务占满,吞吐量很快卡住。 @@ -256,7 +258,7 @@ public class VirtualThreadCompareDemo { ### 调度 -平台线程依赖操作系统调度。虚拟线程由 JDK 自己的调度器调度,再由平台线程承载执行。JEP 444 中说明,虚拟线程调度器是一个 FIFO 模式的 `ForkJoinPool`,它和并行流使用的 common pool 不是同一个池。 +平台线程依赖操作系统调度。虚拟线程由 JDK 自己的调度器调度,再由平台线程承载执行。JEP 444 中说明,虚拟线程调度器是一个采用 FIFO 模式的 work-stealing `ForkJoinPool`,它和并行流使用的 common pool 不是同一个池。 默认情况下,调度器的并行度和可用处理器数量相关,可以通过下面的系统属性调整: @@ -318,7 +320,7 @@ Java 21 正式版保证虚拟线程支持 `ThreadLocal`,这有利于兼容老 以前在线程池里,一个 `ThreadLocal` 可能只对应几十或几百个平台线程。迁移到虚拟线程后,如果每个任务一个虚拟线程,同样的写法可能变成每个任务创建一份缓存对象,内存和分配压力会被放大。 -如果只是传递请求上下文、用户 ID、Trace ID,通常问题不大。如果是缓存数据库连接、大数组、复杂 formatter、客户端对象,就要重新评估。新版本 Java 中的 Scoped Values 也值得关注,它更适合在大量虚拟线程之间传递不可变上下文。 +如果只是传递请求上下文、用户 ID、Trace ID,通常问题不大。如果是缓存数据库连接、大数组、复杂 formatter、客户端对象,就要重新评估。JDK 25 通过 JEP 506 将 Scoped Values 转正,它更适合在大量虚拟线程之间传递不可变上下文。 ### 虚拟线程不会消除线程安全问题 @@ -410,7 +412,7 @@ JFR 中和虚拟线程相关的事件包括: -Djdk.tracePinnedThreads=full ``` -它会在虚拟线程阻塞且被固定时打印调用栈,适合本地或测试环境定位问题。JDK 24 的 JEP 491 之后,这个参数已经不再需要,设置也不会产生效果。 +它会在虚拟线程阻塞且被固定时打印调用栈,适合本地或测试环境定位问题。JDK 24 的 JEP 491 之后,`synchronized` 相关的主要 Pinning 场景已经改进;native/FFM 等剩余边界仍然建议结合 JFR 和线程转储判断。 ## 虚拟线程常见面试题 @@ -432,7 +434,7 @@ I/O 密集型任务大部分时间在等待外部资源。平台线程等待时 ### 虚拟线程和协程一样吗? -它们都属于轻量级并发的思路,但 Java 虚拟线程是 `java.lang.Thread` 的实现,纳入了 Java 原有线程模型。业务代码不需要写 `async/await`,也不需要手动 yield。对开发者来说,它更像“便宜很多的线程”。 +它们都属于轻量级并发的思路,但 Java 虚拟线程是 `java.lang.Thread` 的实现,纳入了 Java 原有线程模型。业务代码不需要写 `async/await`,也不需要手动 yield。和 Go goroutine 相比,虚拟线程更强调兼容 Java 既有线程 API、调试工具和阻塞式代码风格。对开发者来说,它更像“便宜很多的线程”。 ### 使用虚拟线程后还需要 Reactive 编程吗? @@ -447,7 +449,10 @@ I/O 密集型任务大部分时间在等待外部资源。平台线程等待时 - [JEP 444: Virtual Threads](https://openjdk.org/jeps/444) - [Oracle Java 21 Documentation: Virtual Threads](https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html) - [JEP 491: Synchronize Virtual Threads without Pinning](https://openjdk.org/jeps/491) +- [JEP 506: Scoped Values](https://openjdk.org/jeps/506) - [Spring Boot Reference Documentation: Virtual threads](https://docs.spring.io/spring-boot/reference/features/spring-application.html#features.spring-application.virtual-threads) - [Spring Blog: Embracing Virtual Threads](https://spring.io/blog/2022/10/11/embracing-virtual-threads/) - [Inside Java: Managing Throughput with Virtual Threads](https://inside.java/2024/02/04/sip094/) - [Quarkus Blog: When Quarkus meets Virtual Threads](https://quarkus.io/blog/virtual-thread-1/) + + diff --git a/docs/tools/README.md b/docs/tools/README.md index 7b0d9d7bbfa..b4b3d63401b 100644 --- a/docs/tools/README.md +++ b/docs/tools/README.md @@ -30,20 +30,20 @@ head: ## 学习重点 -- Maven 和 Gradle 解决的是项目构建、依赖管理、生命周期和插件扩展问题。 +- Maven 和 Gradle 解决的是项目构建、依赖管理、生命周期、Wrapper 和插件扩展问题。 - Git 是团队协作的基础能力,重点不是背命令,而是理解工作区、暂存区、提交、分支、合并和冲突处理。 -- GitHub 不只是代码托管平台,也承载开源协作、个人展示、代码阅读和项目管理。 -- Docker 主要解决环境一致性、部署隔离、镜像分发和本地快速搭建依赖服务的问题。 +- GitHub 不只是代码托管平台,也承载开源协作、个人展示、代码阅读、Actions 自动化和项目管理。 +- Docker 主要解决环境一致性、部署隔离、镜像分发、本地快速搭建依赖服务和多容器应用编排的问题。 - 工具类知识最好结合真实项目练习,单独看概念容易会看不会用。 ## 建议阅读顺序 1. [Git 核心概念总结](./git/git-intro.md):先掌握版本控制、提交、分支、合并和协作流程。 2. [Maven 核心概念总结](./maven/maven-core-concepts.md):理解 Java 项目构建、POM、坐标、仓库、依赖和生命周期。 -3. [Maven 最佳实践](./maven/maven-best-practices.md):补齐依赖版本管理、多模块项目和日常使用规范。 +3. [Maven 最佳实践](./maven/maven-best-practices.md):补齐依赖版本管理、BOM、Maven Wrapper、CI 和日常使用规范。 4. [Docker 核心概念总结](./docker/docker-intro.md):建立镜像、容器、仓库和 Docker 引擎的基本认知。 -5. [Docker 实战](./docker/docker-in-action.md):通过命令和场景练习容器管理、镜像构建和服务部署。 -6. [Gradle 核心概念总结](./gradle/gradle-core-concepts.md) 和 [GitHub 实用小技巧总结](./git/github-tips.md):按项目需要补充 Gradle 与 GitHub 使用技巧。 +5. [Docker 实战](./docker/docker-in-action.md):通过命令和场景练习容器管理、镜像构建、数据卷和常见排查。 +6. [Gradle 核心概念总结](./gradle/gradle-core-concepts.md) 和 [GitHub 实用小技巧总结](./git/github-tips.md):按项目需要补充 Gradle Wrapper、GitHub Actions 与代码阅读技巧。 ## 核心文章 @@ -51,20 +51,20 @@ head: - [Maven 专题](./maven/):讲清 Maven 核心概念和最佳实践,是 Java 后端项目构建最常用的工具专题。 - [Maven 核心概念总结](./maven/maven-core-concepts.md):理解 POM、坐标、仓库、依赖范围、生命周期、插件和多模块项目。 -- [Maven 最佳实践](./maven/maven-best-practices.md):整理标准目录结构、编译插件、依赖管理、多模块管理和常用实践建议。 -- [Gradle 核心概念总结](./gradle/gradle-core-concepts.md):了解 Gradle、Groovy、Gradle Wrapper、插件和 Task 等核心概念。 +- [Maven 最佳实践](./maven/maven-best-practices.md):整理标准目录结构、编译版本、依赖管理、Maven Wrapper、CI 和常用实践建议。 +- [Gradle 核心概念总结](./gradle/gradle-core-concepts.md):了解 Gradle、Groovy/Kotlin DSL、Gradle Wrapper、插件和 Task 等核心概念。 ### 版本控制与代码协作 - [Git 专题](./git/):围绕 Git 核心概念、工作流和 GitHub 提效技巧展开。 - [Git 核心概念总结](./git/git-intro.md):理解版本控制、工作区、暂存区、提交、分支、合并、冲突和远程仓库。 -- [GitHub 实用小技巧总结](./git/github-tips.md):整理个人主页、项目徽章、代码阅读、搜索和开源协作相关技巧。 +- [GitHub 实用小技巧总结](./git/github-tips.md):整理个人主页、项目徽章、代码阅读、Actions、Explore/Trending 和开源协作相关技巧。 ### 容器化与本地环境 - [Docker 专题](./docker/):从核心概念到实战操作,帮助理解容器化交付和环境一致性。 - [Docker 核心概念总结](./docker/docker-intro.md):理解容器、镜像、仓库、Docker 引擎以及容器和虚拟机的区别。 -- [Docker 实战](./docker/docker-in-action.md):通过镜像、容器、网络、数据卷和常见命令完成 Docker 入门实践。 +- [Docker 实战](./docker/docker-in-action.md):通过镜像、容器、网络、数据卷、日志和排查命令完成 Docker 入门实践。 ### IDE 与效率工具 @@ -74,13 +74,13 @@ head: - Maven 的 POM、坐标、仓库、依赖范围分别是什么? - Maven 生命周期和插件是什么关系? -- Maven 多模块项目如何管理公共依赖版本? +- Maven 多模块项目如何通过 BOM、`dependencyManagement` 和 Maven Wrapper 管理公共依赖与构建版本? - Gradle 和 Maven 有什么区别?什么时候需要了解 Gradle? - Git 工作区、暂存区、本地仓库和远程仓库分别是什么? - Git merge 和 rebase 有什么区别?冲突应该如何处理? -- GitHub 除了托管代码,还能帮助开发者做哪些事? +- GitHub 除了托管代码,还能通过 Profile README、Actions、Codespaces、Explore/Trending 帮开发者做哪些事? - Docker 镜像和容器是什么关系?容器和虚拟机有什么区别? -- Docker 为什么能解决开发、测试、部署环境不一致的问题? +- Docker 为什么能解决开发、测试、部署环境不一致的问题?Compose 适合解决什么问题? ## 相关专题 diff --git a/docs/tools/docker/README.md b/docs/tools/docker/README.md index 69ab12c8302..2ef2e8aff6b 100644 --- a/docs/tools/docker/README.md +++ b/docs/tools/docker/README.md @@ -30,18 +30,19 @@ Docker 是后端开发非常常见的容器化工具,常用于本地快速启 - 镜像是静态模板,容器是镜像运行后的实例,仓库用于分发和复用镜像。 - Docker 常用命令要围绕镜像管理、容器生命周期、日志查看、端口映射和进入容器来掌握。 - 数据卷用于数据持久化和宿主机目录挂载,网络用于容器之间和容器与外部服务通信。 +- Docker Compose 用于定义和运行多容器应用,适合本地开发环境和简单服务编排。 - Docker 不是万能部署方案,生产环境还要结合镜像安全、资源限制、日志、监控和编排能力考虑。 ## 建议阅读顺序 1. [Docker 核心概念总结](./docker-intro.md):先理解容器、镜像、仓库、Docker 引擎以及容器和虚拟机的区别。 -2. [Docker 实战](./docker-in-action.md):通过实际命令练习镜像拉取、容器启动、端口映射、数据卷和常见服务部署。 +2. [Docker 实战](./docker-in-action.md):通过实际命令练习镜像拉取、容器启动、端口映射、数据卷、日志查看和常见服务部署。 3. 结合一个 Java 项目练习:把应用依赖的 MySQL、Redis 等服务用 Docker 启动起来,再观察日志、数据目录和端口映射。 ## 核心文章 -- [Docker 核心概念总结](./docker-intro.md):讲解容器、镜像、仓库、Docker 引擎、Docker 架构,以及 Docker 和虚拟机的区别。 -- [Docker 实战](./docker-in-action.md):通过常用命令和实践场景理解镜像管理、容器管理、服务部署和本地环境搭建。 +- [Docker 核心概念总结](./docker-intro.md):讲解容器、镜像、仓库、Docker 引擎、Docker 架构、Docker Compose,以及 Docker 和虚拟机的区别。 +- [Docker 实战](./docker-in-action.md):通过常用命令和实践场景理解镜像管理、容器管理、服务部署、本地环境搭建和常见排查。 ## 高频问题 @@ -52,6 +53,7 @@ Docker 是后端开发非常常见的容器化工具,常用于本地快速启 - 为什么容器删除后数据可能丢失?数据卷解决了什么问题? - 端口映射和容器网络分别解决什么问题? - 如何查看容器日志、进入容器、停止和删除容器? +- `docker compose` 适合解决什么问题?和单独执行 `docker run` 有什么区别? - Docker 在开发、测试和部署环境里分别有什么价值? ## 相关专题 diff --git a/docs/tools/docker/docker-in-action.md b/docs/tools/docker/docker-in-action.md index abc1850f97d..2cdfce695b5 100644 --- a/docs/tools/docker/docker-in-action.md +++ b/docs/tools/docker/docker-in-action.md @@ -1,5 +1,5 @@ --- -title: Docker实战 +title: Docker 实战 description: 通过实战理解 Docker 的镜像与容器管理,解决环境一致性与交付效率问题,提升开发测试部署的协同效率。 category: 开发工具 tag: @@ -12,16 +12,16 @@ head: ## Docker 介绍 -开始之前,还是简单介绍一下 Docker,更多 Docker 概念介绍可以看前一篇文章[Docker 核心概念总结](./docker-intro.md)。 +开始之前,先简单回顾一下 Docker。更完整的概念介绍可以看前一篇文章:[Docker 核心概念总结](./docker-intro.md)。 ### 什么是 Docker? -说实话关于 Docker 是什么并不太好说,下面我通过四点向你说明 Docker 到底是个什么东西。 +可以从下面几个角度理解 Docker: -- Docker 是世界领先的软件容器平台,基于 **Go 语言** 进行开发实现。 -- Docker 能够自动执行重复性任务,例如搭建和配置开发环境,从而解放开发人员。 +- Docker 是常见的软件容器平台,基于 Go 语言开发实现。 +- Docker 可以把应用和运行依赖打包到镜像中,减少开发、测试、部署环境不一致带来的问题。 - 用户可以方便地创建和使用容器,把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改,就像管理普通的代码一样。 -- Docker 可以**对进程进行封装隔离,属于操作系统层面的虚拟化技术。** 由于隔离的进程独立于宿主和其它的隔离的进程,因此也称其为容器。 +- Docker 可以**对进程进行封装隔离,属于操作系统层面的虚拟化技术。** 由于隔离的进程独立于宿主和其他隔离进程,因此也称其为容器。 官网地址: 。 @@ -33,7 +33,7 @@ Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级 容器是完全使用沙箱机制,相互之间不会有任何接口(类似 iPhone 的 app),更重要的是容器性能开销极低。 -传统的开发流程中,我们的项目通常需要使用 MySQL、Redis、FastDFS 等等环境,这些环境都是需要我们手动去进行下载并配置的,安装配置流程极其复杂,而且不同系统下的操作也不一样。 +传统的开发流程中,我们的项目通常需要使用 MySQL、Redis、Kafka 等依赖服务。这些环境如果都手动安装和配置,不同系统下的操作差异很大,也容易出现“我本地可以,你本地不行”的问题。 Docker 的出现完美地解决了这一问题,我们可以在容器中安装 MySQL、Redis 等软件环境,使得应用和环境架构分开,它的优势在于: @@ -49,31 +49,31 @@ Docker 的出现完美地解决了这一问题,我们可以在容器中安装 ### Windows -接下来对 Docker 进行安装,以 Windows 系统为例,访问 Docker 的官网: +Windows 推荐安装 Docker Desktop。访问 Docker 官网下载安装包: ![安装 Docker](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-install-windows.png) -然后点击`Get Started`: +然后点击 `Get Started`: ![安装 Docker](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-install-windows-download.png) -在此处点击`Download for Windows`即可进行下载。 +在此处点击 `Download for Windows` 即可下载。 -如果你的电脑是`Windows 10 64位专业版`的操作系统,则在安装 Docker 之前需要开启一下`Hyper-V`,开启方式如下。打开控制面板,选择程序: +目前 Docker Desktop for Windows 推荐使用 WSL 2 后端。安装前建议确认系统满足 Docker Desktop 的版本要求,并已经启用 WSL 2。部分场景也可以使用 Hyper-V 后端,开启方式如下。打开控制面板,选择程序: ![开启 Hyper-V](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-windows-hyperv.png) -点击`启用或关闭Windows功能`: +点击 `启用或关闭 Windows 功能`: ![开启 Hyper-V](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-windows-hyperv-enable.png) -勾选上`Hyper-V`,点击确定即可: +勾选 `Hyper-V`,点击确定即可: ![开启 Hyper-V](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-windows-hyperv-check.png) 完成更改后需要重启一下计算机。 -开启了`Hyper-V`后,我们就可以对 Docker 进行安装了,打开安装程序后,等待片刻点击`Ok`即可: +开启 `Hyper-V` 后,就可以安装 Docker Desktop 了。打开安装程序后,等待片刻点击 `Ok` 即可: ![安装 Docker](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-windows-hyperv-install.png) @@ -81,11 +81,11 @@ Docker 的出现完美地解决了这一问题,我们可以在容器中安装 ![安装 Docker](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-windows-hyperv-wsl2.png) -它的意思是询问我们是否使用 WSL2,这是基于 Windows 的一个 Linux 子系统,这里我们取消即可,它就会使用我们之前勾选的`Hyper-V`虚拟机。 +如果安装过程中提示使用 WSL 2,一般建议优先选择 WSL 2 后端。它是 Windows 上运行 Linux 容器更常用的方式;如果你的环境必须使用 Hyper-V,再切换到 Hyper-V 后端。 因为是图形界面的操作,这里就不介绍 Docker Desktop 的具体用法了。 -### Mac +### macOS 直接使用 Homebrew 安装即可 @@ -95,7 +95,7 @@ brew install --cask docker ### Linux -下面来看看 Linux 中如何安装 Docker,这里以 CentOS7 为例。 +下面来看看 Linux 中如何安装 Docker。不同发行版的安装命令略有差异,生产环境建议优先参考 Docker 官方文档。这里用官方安装脚本演示测试或开发环境的快速安装方式。 在测试或开发环境中,Docker 官方为了简化安装流程,提供了一套便捷的安装脚本,执行这个脚本后就会自动地将一切准备工作做好,并且把 Docker 的稳定版本安装在系统中。 @@ -133,7 +133,7 @@ systemctl enable docker ### 仓库 -仓库是集中存放镜像文件的场所。仓库和仓库注册服务器是有区别的,仓库注册服务器上往往存放着多个仓库,每个仓库中又包含了多个镜像,每个镜像有不同的标签。 仓库分为公开仓库和私有仓库两种形式,最大的公开仓库是 DockerHub,存放了数量庞大的镜像供用户下载,国内的公开仓库有阿里云、网易云等 +仓库是集中存放镜像文件的场所。仓库和仓库注册服务器是有区别的,仓库注册服务器上往往存放着多个仓库,每个仓库中又包含了多个镜像,每个镜像有不同的标签。仓库分为公开仓库和私有仓库两种形式,最常见的公开仓库是 Docker Hub,存放了大量可直接下载的镜像。 ### 总结 @@ -143,30 +143,30 @@ systemctl enable docker ## Docker 初体验 -下面我们来对 Docker 进行一个初步的使用,这里以下载一个 MySQL 的镜像为例`(在CentOS7下进行)`。 +下面我们来对 Docker 进行一个初步的使用,这里以下载一个 MySQL 镜像为例。 -和 GitHub 一样,Docker 也提供了一个 DockerHub 用于查询各种镜像的地址和安装教程,为此,我们先访问 DockerHub:[https://hub.docker.com/](https://hub.docker.com/) +和 GitHub 一样,Docker 也提供了 Docker Hub 用于查询各种镜像的地址和使用说明。我们先访问 Docker Hub:[https://hub.docker.com/](https://hub.docker.com/) -![DockerHub](https://oss.javaguide.cn/github/javaguide/tools/docker/dockerhub-com.png) +![Docker Hub](https://oss.javaguide.cn/github/javaguide/tools/docker/dockerhub-com.png) -在左上角的搜索框中输入`MySQL`并回车: +在左上角的搜索框中输入 `mysql` 并回车: -![DockerHub 搜索 MySQL](https://oss.javaguide.cn/github/javaguide/tools/docker/dockerhub-mysql.png) +![Docker Hub 搜索 MySQL](https://oss.javaguide.cn/github/javaguide/tools/docker/dockerhub-mysql.png) -可以看到相关 MySQL 的镜像非常多,若右上角有`OFFICIAL IMAGE`标识,则说明是官方镜像,所以我们点击第一个 MySQL 镜像: +可以看到相关 MySQL 的镜像非常多,若右上角有 `OFFICIAL IMAGE` 标识,则说明是官方镜像,所以我们点击第一个 MySQL 镜像: ![MySQL 官方镜像](https://oss.javaguide.cn/github/javaguide/tools/docker/dockerhub-mysql-official-image.png) -右边提供了下载 MySQL 镜像的指令为`docker pull MySQL`,但该指令始终会下载 MySQL 镜像的最新版本。 +右边提供了下载 MySQL 镜像的指令为 `docker pull mysql`,但该指令会拉取默认标签对应的版本。实际项目中更建议显式指定版本标签,避免环境不可控。 若是想下载指定版本的镜像,则点击下面的`View Available Tags`: ![查看其他版本的 MySQL](https://oss.javaguide.cn/github/javaguide/tools/docker/dockerhub-mysql-view-available-tags.png) -这里就可以看到各种版本的镜像,右边有下载的指令,所以若是想下载 5.7.32 版本的 MySQL 镜像,则执行: +这里就可以看到各种版本的镜像,右边有下载指令。比如想下载 8.4 版本的 MySQL 镜像,可以执行: ```shell -docker pull MySQL:5.7.32 +docker pull mysql:8.4 ``` 然而下载镜像的过程是非常慢的,所以我们需要配置一下镜像源加速下载,访问`阿里云`官网,点击控制台: @@ -199,7 +199,7 @@ Docker 需要频繁地操作相关的镜像,所以我们先来了解一下 Doc ```shell [root@izrcf5u3j3q8xaz ~]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE -MySQL 5.7.32 f07dfa83b528 11 days ago 448MB +mysql 8.4 f07dfa83b528 11 days ago 448MB tomcat latest feba8d001e3f 2 weeks ago 649MB nginx latest ae2feff98a0c 2 weeks ago 133MB hello-world latest bf756fb1ae65 12 months ago 13.3kB @@ -210,17 +210,16 @@ hello-world latest bf756fb1ae65 12 months ago 13.3kB 该指令能够查询指定镜像名: ```shell -docker image MySQL +docker images mysql ``` 若如此做,则会查询出 Docker 中的所有 MySQL 镜像: ```shell -[root@izrcf5u3j3q8xaz ~]# docker images MySQL +[root@izrcf5u3j3q8xaz ~]# docker images mysql REPOSITORY TAG IMAGE ID CREATED SIZE -MySQL 5.6 0ebb5600241d 11 days ago 302MB -MySQL 5.7.32 f07dfa83b528 11 days ago 448MB -MySQL 5.5 d404d78aa797 20 months ago 205MB +mysql 8.4 0ebb5600241d 11 days ago 589MB +mysql 8.0 f07dfa83b528 11 days ago 596MB ``` 该指令还能够携带`-q`参数:`docker images -q` , `-q`表示仅显示镜像的 id: @@ -236,33 +235,33 @@ d404d78aa797 若是要下载镜像,则使用: ```shell -docker pull MySQL:5.7 +docker pull mysql:8.4 ``` -`docker pull`是固定的,后面写上需要下载的镜像名及版本标志;若是不写版本标志,而是直接执行`docker pull MySQL`,则会下载镜像的最新版本。 +`docker pull` 是固定命令,后面写上需要下载的镜像名及版本标签;若是不写版本标签,而是直接执行 `docker pull mysql`,Docker 会拉取默认标签对应的版本。 一般在下载镜像前我们需要搜索一下镜像有哪些版本才能对指定版本进行下载,使用指令: ```shell -docker search MySQL +docker search mysql ``` ![](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-search-mysql-terminal.png) -不过该指令只能查看 MySQL 相关的镜像信息,而不能知道有哪些版本,若想知道版本,则只能这样查询: +不过,`docker search` 只能搜索镜像仓库,不能列出某个镜像的全部标签。想查看 MySQL 支持哪些版本,建议直接去 Docker Hub 的 Tags 页面查看。 ```shell -docker search MySQL:5.5 +docker pull mysql:8.4 ``` -若是查询的版本不存在,则结果为空: +如果标签不存在,执行 `docker pull` 时会返回类似 `manifest unknown` 的错误: ![](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-search-mysql-404-terminal.png) 删除镜像使用指令: ```shell -docker image rm MySQL:5.5 +docker image rm mysql:8.4 ``` 若是不指定版本,则默认删除的也是最新版本。 @@ -290,13 +289,13 @@ docker image rm -f bf756fb1ae65 Docker 还提供了删除镜像的简化版本:`docker rmi 镜像名:版本标志` 。 -此时我们即可借助`rmi`和`-q`进行一些联合操作,比如现在想删除所有的 MySQL 镜像,那么你需要查询出 MySQL 镜像的 id,并根据这些 id 一个一个地执行`docker rmi`进行删除,但是现在,我们可以这样: +此时我们即可借助 `rmi` 和 `-q` 进行一些联合操作。比如现在想删除所有的 MySQL 镜像,需要查询出 MySQL 镜像的 ID,并根据这些 ID 一个一个地执行 `docker rmi` 删除。也可以这样: ```shell -docker rmi -f $(docker images MySQL -q) +docker rmi -f $(docker images mysql -q) ``` -首先通过`docker images MySQL -q`查询出 MySQL 的所有镜像 id,`-q`表示仅查询 id,并将这些 id 作为参数传递给`docker rmi -f`指令,这样所有的 MySQL 镜像就都被删除了。 +首先通过 `docker images mysql -q` 查询出 MySQL 的所有镜像 ID,`-q` 表示仅查询 ID,并将这些 ID 作为参数传递给 `docker rmi -f` 指令,这样所有的 MySQL 镜像就都被删除了。 ## Docker 容器指令 @@ -567,13 +566,13 @@ public class HelloServlet extends HttpServlet { ![](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-data-volume-webapp-8080-hello-world.png) -这种方式设置的数据卷称为自定义数据卷,因为数据卷的目录是由我们自己设置的,Docker 还为我们提供了另外一种设置数据卷的方式: +这种方式通常称为绑定挂载(bind mount),因为宿主机目录由我们自己指定。Docker 还提供了另一种更常见的数据卷方式:命名卷(named volume)。 ```shell docker run -d -p 8080:8080 --name tomcat01 -v aa:/usr/local/tomcat/webapps tomcat:8.0-jre8 ``` -此时的`aa`并不是数据卷的目录,而是数据卷的别名,Docker 会为我们自动创建一个名为`aa`的数据卷,并且会将容器内`webapps`目录下的所有内容复制到数据卷中,该数据卷的位置在`/var/lib/docker/volumes`目录下: +此时的 `aa` 并不是宿主机目录,而是数据卷名称。Docker 会自动创建一个名为 `aa` 的数据卷,并且会将容器内 `webapps` 目录下的已有内容复制到数据卷中。默认情况下,Docker 管理的数据卷位于 `/var/lib/docker/volumes` 目录下: ```shell [root@centos-7 volumes]# pwd @@ -586,7 +585,7 @@ _data docs examples host-manager manager ROOT ``` -此时我们只需修改该目录的内容就能能够影响到容器。 +此时我们只需修改该目录的内容,就能影响到容器。不过,实际项目中不建议直接修改 `/var/lib/docker/volumes` 下的文件,优先通过容器、应用程序或者明确的绑定挂载目录来管理数据。 --- @@ -603,7 +602,7 @@ docker commit -m "描述信息" -a "镜像作者" tomcat01 my_tomcat:1.0 REPOSITORY TAG IMAGE ID CREATED SIZE my_tomcat 1.0 79ab047fade5 2 seconds ago 463MB tomcat 8 a041be4a5ba5 2 weeks ago 533MB -MySQL latest db2b37ec6181 2 months ago 545MB +mysql 8.4 db2b37ec6181 2 months ago 589MB ``` 若是想将镜像备份出来,则可以使用指令: @@ -636,4 +635,27 @@ REPOSITORY TAG IMAGE ID CREATED my_tomcat 1.0 79ab047fade5 7 minutes ago 463MB ``` +## 常见排查命令 + +Docker 上手之后,真正经常用到的是排查命令。下面这些命令建议熟悉: + +```shell +# 查看容器启动参数、网络、挂载目录和环境变量 +docker inspect tomcat01 + +# 查看最近的容器日志 +docker logs --tail=100 tomcat01 + +# 持续查看容器日志 +docker logs -f tomcat01 + +# 查看容器资源占用 +docker stats + +# 查看 Docker 占用的磁盘空间 +docker system df +``` + +清理资源时要小心,尤其是带 `-f` 的命令。`docker system prune` 会删除未使用的容器、网络、镜像和构建缓存,如果加上 `--volumes`,还会清理未使用的数据卷,数据库、本地测试数据都可能被删掉。 + diff --git a/docs/tools/docker/docker-intro.md b/docs/tools/docker/docker-intro.md index 426a83c7b53..a8603a0e88b 100644 --- a/docs/tools/docker/docker-intro.md +++ b/docs/tools/docker/docker-intro.md @@ -1,5 +1,5 @@ --- -title: Docker核心概念总结 +title: Docker 核心概念总结 description: 梳理 Docker 的核心概念与容器/虚拟机差异,掌握镜像、容器与仓库的关系及在交付部署中的实际价值。 category: 开发工具 tag: @@ -10,13 +10,13 @@ head: content: Docker,容器,镜像,仓库,引擎,隔离,虚拟机对比,部署 --- -本文只是对 Docker 的概念做了较为详细的介绍,并不涉及一些像 Docker 环境的安装以及 Docker 的一些常见操作和命令。 +本文主要讲 Docker 的核心概念、运行模型和常见使用场景,不展开安装过程。安装、命令练习和本地服务启动可以看后面的 [Docker 实战](./docker-in-action.md)。 ## 容器介绍 -**Docker 是世界领先的软件容器平台**,所以想要搞懂 Docker 的概念我们必须先从容器开始说起。 +Docker 是常见的软件容器平台。想要搞懂 Docker,先要理解容器解决的到底是什么问题。 -### 什么是容器? +### 什么是容器? #### 先来看看容器较为官方的解释 @@ -32,7 +32,7 @@ head: ![认识容器](https://oss.javaguide.cn/github/javaguide/tools/docker/container.png) -### 图解物理机,虚拟机与容器 +### 图解物理机、虚拟机与容器 关于虚拟机与容器的对比在后面会详细介绍到,这里只是通过网上的图片加深大家对于物理机、虚拟机与容器这三者的理解(下面的图片来源于网络)。 @@ -76,13 +76,13 @@ head: ## Docker 介绍 -### 什么是 Docker? +### 什么是 Docker? -说实话关于 Docker 是什么并不太好说,下面我通过四点向你说明 Docker 到底是个什么东西。 +可以从下面几个角度理解 Docker: -- **Docker 是世界领先的软件容器平台。** -- **Docker** 使用 Google 公司推出的 **Go 语言** 进行开发实现,基于 **Linux 内核** 提供的 CGroup 功能和 namespace 来实现的,以及 AUFS 类的 **UnionFS** 等技术,**对进程进行封装隔离,属于操作系统层面的虚拟化技术。** 由于隔离的进程独立于宿主和其它的隔离的进程,因此也称其为容器。 -- Docker 能够自动执行重复性任务,例如搭建和配置开发环境,从而解放了开发人员以便他们专注在真正重要的事情上:构建杰出的软件。 +- **Docker 是一个软件容器平台。** +- **Docker** 使用 Go 语言开发,基于 Linux 内核提供的 cgroups、namespaces,以及 UnionFS 等能力对进程进行封装隔离,属于操作系统层面的虚拟化技术。 +- Docker 能够把应用和运行依赖打包到镜像中,减少开发、测试、部署环境不一致带来的问题。 - 用户可以方便地创建和使用容器,把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改,就像管理普通的代码一样。 **Docker 思想**: @@ -116,7 +116,7 @@ Docker 中有非常重要的三个基本概念:镜像(Image)、容器(Co ![](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-build-run.jpeg) -### 镜像(Image):一个特殊的文件系统 +### 镜像(Image):一个特殊的文件系统 **操作系统分为内核和用户空间**。对于 Linux 而言,内核启动后,会挂载 root 文件系统为其提供用户空间支持。而 Docker 镜像(Image),就相当于是一个 root 文件系统。 @@ -128,7 +128,7 @@ Docker 设计时,就充分利用 **Union FS** 的技术,将其设计为**分 分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层,然后进一步添加新的层,以定制自己所需的内容,构建新的镜像。 -### 容器(Container):镜像运行时的实体 +### 容器(Container):镜像运行时的实体 镜像(Image)和容器(Container)的关系,就像是面向对象程序设计中的 类 和 实例 一样,镜像是静态的定义,**容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等** 。 @@ -136,15 +136,15 @@ Docker 设计时,就充分利用 **Union FS** 的技术,将其设计为**分 **容器存储层的生存周期和容器一样,容器消亡时,容器存储层也随之消亡。因此,任何保存于容器存储层的信息都会随容器删除而丢失。** -按照 Docker 最佳实践的要求,**容器不应该向其存储层内写入任何数据** ,容器存储层要保持无状态化。**所有的文件写入操作,都应该使用数据卷(Volume)、或者绑定宿主目录**,在这些位置的读写会跳过容器存储层,直接对宿主(或网络存储)发生读写,其性能和稳定性更高。数据卷的生存周期独立于容器,容器消亡,数据卷不会消亡。因此, **使用数据卷后,容器可以随意删除、重新 run ,数据却不会丢失。** +按照 Docker 最佳实践的要求,**容器不应该向其存储层内写入业务数据**,容器存储层要尽量保持无状态。**需要持久化的文件写入,应该使用数据卷(Volume)或者绑定宿主目录**,这类读写会绕过容器存储层,直接落到宿主机或网络存储上,性能和稳定性更好。数据卷的生命周期独立于容器,容器删除后,数据卷不会自动删除。 -### 仓库(Repository):集中存放镜像文件的地方 +### 仓库(Repository):集中存放镜像文件的地方 镜像构建完成后,可以很容易的在当前宿主上运行,但是, **如果需要在其它服务器上使用这个镜像,我们就需要一个集中的存储、分发镜像的服务,Docker Registry 就是这样的服务。** 一个 Docker Registry 中可以包含多个仓库(Repository);每个仓库可以包含多个标签(Tag);每个标签对应一个镜像。所以说:**镜像仓库是 Docker 用来集中存放镜像文件的地方类似于我们之前常用的代码仓库。** -通常,**一个仓库会包含同一个软件不同版本的镜像**,而**标签就常用于对应该软件的各个版本** 。我们可以通过`<仓库名>:<标签>`的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签,将以 latest 作为默认标签.。 +通常,**一个仓库会包含同一个软件不同版本的镜像**,而**标签就常用于对应这个软件的各个版本**。我们可以通过 `<仓库名>:<标签>` 的格式指定具体镜像。如果不给出标签,将以 `latest` 作为默认标签。不过在生产环境中不建议依赖 `latest`,最好明确指定版本标签,便于回滚和排查问题。 **这里补充一下 Docker Registry 公开服务和私有 Docker Registry 的概念:** @@ -156,7 +156,7 @@ Docker 设计时,就充分利用 **Union FS** 的技术,将其设计为**分 比如我们想要搜索自己想要的镜像: -![利用Docker Hub 搜索镜像](https://oss.javaguide.cn/github/javaguide/tools/docker/Screen%20Shot%202019-11-04%20at%208.21.39%20PM.png) +![利用 Docker Hub 搜索镜像](https://oss.javaguide.cn/github/javaguide/tools/docker/Screen%20Shot%202019-11-04%20at%208.21.39%20PM.png) 在 Docker Hub 的搜索结果中,有几项关键的信息有助于我们选择合适的镜像: @@ -174,7 +174,7 @@ mariadb MariaDB is a community-developed fork of MyS mysql/mysql-server Optimized MySQL Server Docker images. Create… 650 [OK] ``` -在国内访问 **Docker Hub** 可能会比较慢国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 [时速云镜像库](https://www.tenxcloud.com/ "时速云镜像库")、[网易云镜像服务](https://www.163yun.com/product/repo "网易云镜像服务")、[DaoCloud 镜像市场](https://www.daocloud.io/ "DaoCloud 镜像市场")、[阿里云镜像库](https://www.aliyun.com/product/containerservice?utm_content=se_1292836 "阿里云镜像库")等。 +在国内访问 **Docker Hub** 可能会比较慢,企业项目通常会结合公司内部镜像仓库或云厂商镜像仓库来做镜像缓存和分发。 除了使用公开服务外,用户还可以在 **本地搭建私有 Docker Registry** 。Docker 官方提供了 Docker Registry 镜像,可以直接使用做为私有 Registry 服务。开源的 Docker Registry 镜像只提供了 Docker Registry API 的服务端实现,足以支持 Docker 命令,不影响使用。但不包含图形界面,以及镜像维护、用户管理、访问控制等高级功能。 @@ -189,7 +189,7 @@ mysql/mysql-server Optimized MySQL Server Docker images. Create - `docker run` 命令可以从本地镜像创建一个新的容器并启动它。如果本地没有镜像,Docker 会先尝试从 Registry/Hub 拉取镜像。 - `docker push` 命令可以将本地的 Docker 镜像上传到指定的 Registry/Hub。 -上面涉及到了一些 Docker 的基本命令,后面会详细介绍大。 +上面涉及到了一些 Docker 基本命令,后面的实战文章会详细介绍。 ### Build Ship and Run @@ -210,20 +210,20 @@ Docker 运行过程也就是去仓库把镜像拉到本地,然后用一条命 ### 基本命令 ```bash -docker version # 查看docker版本 +docker version # 查看 Docker 版本 docker images # 查看所有已下载镜像,等价于:docker image ls 命令 docker container ls # 查看所有容器 -docker ps #查看正在运行的容器 -docker image prune # 清理临时的、没有被使用的镜像文件。-a, --all: 删除所有没有用的镜像,而不仅仅是临时文件; +docker ps # 查看正在运行的容器 +docker image prune # 清理没有被使用的镜像文件。-a/--all 会删除所有未被容器使用的镜像 ``` ### 拉取镜像 -`docker pull` 命令默认使用的 Registry/Hub 是 Docker Hub。当你执行 docker pull 命令而没有指定任何 Registry/Hub 的地址时,Docker 会从 Docker Hub 拉取镜像。 +`docker pull` 命令默认使用的 Registry 是 Docker Hub。当你执行 `docker pull` 命令而没有指定任何 Registry 地址时,Docker 会从 Docker Hub 拉取镜像。 ```bash -docker search mysql # 查看mysql相关镜像 -docker pull mysql:5.7 # 拉取mysql镜像 +docker search mysql # 查看 MySQL 相关镜像 +docker pull mysql:8.4 # 拉取 MySQL 镜像 docker image ls # 查看所有已下载镜像 ``` @@ -232,18 +232,17 @@ docker image ls # 查看所有已下载镜像 运行 `docker build`命令并指定一个 Dockerfile 时,Docker 会读取 Dockerfile 中的指令,逐步构建一个新的镜像,并将其保存在本地。 ```bash -# -# imageName 是镜像名称,1.0.0 是镜像的版本号或标签 -docker build -t imageName:1.0.0 . +# image-name 是镜像名称,1.0.0 是镜像版本号或标签 +docker build -t image-name:1.0.0 . ``` 需要注意:Dockerfile 的文件名不必须为 Dockerfile,也不一定要放在构建上下文的根目录中。使用 `-f` 或 `--file` 选项,可以指定任何位置的任何文件作为 Dockerfile。当然,一般大家习惯性的会使用默认的文件名 `Dockerfile`,以及会将其置于镜像构建上下文目录中。 ### 删除镜像 -比如我们要删除我们下载的 mysql 镜像。 +比如我们要删除已经下载的 MySQL 镜像。 -通过 `docker rmi [image]` (等价于`docker image rm [image]`)删除镜像之前首先要确保这个镜像没有被容器引用(可以通过标签名称或者镜像 ID 删除)。通过我们前面讲的`docker ps`命令即可查看。 +通过 `docker rmi [image]`(等价于 `docker image rm [image]`)删除镜像之前,首先要确保这个镜像没有被容器引用。可以通过标签名称或者镜像 ID 删除,也可以通过前面讲的 `docker ps` 命令查看是否有容器正在使用它。 ```shell ➜ ~ docker ps @@ -251,9 +250,9 @@ CONTAINER ID IMAGE COMMAND CREATED c4cd691d9f80 mysql:5.7 "docker-entrypoint.s…" 7 weeks ago Up 12 days 0.0.0.0:3306->3306/tcp, 33060/tcp mysql ``` -可以看到 mysql 正在被 id 为 c4cd691d9f80 的容器引用,我们需要首先通过 `docker stop c4cd691d9f80` 或者 `docker stop mysql`暂停这个容器。 +可以看到 `mysql:5.7` 正在被 ID 为 `c4cd691d9f80` 的容器引用,需要先通过 `docker stop c4cd691d9f80` 或者 `docker stop mysql` 暂停这个容器。 -然后查看 mysql 镜像的 id +然后查看 MySQL 镜像的 ID: ```shell ➜ ~ docker images @@ -261,10 +260,10 @@ REPOSITORY TAG IMAGE ID CREATED mysql 5.7 f6509bac4980 3 months ago 373MB ``` -通过 IMAGE ID 或者 REPOSITORY 名字即可删除 +通过 `IMAGE ID` 或者 `REPOSITORY:TAG` 即可删除: ```shell -docker rmi f6509bac4980 # 或者 docker rmi mysql +docker rmi f6509bac4980 # 或者 docker rmi mysql:5.7 ``` ### 镜像推送 @@ -273,7 +272,7 @@ docker rmi f6509bac4980 # 或者 docker rmi mysql ```bash # 将镜像推送到私有镜像仓库 Harbor -# harbor.example.com是私有镜像仓库的地址,ubuntu是镜像的名称,18.04是镜像的版本标签 +# harbor.example.com 是私有镜像仓库的地址,ubuntu 是镜像名称,18.04 是镜像版本标签 docker push harbor.example.com/ubuntu:18.04 ``` @@ -301,7 +300,7 @@ docker volume create my-vol # 查看所有的数据卷 docker volume ls # 查看数据卷的具体信息 -docker inspect web +docker volume inspect my-vol # 删除指定的数据卷 docker volume rm my-vol ``` @@ -314,7 +313,7 @@ docker volume rm my-vol ### 什么是 Docker Compose?有什么用? -Docker Compose 是 Docker 官方编排(Orchestration)项目之一,基于 Python 编写,负责实现对 Docker 容器集群的快速编排。通过 Docker Compose,开发者可以使用 YAML 文件来配置应用的所有服务,然后只需一个简单的命令即可创建和启动所有服务。 +Docker Compose 是 Docker 官方提供的多容器应用定义和运行工具。通过 Compose,开发者可以使用一个 YAML 文件描述应用依赖的多个服务、网络、端口和数据卷,然后用一条命令启动或停止整组服务。 Docker Compose 是开源项目,地址:。 @@ -322,131 +321,131 @@ Docker Compose 的核心功能: - **多容器管理**:允许用户在一个 YAML 文件中定义和管理多个容器。 - **服务编排**:配置容器间的网络和依赖关系。 -- **一键部署**:通过简单的命令,如`docker-compose up`和`docker-compose down`,可以轻松地启动和停止整个应用程序。 +- **一键启动与停止**:通过 `docker compose up` 和 `docker compose down` 等命令,可以轻松启动和停止整个应用。 Docker Compose 简化了多容器应用程序的开发、测试和部署过程,提高了开发团队的生产力,同时降低了应用程序的部署复杂度和管理成本。 ### Docker Compose 文件基本结构 -Docker Compose 文件是 Docker Compose 工具的核心,用于定义和配置多容器 Docker 应用。这个文件通常命名为 `docker-compose.yml`,采用 YAML(YAML Ain't Markup Language)格式编写。 +Docker Compose 文件是 Docker Compose 工具的核心,用于定义和配置多容器 Docker 应用。这个文件通常命名为 `compose.yaml` 或 `docker-compose.yml`,采用 YAML(YAML Ain't Markup Language)格式编写。 Docker Compose 文件基本结构如下: -- **版本(version):** 指定 Compose 文件格式的版本。版本决定了可用的配置选项。 - **服务(services):** 定义了应用中的每个容器(服务)。每个服务可以使用不同的镜像、环境设置和依赖关系。 - **镜像(image):** 从指定的镜像中启动容器,可以是存储仓库、标签以及镜像 ID。 - **命令(command):** 可选,覆盖容器启动后默认执行的命令。在启动服务时运行特定的命令或脚本,常用于启动应用程序、执行初始化脚本等。 - **端口(ports):** 可选,映射容器和宿主机的端口。 - - **依赖(depends_on):** 依赖配置的选项,意思是如果服务启动是如果有依赖于其他服务的,先启动被依赖的服务,启动完成后在启动该服务。 + - **依赖(depends_on):** 配置服务之间的启动依赖关系。例如后端服务依赖数据库服务时,可以先启动数据库,再启动后端服务。 - **环境变量(environment):** 可选,设置服务运行所需的环境变量。 - **重启(restart):** 可选,控制容器的重启策略。在容器退出时,根据指定的策略自动重启容器。 - **服务卷(volumes):** 可选,定义服务使用的卷,用于数据持久化或在容器之间共享数据。 - - **构建(build):** 指定构建镜像的 dockerfile 的上下文路径,或者详细配置对象。 + - **构建(build):** 指定构建镜像的 Dockerfile 上下文路径,或者使用详细配置对象。 - **网络(networks):** 定义了容器间的网络连接。 - **卷(volumes):** 用于数据持久化和共享的数据卷定义。常用于数据库存储、配置文件、日志等数据的持久化。 ```yaml -version: "3.8" # 定义版本, 表示当前使用的 docker-compose 语法的版本 -services: # 服务,可以存在多个 - servicename1: # 服务名字,它也是内部 bridge 网络可以使用的 DNS name,如果不是集群模式相当于 docker run 的时候指定的一个名称, - #集群(Swarm)模式是多个容器的逻辑抽象 - image: # 镜像的名字 - command: # 可选,如果设置,则会覆盖默认镜像里的 CMD 命令 - environment: # 可选,等价于 docker container run 里的 --env 选项设置环境变量 - volumes: # 可选,等价于 docker container run 里的 -v 选项 绑定数据卷 - networks: # 可选,等价于 docker container run 里的 --network 选项指定网络 - ports: # 可选,等价于 docker container run 里的 -p 选项指定端口映射 - restart: # 可选,控制容器的重启策略 - build: #构建目录 - depends_on: #服务依赖配置 - servicename2: - image: - command: - networks: - ports: - servicename3: - #... -volumes: # 可选,需要创建的数据卷,类似 docker volume create - db_data: -networks: # 可选,等价于 docker network create +services: + service-name-1: + image: nginx:stable + command: ["nginx", "-g", "daemon off;"] + environment: + TZ: Asia/Shanghai + volumes: + - web_data:/usr/share/nginx/html + networks: + - app_net + ports: + - "8080:80" + restart: unless-stopped + depends_on: + - service-name-2 + service-name-2: + image: redis:7 + networks: + - app_net + +volumes: + web_data: + +networks: + app_net: ``` ### Docker Compose 常见命令 #### 启动 -`docker-compose up`会根据 `docker-compose.yml` 文件中定义的服务来创建和启动容器,并将它们连接到默认的网络中。 +`docker compose up` 会根据 Compose 文件中定义的服务创建并启动容器,并将它们连接到 Compose 创建的网络中。如果文件没有声明自定义网络,Compose 会自动创建默认网络。 ```bash -# 在当前目录下寻找 docker-compose.yml 文件,并根据其中定义的服务启动应用程序 -docker-compose up +# 在当前目录下寻找 compose.yaml 或 docker-compose.yml 文件,并根据其中定义的服务启动应用 +docker compose up # 后台启动 -docker-compose up -d +docker compose up -d # 强制重新创建所有容器,即使它们已经存在 -docker-compose up --force-recreate +docker compose up --force-recreate # 重新构建镜像 -docker-compose up --build +docker compose up --build # 指定要启动的服务名称,而不是启动所有服务 # 可以同时指定多个服务,用空格分隔。 -docker-compose up service_name +docker compose up service-name ``` -另外,如果 Compose 文件名称不是 `docker-compose.yml` 也没问题,可以通过 `-f` 参数指定。 +另外,如果 Compose 文件名称不是 `compose.yaml` 或 `docker-compose.yml`,可以通过 `-f` 参数指定。 ```bash -docker-compose -f docker-compose.prod.yml up +docker compose -f compose.prod.yaml up ``` #### 暂停 -`docker-compose down`用于停止并移除通过 `docker-compose up` 启动的容器和网络。 +`docker compose down` 用于停止并移除通过 `docker compose up` 启动的容器和网络。 ```bash -# 在当前目录下寻找 docker-compose.yml 文件 -# 根据其中定义移除启动的所有容器,网络和卷。 -docker-compose down +# 在当前目录下寻找 Compose 文件 +# 根据其中定义移除启动的容器和网络 +docker compose down # 停止容器但不移除 -docker-compose down --stop -# 指定要停止和移除的特定服务,而不是停止和移除所有服务 -# 可以同时指定多个服务,用空格分隔。 -docker-compose down service_name +docker compose stop +# 停止指定服务 +docker compose stop service-name ``` -同样地,如果 Compose 文件名称不是 `docker-compose.yml` 也没问题,可以通过 `-f` 参数指定。 +同样地,如果 Compose 文件名称不是 `compose.yaml` 或 `docker-compose.yml`,可以通过 `-f` 参数指定。 ```bash -docker-compose -f docker-compose.prod.yml down +docker compose -f compose.prod.yaml down ``` #### 查看 -`docker-compose ps`用于查看通过 `docker-compose up` 启动的所有容器的状态信息。 +`docker compose ps` 用于查看通过 `docker compose up` 启动的所有容器的状态信息。 ```bash # 查看所有容器的状态信息 -docker-compose ps +docker compose ps # 只显示服务名称 -docker-compose ps --services +docker compose ps --services # 查看指定服务的容器 -docker-compose ps service_name +docker compose ps service-name ``` #### 其他 | 命令 | 介绍 | | ------------------------ | ---------------------- | -| `docker-compose version` | 查看版本 | -| `docker-compose images` | 列出所有容器使用的镜像 | -| `docker-compose kill` | 强制停止服务的容器 | -| `docker-compose exec` | 在容器中执行命令 | -| `docker-compose logs` | 查看日志 | -| `docker-compose pause` | 暂停服务 | -| `docker-compose unpause` | 恢复服务 | -| `docker-compose push` | 推送服务镜像 | -| `docker-compose start` | 启动当前停止的某个容器 | -| `docker-compose stop` | 停止当前运行的某个容器 | -| `docker-compose rm` | 删除服务停止的容器 | -| `docker-compose top` | 查看进程 | +| `docker compose version` | 查看版本 | +| `docker compose images` | 列出所有容器使用的镜像 | +| `docker compose kill` | 强制停止服务的容器 | +| `docker compose exec` | 在容器中执行命令 | +| `docker compose logs` | 查看日志 | +| `docker compose pause` | 暂停服务 | +| `docker compose unpause` | 恢复服务 | +| `docker compose push` | 推送服务镜像 | +| `docker compose start` | 启动当前停止的服务 | +| `docker compose stop` | 停止当前运行的服务 | +| `docker compose rm` | 删除已停止的服务容器 | +| `docker compose top` | 查看进程 | ## Docker 底层原理 @@ -454,7 +453,7 @@ docker-compose ps service_name 简单点来说,虚拟化技术可以这样定义: -> 虚拟化技术是一种资源管理技术,是将计算机的各种[实体资源](https://zh.wikipedia.org/wiki/計算機科學 "实体资源"))([CPU](https://zh.wikipedia.org/wiki/CPU "CPU")、[内存](https://zh.wikipedia.org/wiki/内存 "内存")、[磁盘空间](https://zh.wikipedia.org/wiki/磁盘空间 "磁盘空间")、[网络适配器](https://zh.wikipedia.org/wiki/網路適配器 "网络适配器")等),予以抽象、转换后呈现出来并可供分割、组合为一个或多个电脑配置环境。由此,打破实体结构间的不可切割的障碍,使用户可以比原本的配置更好的方式来应用这些电脑硬件资源。这些资源的新虚拟部分是不受现有资源的架设方式,地域或物理配置所限制。一般所指的虚拟化资源包括计算能力和数据存储。 +> 虚拟化技术是一种资源管理技术,是将计算机的各种[实体资源](https://zh.wikipedia.org/wiki/計算機科學)([CPU](https://zh.wikipedia.org/wiki/CPU)、[内存](https://zh.wikipedia.org/wiki/内存)、[磁盘空间](https://zh.wikipedia.org/wiki/磁盘空间)、[网络适配器](https://zh.wikipedia.org/wiki/網路適配器)等),予以抽象、转换后呈现出来并可供分割、组合为一个或多个电脑配置环境。由此,打破实体结构间的不可切割的障碍,使用户可以比原本的配置更好的方式来应用这些电脑硬件资源。这些资源的新虚拟部分是不受现有资源的架设方式,地域或物理配置所限制。一般所指的虚拟化资源包括计算能力和数据存储。 Docker 技术是基于 LXC(Linux container- Linux 容器)虚拟容器技术的。 @@ -480,15 +479,15 @@ LXC 技术主要是借助 Linux 内核中提供的 CGroup 功能和 namespace 本文主要把 Docker 中的一些常见概念和命令做了详细的阐述。从零到上手实战可以看[Docker 从入门到上手干事](https://javaguide.cn/tools/docker/docker-in-action.html)这篇文章,内容非常详细! -另外,再给大家推荐一本质量非常高的开源书籍[《Docker 从入门到实践》](https://yeasy.gitbook.io/docker_practice/introduction/why "《Docker 从入门到实践》") ,这本书的内容非常新,毕竟书籍的内容是开源的,可以随时改进。 +另外,再给大家推荐一本质量非常高的开源书籍[《Docker 从入门到实践》](https://yeasy.gitbook.io/docker_practice/introduction/why) ,这本书的内容非常新,毕竟书籍的内容是开源的,可以随时改进。 ![《Docker 从入门到实践》网站首页](https://oss.javaguide.cn/github/javaguide/tools/docker/docker-getting-started-practice-website-homepage.png) ## 参考 - [Docker Compose:从零基础到实战应用的全面指南](https://juejin.cn/post/7306756690727747610) -- [Linux Namespace 和 Cgroup](https://segmentfault.com/a/1190000009732550 "Linux Namespace和Cgroup") +- [Linux Namespace 和 Cgroup](https://segmentfault.com/a/1190000009732550) - [LXC vs Docker: Why Docker is Better](https://www.upguard.com/articles/docker-vs-lxc "LXC vs Docker: Why Docker is Better") -- [CGroup 介绍、应用实例及原理描述](https://www.ibm.com/developerworks/cn/linux/1506_cgroup/index.html "CGroup 介绍、应用实例及原理描述") +- [CGroup 介绍、应用实例及原理描述](https://www.ibm.com/developerworks/cn/linux/1506_cgroup/index.html) diff --git a/docs/tools/git/README.md b/docs/tools/git/README.md index 9dd9090eaf8..e6e4838e974 100644 --- a/docs/tools/git/README.md +++ b/docs/tools/git/README.md @@ -30,18 +30,18 @@ Git 是开发者必须掌握的基础工具。学习 Git 时,不建议只背 - 工作区、暂存区、本地仓库、远程仓库分别对应不同阶段的代码状态。 - 分支让多人并行开发成为可能,合并和冲突处理是团队协作高频场景。 - Git 命令要结合真实流程理解,比如 clone、add、commit、branch、merge、pull、push。 -- GitHub 可以用于代码托管、项目展示、开源协作、代码搜索和个人影响力建设。 +- GitHub 可以用于代码托管、项目展示、开源协作、代码搜索、Actions 自动化和个人影响力建设。 ## 建议阅读顺序 1. [Git 核心概念总结](./git-intro.md):先理解版本控制、Git 数据模型、常用命令、分支和远程协作。 2. 在本地项目中练习一次完整流程:clone、创建分支、提交、合并、解决冲突、推送远程分支。 -3. [GitHub 实用小技巧总结](./github-tips.md):补充 GitHub 个人主页、项目徽章、代码阅读和搜索技巧。 +3. [GitHub 实用小技巧总结](./github-tips.md):补充 GitHub 个人主页、项目徽章、代码阅读、Actions 和 Explore/Trending 技巧。 ## 核心文章 - [Git 核心概念总结](./git-intro.md):系统介绍版本控制、Git 简史、数据存储方式、工作区、暂存区、提交、分支、合并和常用命令。 -- [GitHub 实用小技巧总结](./github-tips.md):整理 GitHub 简历、个人主页、项目徽章、开源趋势、代码阅读和搜索等实用技巧。 +- [GitHub 实用小技巧总结](./github-tips.md):整理 GitHub 简历、个人主页、项目徽章、开源趋势、代码阅读、Actions 和搜索等实用技巧。 ## 高频问题 @@ -52,7 +52,7 @@ Git 是开发者必须掌握的基础工具。学习 Git 时,不建议只背 - Git 分支的本质是什么?为什么分支切换很快? - merge 和 rebase 有什么区别? - 发生冲突时应该如何定位和解决? -- GitHub Profile README、项目徽章和代码搜索有什么实际价值? +- GitHub Profile README、项目徽章、Codespaces、Actions 和代码搜索有什么实际价值? ## 相关专题 diff --git a/docs/tools/git/git-intro.md b/docs/tools/git/git-intro.md index 66de9bdc3da..701fedc6e1b 100644 --- a/docs/tools/git/git-intro.md +++ b/docs/tools/git/git-intro.md @@ -1,5 +1,5 @@ --- -title: Git核心概念总结 +title: Git 核心概念总结 description: 总结 Git 的核心概念与工作流,涵盖分支与合并、提交管理与冲突解决,助力团队协作与代码质量提升。 category: 开发工具 tag: @@ -109,16 +109,16 @@ Git 有三种状态,你的文件可能处于其中之一: 有两种取得 Git 项目仓库的方法。 -1. 在现有目录中初始化仓库: 进入项目目录运行 `git init` 命令,该命令将创建一个名为 `.git` 的子目录。 -2. 从一个服务器克隆一个现有的 Git 仓库: `git clone [url]` 自定义本地仓库的名字: `git clone [url] directoryname` +1. 在现有目录中初始化仓库:进入项目目录运行 `git init` 命令,该命令会创建一个名为 `.git` 的子目录。 +2. 从一个服务器克隆一个现有的 Git 仓库:`git clone [url]`。如果想自定义本地目录名,可以使用 `git clone [url] directoryname`。 ### 记录每次更新到仓库 1. **检测当前文件状态** : `git status` -2. **提出更改(把它们添加到暂存区**):`git add filename` (针对特定文件)、`git add *`(所有文件)、`git add *.txt`(支持通配符,所有 .txt 文件) +2. **提出更改(把它们添加到暂存区)**:`git add filename`(针对特定文件)、`git add .`(当前目录下所有改动)、`git add *.txt`(支持通配符,所有 `.txt` 文件)。 3. **忽略文件**:`.gitignore` 文件 -4. **提交更新:** `git commit -m "代码提交信息"` (每次准备提交前,先用 `git status` 看下,是不是都已暂存起来了, 然后再运行提交命令 `git commit`) -5. **跳过使用暂存区域更新的方式** : `git commit -a -m "代码提交信息"`。 `git commit` 加上 `-a` 选项,Git 就会自动把所有已经跟踪过的文件暂存起来一并提交,从而跳过 `git add` 步骤。 +4. **提交更新**:`git commit -m "代码提交信息"`。每次准备提交前,先用 `git status` 看一下是否都已暂存。 +5. **跳过使用暂存区域更新的方式**:`git commit -a -m "代码提交信息"`。`git commit` 加上 `-a` 选项,Git 会自动把所有已经跟踪过的文件暂存起来一并提交,从而跳过 `git add` 步骤。 6. **移除文件**:`git rm filename` (从暂存区域移除,然后提交。) 7. **对文件重命名**:`git mv README.md README`(这个命令相当于`mv README.md README`、`git rm README.md`、`git add README` 这三条命令的集合) @@ -138,8 +138,8 @@ Git 有三种状态,你的文件可能处于其中之一: ### 推送改动到远程仓库 -- 如果你还没有克隆现有仓库,并欲将你的仓库连接到某个远程服务器,你可以使用如下命令添加:`git remote add origin ` ,比如我们要让本地的一个仓库和 GitHub 上创建的一个仓库关联可以这样`git remote add origin https://github.com/Snailclimb/test.git` -- 将这些改动提交到远端仓库:`git push origin master` (可以把 _master_ 换成你想要推送的任何分支) +- 如果你还没有克隆现有仓库,并想将你的仓库连接到某个远程服务器,可以使用如下命令添加:`git remote add origin `。比如要让本地仓库和 GitHub 上创建的仓库关联,可以这样写:`git remote add origin https://github.com/Snailclimb/test.git`。 +- 将这些改动提交到远端仓库:`git push origin main`。这里的 `main` 可以换成你想要推送的任何分支。很多老项目的默认分支仍然叫 `master`,以实际仓库为准。 如此你就能够将你的改动推送到所添加的服务器上去了。 @@ -168,13 +168,25 @@ git log --author=bob git commit --amend ``` -取消暂存的文件 +取消暂存的文件: + +```shell +git restore --staged filename +``` + +老版本 Git 也常见下面这种写法: ```shell git reset filename ``` -撤消对文件的修改: +撤消对文件的修改: + +```shell +git restore filename +``` + +老版本 Git 也常见下面这种写法: ```shell git checkout -- filename @@ -184,12 +196,14 @@ git checkout -- filename ```shell git fetch origin -git reset --hard origin/master +git reset --hard origin/main ``` +注意:`git reset --hard` 会丢弃本地未提交改动,执行前一定要确认没有需要保留的内容。老项目如果默认分支是 `master`,对应命令改成 `git reset --hard origin/master`。 + ### 分支 -分支是用来将特性开发绝缘开来的。在你创建仓库的时候,_master_ 是“默认”的分支。在其他分支上进行开发,完成后再将它们合并到主分支上。 +分支是用来隔离不同开发任务的。在其他分支上开发功能或修复问题,完成后再合并回主分支。现在很多仓库默认分支叫 `main`,老项目中也经常能看到 `master`。 我们通常在开发新功能、修复一个紧急 bug 等等时候会选择创建分支。单分支开发好还是多分支开发好,还是要看具体场景来说。 @@ -199,30 +213,34 @@ git reset --hard origin/master git branch test ``` -切换当前分支到 test(当你切换分支的时候,Git 会重置你的工作目录,使其看起来像回到了你在那个分支上最后一次提交的样子。 Git 会自动添加、删除、修改文件以确保此时你的工作目录和这个分支最后一次提交时的样子一模一样) +切换当前分支到 `test`(当你切换分支的时候,Git 会重置你的工作目录,使其看起来像回到了你在那个分支上最后一次提交的样子。Git 会自动添加、删除、修改文件,以确保此时你的工作目录和这个分支最后一次提交时的样子一致)。 ```shell -git checkout test +git switch test ``` +老版本 Git 也常见 `git checkout test` 这种写法。 + ![](https://oss.javaguide.cn/github/javaguide/tools/git/2019-3%E5%88%87%E6%8D%A2%E5%88%86%E6%94%AF.png) -你也可以直接这样创建分支并切换过去(上面两条命令的合写) +你也可以直接这样创建分支并切换过去: ```shell -git checkout -b feature_x +git switch -c feature_x ``` +老版本 Git 也常见 `git checkout -b feature_x` 这种写法。 + 切换到主分支 ```shell -git checkout master +git switch main ``` 合并分支(可能会有冲突) ```shell - git merge test +git merge test ``` 把新建的分支删掉 @@ -234,7 +252,7 @@ git branch -d feature_x 将分支推送到远端仓库(推送成功后其他人可见): ```shell -git push origin +git push origin feature_x ``` ## 学习资料推荐 diff --git a/docs/tools/git/github-tips.md b/docs/tools/git/github-tips.md index f293c846f56..fb4bc1ab67b 100644 --- a/docs/tools/git/github-tips.md +++ b/docs/tools/git/github-tips.md @@ -1,44 +1,42 @@ --- -title: Github实用小技巧总结 -description: 汇总 Github 的高效使用技巧,包括个性化主页、自动简历与统计展示,提升个人品牌与开源协作体验。 +title: GitHub 实用小技巧总结 +description: 汇总 GitHub 的高效使用技巧,包括个人主页、项目徽章、代码阅读、GitHub Actions、Explore/Trending 和开源协作提效方法。 category: 开发工具 tag: - Git head: - - meta - name: keywords - content: Github 技巧,个人主页,README,统计信息,开源贡献,简历 + content: GitHub 技巧,个人主页,README,统计信息,开源贡献,GitHub Actions,代码阅读 --- -我使用 Github 已经有 6 年多了,今天毫无保留地把自己觉得比较有用的 Github 小技巧送给关注 JavaGuide 的各位小伙伴。 +GitHub 不只是代码托管平台。对开发者来说,它同时承担了项目展示、代码阅读、开源协作、自动化构建和个人主页的作用。这篇文章整理一些比较实用的 GitHub 使用技巧。 -## 一键生成 Github 简历 & Github 年报 +## 一键生成 GitHub 简历与 GitHub 年报 -通过 [https://resume.github.io/](https://resume.github.io/) 这个网站你可以一键生成一个在线的 Github 简历。 +通过 [https://resume.github.io/](https://resume.github.io/) 这个网站你可以一键生成一个在线的 GitHub 简历。 -当时我参加的校招的时候,个人信息那里就放了一个在线的 Github 简历。我觉得这样会让面试官感觉你是一个内行,会提高一些印象分。 +不过,简历里是否放 GitHub 链接要看账号内容质量。如果账号里有完整项目、持续维护记录、清晰 README 和比较规范的提交历史,GitHub 链接会加分;如果只有空仓库或者临时练习代码,就没必要强行放。生成后的效果如下图所示。 -但是,如果你的 Github 没有什么项目的话还是不要放在简历里面了。生成后的效果如下图所示。 +![GitHub简历](https://oss.javaguide.cn/2020-11/image-20201108192205620.png) -![Github简历](https://oss.javaguide.cn/2020-11/image-20201108192205620.png) - -通过 这个网站,你可以生成一份 Github 个人年报,这个年报会列举出你在这一年的项目贡献情况、最常使用的编程语言、详细的贡献信息。 +通过 这个网站,你可以生成一份 GitHub 个人年报,这个年报会列举出你在这一年的项目贡献情况、最常使用的编程语言、详细的贡献信息。 ![](https://oss.javaguide.cn/github/dootask/image-20211226144607457.png) -## 个性化 Github 首页 +## 个性化 GitHub 首页 -Github 目前支持在个人主页自定义展示一些内容。展示效果如下图所示。 +GitHub 目前支持在个人主页自定义展示一些内容。展示效果如下图所示。 ![个性化首页展示效果](https://oss.javaguide.cn/java-guide-blog/image-20210616221212259.png) -想要做到这样非常简单,你只需要创建一个和你的 Github 账户同名的仓库,然后自定义`README.md`的内容即可。 +想要做到这样非常简单,你只需要创建一个和你的 GitHub 账户同名的仓库,然后自定义`README.md`的内容即可。 展示在你主页的自定义内容就是`README.md`的内容(_不会 Markdown 语法的小伙伴自行面壁 5 分钟_)。 -![创建一个和你的Github账户同名的仓库](https://oss.javaguide.cn/java-guide-blog/image-20201107110309341.png) +![创建一个和你的GitHub账户同名的仓库](https://oss.javaguide.cn/java-guide-blog/image-20201107110309341.png) -这个也是可以玩出花来的!比如说:通过 [github-readme-stats](https://hellogithub.com/periodical/statistics/click/?target=https://github.com/anuraghazra/github-readme-stats) 这个开源项目,你可以 README 中展示动态生成的 GitHub 统计信息。展示效果如下图所示。 +这个也是可以玩出花来的!比如说:通过 [github-readme-stats](https://hellogithub.com/periodical/statistics/click/?target=https://github.com/anuraghazra/github-readme-stats) 这个开源项目,你可以在 README 中展示动态生成的 GitHub 统计信息。展示效果如下图所示。 ![通过github-readme-stats动态生成GitHub统计信息 ](https://oss.javaguide.cn/java-guide-blog/image-20210616221312426.png) @@ -46,7 +44,7 @@ Github 目前支持在个人主页自定义展示一些内容。展示效果如 ## 自定义项目徽章 -你在 Github 上看到的项目徽章都是通过 [https://shields.io/](https://shields.io/) 这个网站生成的。我的 JavaGuide 这个项目的徽章如下图所示。 +你在 GitHub 上看到的项目徽章都是通过 [https://shields.io/](https://shields.io/) 这个网站生成的。我的 JavaGuide 这个项目的徽章如下图所示。 ![项目徽章](https://oss.javaguide.cn/2020-11/image-20201107143136559.png) @@ -60,25 +58,25 @@ Github 目前支持在个人主页自定义展示一些内容。展示效果如 ## 自动为项目添加贡献情况图标 -通过 repobeats 这个工具可以为 Github 项目添加如下图所示的项目贡献基本情况图表,挺不错的 👍 +通过 repobeats 这个工具可以为 GitHub 项目添加如下图所示的项目贡献基本情况图表。 ![](https://oss.javaguide.cn/github/dootask/repobeats.png) 地址: 。 -## Github 表情 +## GitHub 表情 -![Github表情](https://oss.javaguide.cn/2020-11/image-20201107162254582.png) +![GitHub表情](https://oss.javaguide.cn/2020-11/image-20201107162254582.png) -如果你想要在 Github 使用表情的话,可以在这里找找:[www.webfx.com/tools/emoji-cheat-sheet/](https://www.webfx.com/tools/emoji-cheat-sheet/)。 +如果你想要在 GitHub 使用表情的话,可以在这里找找:[www.webfx.com/tools/emoji-cheat-sheet/](https://www.webfx.com/tools/emoji-cheat-sheet/)。 -![在线Github表情](https://oss.javaguide.cn/2020-11/image-20201107162432941.png) +![在线GitHub表情](https://oss.javaguide.cn/2020-11/image-20201107162432941.png) -## 高效阅读 Github 项目的源代码 +## 高效阅读 GitHub 项目的源代码 -Github 前段时间推出的 Codespaces 可以提供类似 VS Code 的在线 IDE,不过目前还没有完全开发使用。 +GitHub Codespaces 可以提供类似 VS Code 的在线开发环境,适合临时阅读、调试或快速参与开源项目。对于大型项目或需要本地服务依赖的项目,还是建议 clone 到本地,用自己熟悉的 IDE 阅读和调试。 -简单介绍几种我最常用的阅读 Github 项目源代码的方式。 +简单介绍几种常用的 GitHub 项目源码阅读方式。 ### Chrome 插件 Octotree @@ -86,70 +84,72 @@ Github 前段时间推出的 Codespaces 可以提供类似 VS Code 的在线 IDE ![Chrome插件Octotree](https://oss.javaguide.cn/2020-11/image-20201107144944798.png) -### Chrome 插件 SourceGraph +### Sourcegraph -我不想将项目 clone 到本地的时候一般就会使用这种方式来阅读项目源代码。SourceGraph 不仅可以让我们在 Github 优雅的查看代码,它还支持一些骚操作,比如:类之间的跳转、代码搜索等功能。 +不想将项目 clone 到本地时,也可以使用 Sourcegraph 这类代码搜索和阅读工具。Sourcegraph 支持跨仓库代码搜索、引用跳转等功能,阅读大型项目时比较有帮助。 当你下载了这个插件之后,你的项目主页会多出一个小图标如下图所示。点击这个小图标即可在线阅读项目源代码。 ![](https://oss.javaguide.cn/2020-11/image-20201107145749659.png) -使用 SourceGraph 阅读代码的就像下面这样,同样是树形结构展示代码,但是我个人感觉没有 Octotree 的手感舒服。不过,SourceGraph 内置了很多插件,而且还支持类之间的跳转! +使用 Sourcegraph 阅读代码的效果类似下面这样,同样是树形结构展示代码,还支持类之间的跳转。 ![](https://oss.javaguide.cn/2020-11/image-20201107150307314.png) ### 克隆项目到本地 -先把项目克隆到本地,然后使用自己喜欢的 IDE 来阅读。可以说是最酸爽的方式了! +先把项目克隆到本地,然后使用自己喜欢的 IDE 来阅读。想深入理解一个项目,首选这种方式。 -如果你想要深入了解某个项目的话,首选这种方式。一个`git clone` 就完事了。 +```bash +git clone https://github.com/Snailclimb/JavaGuide.git +``` -## 扩展 Github 的功能 +## 扩展 GitHub 的功能 -**Enhanced GitHub** 可以让你的 Github 更好用。这个 Chrome 插件可以可视化你的 Github 仓库大小,每个文件的大小并且可以让你快速下载单个文件。 +**Enhanced GitHub** 可以让你的 GitHub 更好用。这个浏览器插件可以展示仓库大小、文件大小,并支持快速下载单个文件。 ![](https://oss.javaguide.cn/2020-11/image-20201107160817672.png) ## 自动为 Markdown 文件生成目录 -如果你想为 Github 上的 Markdown 文件生成目录的话,通过 VS Code 的 **Markdown Preview Enhanced** 这个插件就可以了。 +如果你想为 Markdown 文件生成目录,通过 VS Code 的 **Markdown Preview Enhanced** 这类插件就可以了。 生成的目录效果如下图所示。你直接点击目录中的链接即可跳转到文章对应的位置,可以优化阅读体验。 ![]() -不过,目前 Github 已经自动为 Markdown 文件生成了目录,只是需要通过点击的方式才能显示出来。 +不过,目前 GitHub 已经会为 Markdown 文件自动生成目录,只是需要通过页面上的目录按钮展开。 ![](https://oss.javaguide.cn/github/cosy/image-20211227093215005.png) -## 善用 Github Explore +## 善用 GitHub Explore -其实,Github 自带的 Explore 是一个非常强大且好用的功能。不过,据我观察,国内很多 Github 用户都不知道这个到底是干啥的。 +GitHub 自带的 Explore 是一个非常强大且好用的功能,适合用来发现项目、主题和技术趋势。 -简单来说,Github Explore 可以为你带来下面这些服务: +简单来说,GitHub Explore 可以提供下面这些服务: 1. 可以根据你的个人兴趣为你推荐项目; -2. Github Topics 按照类别/话题将一些项目进行了分类汇总。比如 [Data visualization](https://github.com/topics/data-visualization) 汇总了数据可视化相关的一些开源项目,[Awesome Lists](https://github.com/topics/awesome) 汇总了 Awesome 系列的仓库; -3. 通过 Github Trending 我们可以看到最近比较热门的一些开源项目,我们可以按照语言类型以及时间维度对项目进行筛选; -4. Github Collections 类似一个收藏夹集合。比如 [Teaching materials for computational social science](https://github.com/collections/teaching-computational-social-science) 这个收藏夹就汇总了计算机课程相关的开源资源,[Learn to Code](https://github.com/collections/learn-to-code) 这个收藏夹就汇总了对你学习编程有帮助的一些仓库; +2. GitHub Topics 按照类别/话题将一些项目进行了分类汇总。比如 [Data visualization](https://github.com/topics/data-visualization) 汇总了数据可视化相关的一些开源项目,[Awesome Lists](https://github.com/topics/awesome) 汇总了 Awesome 系列的仓库; +3. 通过 GitHub Trending 我们可以看到最近比较热门的一些开源项目,我们可以按照语言类型以及时间维度对项目进行筛选; +4. GitHub Collections 类似一个收藏夹集合。比如 [Teaching materials for computational social science](https://github.com/collections/teaching-computational-social-science) 这个收藏夹就汇总了计算机课程相关的开源资源,[Learn to Code](https://github.com/collections/learn-to-code) 这个收藏夹就汇总了对你学习编程有帮助的一些仓库; 5. …… ![](https://oss.javaguide.cn/github/javaguide/github-explore.png) ## GitHub Actions 很强大 -你可以简单地将 GitHub Actions 理解为 Github 自带的 CI/CD ,通过 GitHub Actions 你可以直接在 GitHub 构建、测试和部署代码,你还可以对代码进行审查、管理 API、分析项目依赖项。总之,GitHub Actions 可以自动化地帮你完成很多事情。 +你可以简单地将 GitHub Actions 理解为 GitHub 自带的自动化平台。通过 GitHub Actions,你可以直接在 GitHub 上完成构建、测试、部署、依赖扫描、定时任务等工作。 关于 GitHub Actions 的详细介绍,推荐看一下阮一峰老师写的 [GitHub Actions 入门教程](https://www.ruanyifeng.com/blog/2019/09/getting-started-with-github-actions.html) 。 -GitHub Actions 有一个官方市场,上面有非常多别人提交的 Actions ,你可以直接拿来使用。 +GitHub Actions 有一个官方市场,上面有很多别人提交的 Actions,可以直接复用。 ![](https://oss.javaguide.cn/github/javaguide/image-20211227100147433.png) ## 后记 -这一篇文章,我毫无保留地把自己这些年总结的 Github 小技巧分享了出来,真心希望对大家有帮助,真心希望大家一定要利用好 Github 这个专属程序员的宝藏。 +GitHub 技巧不需要一次性全部记住。个人主页、项目徽章、代码阅读、Explore/Trending、GitHub Actions 这几块先用起来,就已经能覆盖大部分日常场景。 -另外,这篇文章中,我并没有提到 Github 搜索技巧。在我看来,Github 搜索技巧不必要记网上那些文章说的各种命令啥的,真没啥卵用。你会发现你用的最多的还是关键字搜索以及 Github 自带的筛选功能。 +另外,这篇文章没有展开讲 GitHub 搜索语法。实际使用中,关键词搜索、语言筛选、Star 数排序、更新时间筛选,往往比死记复杂语法更常用。 diff --git a/docs/tools/gradle/gradle-core-concepts.md b/docs/tools/gradle/gradle-core-concepts.md index 81ce9a1421d..9ca7f1a93b7 100644 --- a/docs/tools/gradle/gradle-core-concepts.md +++ b/docs/tools/gradle/gradle-core-concepts.md @@ -1,6 +1,6 @@ --- -title: Gradle核心概念总结 -description: Gradle 就是一个运行在 JVM 上的自动化的项目构建工具,用来帮助我们自动构建项目。 +title: Gradle 核心概念总结 +description: Gradle 是一个运行在 JVM 上的自动化构建工具,支持灵活的任务编排、依赖管理、插件扩展和多项目构建。 category: 开发工具 head: - - meta @@ -10,7 +10,7 @@ head: > 这部分内容主要根据 Gradle 官方文档整理,做了对应的删减,主要保留比较重要的部分,不涉及实战,主要是一些重要概念的介绍。 -Gradle 这部分内容属于可选内容,可以根据自身需求决定是否学习,目前国内还是使用 Maven 普遍一些。 +Gradle 这部分内容属于可选内容,可以根据自身需求决定是否学习。国内 Java 后端项目里 Maven 仍然更常见,但 Android、部分 Spring Boot 项目以及需要高度定制构建流程的项目中,Gradle 使用得也很多。 ## Gradle 介绍 @@ -20,7 +20,7 @@ Gradle 官方文档是这样介绍的 Gradle 的: > > Gradle 是一个开源的构建自动化工具,它足够灵活,可以构建几乎任何类型的软件。Gradle 对你要构建什么或者如何构建它做了很少的假设。这使得 Gradle 特别灵活。 -简单来说,Gradle 就是一个运行在 JVM 上的自动化的项目构建工具,用来帮助我们自动构建项目。 +简单来说,Gradle 就是一个运行在 JVM 上的自动化项目构建工具,用来帮助我们完成编译、测试、打包、发布等构建任务。 对于开发者来说,Gradle 的主要作用主要有 3 个: @@ -28,17 +28,17 @@ Gradle 官方文档是这样介绍的 Gradle 的: 2. **依赖管理**:方便快捷的管理项目依赖的资源(jar 包),避免资源间的版本冲突问题。 3. **统一开发结构**:提供标准的、统一的项目结构。 -Gradle 构建脚本是使用 Groovy 或 Kotlin 语言编写的,表达能力非常强,也足够灵活。 +Gradle 构建脚本可以使用 Groovy DSL 或 Kotlin DSL 编写。现在新项目里 Kotlin DSL 也很常见,它的类型提示和 IDE 支持通常更好。 ## Groovy 介绍 -Gradle 是运行在 JVM 上的一个程序,它可以使用 Groovy 来编写构建脚本。 +Gradle 是运行在 JVM 上的一个程序,构建脚本可以使用 Groovy 或 Kotlin 编写。历史上很多 Gradle 示例使用 Groovy DSL,因此先了解一点 Groovy 语法对阅读老项目很有帮助。 Groovy 是运行在 JVM 上的脚本语言,是基于 Java 扩展的动态语言,它的语法和 Java 非常的相似,可以使用 Java 的类库。Groovy 可以用于面向对象编程,也可以用作纯粹的脚本语言。在语言的设计上它吸纳了 Java、Python、Ruby 和 Smalltalk 语言的优秀特性,比如动态类型转换、闭包和元编程支持。 我们可以用学习 Java 的方式去学习 Groovy ,学习成本相对来说还是比较低的,即使开发过程中忘记 Groovy 语法,也可以用 Java 语法继续编码。 -基于 JVM 的语言有很多种比如 Groovy,Kotlin,Java,Scala,他们最终都会编译生成 Java 字节码文件并在 JVM 上运行。 +基于 JVM 的语言有很多种,比如 Groovy、Kotlin、Java、Scala,它们最终都会编译生成 Java 字节码文件并在 JVM 上运行。 ## Gradle 优势 @@ -76,12 +76,13 @@ Gradle Wrapper 会给我们带来下面这些好处: ### 生成 Gradle Wrapper -如果想要生成 Gradle Wrapper 的话,需要本地配置好 Gradle 环境变量。Gradle 中已经内置了 Wrapper Task,在项目根目录执行执行`gradle wrapper`命令即可帮助我们生成 Gradle Wrapper。 +如果想要首次生成 Gradle Wrapper,需要本地先有可用的 Gradle。Gradle 中已经内置了 Wrapper Task,在项目根目录执行 `gradle wrapper` 命令即可生成 Gradle Wrapper。 执行命令 `gradle wrapper` 命令时可以指定一些参数来控制 wrapper 的生成。具体有如下两个配置参数: -- `--gradle-version` 用于指定使用的 Gradle 的版本 -- `--gradle-distribution-url` 用于指定下载 Gradle 版本的 URL,该值的规则是 `http://services.gradle.org/distributions/gradle-${gradleVersion}-bin.zip` +- `--gradle-version`:用于指定使用的 Gradle 版本。 +- `--gradle-distribution-url`:用于指定下载 Gradle 发行版的 URL,该值通常类似于 `https://services.gradle.org/distributions/gradle-${gradleVersion}-bin.zip`。 +- `--gradle-distribution-sha256-sum`:用于指定发行版压缩包的 SHA-256 校验值,可以降低下载文件被篡改的风险。 执行`gradle wrapper`命令之后,Gradle Wrapper 就生成完成了,项目根目录中生成如下文件: @@ -98,8 +99,8 @@ Gradle Wrapper 会给我们带来下面这些好处: - `gradle-wrapper.jar`:包含了 Gradle 运行时的逻辑代码。 - `gradle-wrapper.properties`:定义了 Gradle 的版本号和 Gradle 运行时的行为属性。 -- `gradlew`:Linux 平台下,用于执行 Gralde 命令的包装器脚本。 -- `gradlew.bat`:Windows 平台下,用于执行 Gralde 命令的包装器脚本。 +- `gradlew`:Linux/macOS 平台下,用于执行 Gradle 命令的包装器脚本。 +- `gradlew.bat`:Windows 平台下,用于执行 Gradle 命令的包装器脚本。 `gradle-wrapper.properties` 文件的内容如下: @@ -121,38 +122,40 @@ zipStorePath=wrapper/dists 更新 Gradle Wrapper 有 2 种方式: -1. 接修改`distributionUrl`字段,然后执行 Gradle 命令。 -2. 执行 gradlew 命令`gradlew wrapper –-gradle-version [version]`。 +1. 直接修改 `distributionUrl` 字段,然后执行 Gradle 命令。 +2. 执行 `./gradlew wrapper --gradle-version [version]`。 -下面的命令会将 Gradle 版本升级为 7.6。 +下面的命令会将 Gradle 版本升级为 9.5.1。 ```shell -gradlew wrapper --gradle-version 7.6 +./gradlew wrapper --gradle-version 9.5.1 ``` `gradle-wrapper.properties` 文件中的 `distributionUrl` 属性也发生了改变。 ```properties -distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip ``` +项目已经生成 Wrapper 后,日常构建优先使用 `./gradlew build`,而不是直接使用本机安装的 `gradle build`。这样可以确保团队成员和 CI 使用同一个 Gradle 版本。 + ### 自定义 Gradle Wrapper -Gradle 已经内置了 Wrapper Task,因此构建 Gradle Wrapper 会生成 Gradle Wrapper 的属性文件,这个属性文件可以通过自定义 Wrapper Task 来设置。比如我们想要修改要下载的 Gralde 版本为 7.6,可以这么设置: +Gradle 已经内置了 Wrapper Task,因此构建 Gradle Wrapper 会生成 Gradle Wrapper 的属性文件,这个属性文件可以通过自定义 Wrapper Task 来设置。比如我们想要修改要下载的 Gradle 版本为 9.5.1,可以这么设置: -```javascript -task wrapper(type: Wrapper) { - gradleVersion = '7.6' +```groovy +tasks.wrapper { + gradleVersion = '9.5.1' } ``` 也可以设置 Gradle 发行版压缩包的下载地址和 Gradle 解包后的本地存储路径等配置。 ```groovy -task wrapper(type: Wrapper) { - gradleVersion = '7.6' - distributionUrl = '../../gradle-7.6-bin.zip' - distributionPath=wrapper/dists +tasks.wrapper { + gradleVersion = '9.5.1' + distributionUrl = '../../gradle-9.5.1-bin.zip' + distributionPath = 'wrapper/dists' } ``` diff --git a/docs/tools/maven/README.md b/docs/tools/maven/README.md index 3d64c93c513..b312d89ee4f 100644 --- a/docs/tools/maven/README.md +++ b/docs/tools/maven/README.md @@ -1,6 +1,6 @@ --- title: Maven 专题:POM、坐标、仓库、依赖管理、生命周期、插件与多模块项目 -description: Maven 面试与项目构建学习路线,涵盖 POM、坐标、仓库、依赖范围、生命周期、插件、多模块项目和最佳实践,适合 Java 后端开发者。 +description: Maven 面试与项目构建学习路线,涵盖 POM、坐标、仓库、依赖范围、生命周期、插件、多模块项目、Maven Wrapper 和最佳实践,适合 Java 后端开发者。 category: 开发工具 tag: - Maven @@ -20,7 +20,7 @@ Maven 是 Java 后端项目中最常见的构建和依赖管理工具。学习 M ## 适合谁看 - 正在学习 Java 项目构建和依赖管理的同学。 -- 使用 Maven 写项目,但遇到依赖冲突、版本不统一、多模块管理时容易卡住的开发者。 +- 使用 Maven 写项目,但遇到依赖冲突、版本不统一、多模块管理、CI 构建时容易卡住的开发者。 - 准备面试,需要讲清 Maven 核心概念和最佳实践的读者。 - 需要维护 Spring Boot、微服务或多模块 Java 项目的工程师。 @@ -30,18 +30,19 @@ Maven 是 Java 后端项目中最常见的构建和依赖管理工具。学习 M - Maven 仓库分为本地仓库、私服仓库和中央仓库,依赖解析会按一定顺序查找。 - 依赖范围、依赖传递、依赖排除和版本管理决定项目最终使用哪些 Jar 包。 - 生命周期定义构建阶段,插件负责真正执行编译、测试、打包等任务。 +- Maven Wrapper 能固定项目使用的 Maven 版本,适合团队协作和 CI 环境。 - 多模块项目要重点关注父 POM、`dependencyManagement`、`pluginManagement` 和模块边界。 ## 建议阅读顺序 1. [Maven 核心概念总结](./maven-core-concepts.md):先理解 POM、坐标、仓库、依赖、生命周期、插件和多模块项目。 -2. [Maven 最佳实践](./maven-best-practices.md):再学习标准目录结构、编译插件、依赖版本管理、多模块管理和常见实践。 +2. [Maven 最佳实践](./maven-best-practices.md):再学习标准目录结构、编译版本、BOM、依赖版本管理、Maven Wrapper、CI 和常见实践。 3. 结合一个 Spring Boot 项目查看 `pom.xml`:重点看父工程、依赖范围、插件配置和最终依赖树。 ## 核心文章 - [Maven 核心概念总结](./maven-core-concepts.md):系统介绍 Maven 的定位、POM、坐标、仓库、依赖、生命周期、插件和多模块项目。 -- [Maven 最佳实践](./maven-best-practices.md):整理标准目录结构、编译器插件、依赖版本统一、多模块管理和日常使用建议。 +- [Maven 最佳实践](./maven-best-practices.md):整理标准目录结构、编译版本、依赖版本统一、Maven Wrapper、CI 和日常使用建议。 ## 高频问题 @@ -51,6 +52,7 @@ Maven 是 Java 后端项目中最常见的构建和依赖管理工具。学习 M - Maven 依赖传递是什么?依赖冲突如何排查? - `dependencyManagement` 和 `dependencies` 有什么区别? - Maven 生命周期和插件是什么关系? +- 为什么团队项目建议提交 Maven Wrapper? - `compile`、`provided`、`runtime`、`test` 等依赖范围有什么区别? - 多模块项目为什么通常需要父 POM? diff --git a/docs/tools/maven/maven-best-practices.md b/docs/tools/maven/maven-best-practices.md index cce228577d8..91fba5b27a2 100644 --- a/docs/tools/maven/maven-best-practices.md +++ b/docs/tools/maven/maven-best-practices.md @@ -1,18 +1,18 @@ --- -title: Maven最佳实践 -description: Maven 是一种广泛使用的 Java 项目构建自动化工具。它简化了构建过程并帮助管理依赖关系,使开发人员的工作更轻松。在这篇博文中,我们将讨论一些最佳实践、提示和技巧,以优化我们在项目中对 Maven 的使用并改善我们的开发体验。 +title: Maven 最佳实践 +description: 总结 Maven 在 Java 项目中的常见最佳实践,涵盖标准目录结构、编译版本、依赖管理、Profile、Maven Wrapper、CI 构建和插件使用。 category: 开发工具 head: - - meta - name: keywords - content: Maven坐标,Maven仓库,Maven生命周期,Maven多模块管理 + content: Maven坐标,Maven仓库,Maven生命周期,Maven多模块管理,Maven Wrapper,依赖管理 --- > 本文由 JavaGuide 翻译并完善,原文地址: 。 -Maven 是一种广泛使用的 Java 项目构建自动化工具。它简化了构建过程并帮助管理依赖关系,使开发人员的工作更轻松。Maven 详细介绍可以参考我写的这篇 [Maven 核心概念总结](./maven-core-concepts.md) 。 +Maven 是一种广泛使用的 Java 项目构建自动化工具。它简化了构建过程,并帮助我们管理依赖关系。Maven 详细介绍可以参考这篇文章:[Maven 核心概念总结](./maven-core-concepts.md)。 -这篇文章不会涉及到 Maven 概念的介绍,主要讨论一些最佳实践、建议和技巧,以优化我们在项目中对 Maven 的使用并改善我们的开发体验。 +这篇文章不展开 Maven 基础概念,主要讨论项目中更容易踩坑的实践问题:目录结构、编译版本、依赖版本、环境配置、Wrapper、CI 和插件管理。 ## Maven 标准目录结构 @@ -38,11 +38,21 @@ pom.xml 这只是一个最简单的 Maven 项目目录示例。实际项目中,我们还会根据项目规范去做进一步的细分。 -## 指定 Maven 编译器插件 +## 明确指定 Java 编译版本 -默认情况下,Maven 使用 Java5 编译我们的项目。要使用不同的 JDK 版本,请在 `pom.xml` 文件中配置 Maven 编译器插件。 +不要依赖 Maven 或插件的默认编译版本,项目应该在 `pom.xml` 中明确声明目标 Java 版本。对于现代 Java 项目,优先使用 `maven.compiler.release`,它对应 `javac --release`,比单独配置 `source` 和 `target` 更稳妥。 -例如,如果你想要使用 Java8 来编译你的项目,你可以在``标签下添加以下的代码片段: +需要注意的是,`javac --release` 从 JDK 9 开始提供;Maven Compiler Plugin 3.13.0 及之后版本在 JDK 8 上也支持 `maven.compiler.release`,会自动转换为 `source` 和 `target`。如果项目仍使用更旧的插件或构建环境,再显式配置 `source`、`target`。 + +例如,项目需要按 Java 17 编译,可以这样写: + +```xml + + 17 + +``` + +如果需要直接配置 Maven Compiler Plugin,也可以这样写: ```xml @@ -50,23 +60,22 @@ pom.xml org.apache.maven.plugins maven-compiler-plugin - 3.8.1 + 3.15.0 - 1.8 - 1.8 + 17 ``` -这样,Maven 就会使用 Java8 的编译器来编译你的项目。如果你想要使用其他版本的 JDK,你只需要修改``和``标签的值即可。例如,如果你想要使用 Java11,你可以将它们的值改为 11。 +`release` 的值不要再写成 `1.8` 这种旧格式。比如 Java 8 写 `8`,Java 17 写 `17`,Java 21 写 `21`。 ## 有效管理依赖关系 -Maven 的依赖管理系统是其最强大的功能之一。在顶层 pom 文件中,通过标签 `dependencyManagement` 定义公共的依赖关系,这有助于避免冲突并确保所有模块使用相同版本的依赖项。 +Maven 的依赖管理系统是其最强大的功能之一。在父 POM 中,通过 `dependencyManagement` 定义公共依赖版本,可以避免多个模块各写一份版本号,降低依赖冲突概率。 -例如,假设我们有一个父模块和两个子模块 A 和 B,我们想要在所有模块中使用 JUnit 5.7.2 作为测试框架。我们可以在父模块的`pom.xml`文件中使用``标签来定义 JUnit 的版本: +例如,假设我们有一个父模块和两个子模块 A 和 B,想要在所有模块中使用 JUnit 5,可以在父模块的 `pom.xml` 文件中通过 `` 定义 JUnit 的版本: ```xml @@ -74,14 +83,14 @@ Maven 的依赖管理系统是其最强大的功能之一。在顶层 pom 文件 org.junit.jupiter junit-jupiter - 5.7.2 + 5.10.2 test ``` -在子模块 A 和 B 的 `pom.xml` 文件中,我们只需要引用 JUnit 的 `groupId` 和 `artifactId` 即可: +在子模块 A 和 B 的 `pom.xml` 文件中,只需要引用 JUnit 的 `groupId` 和 `artifactId` 即可: ```xml @@ -92,6 +101,8 @@ Maven 的依赖管理系统是其最强大的功能之一。在顶层 pom 文件 ``` +对于 Spring Boot、Spring Cloud 这类已经提供 BOM 的生态,优先导入官方 BOM,再在业务模块里省略具体依赖版本。这样能减少“手工拼版本”带来的兼容性问题。 + ## 针对不同环境使用配置文件 Maven 配置文件允许我们配置不同环境的构建设置,例如开发、测试和生产。在 `pom.xml` 文件中定义配置文件并使用命令行参数激活它们: @@ -128,15 +139,17 @@ mvn clean install -P production - 将相似的依赖项和插件组合在一起。 - 使用注释来描述特定依赖项或插件的用途。 -- 将插件和依赖项的版本号保留在 `` 标签内以便于管理。 +- 将公共版本号放在 `` 标签内,或者统一放到父 POM 的 `dependencyManagement` / `pluginManagement` 中管理。 ```xml - 5.7.0 - 3.9.0 + 5.10.2 + 5.12.0 ``` +插件版本也建议显式声明。不要依赖 Maven 的默认插件版本,否则不同 Maven 版本或不同构建环境下可能出现行为差异。 + ## 使用 Maven Wrapper Maven Wrapper 是一个用于管理和使用 Maven 的工具,它允许在没有预先安装 Maven 的情况下运行和构建 Maven 项目。 @@ -155,11 +168,13 @@ mvn wrapper:wrapper 此命令会在我们的项目中生成 Maven Wrapper 文件。现在我们可以使用 `./mvnw` (或 Windows 上的 `./mvnw.cmd`)而不是 `mvn` 来执行 Maven 命令。 +团队项目建议提交 `mvnw`、`mvnw.cmd` 和 `.mvn/wrapper/` 目录。这样新成员或 CI 环境不需要预先安装指定版本的 Maven,也能用项目声明的 Maven 版本完成构建。 + ## 通过持续集成实现构建自动化 将 Maven 项目与持续集成 (CI) 系统(例如 Jenkins 或 GitHub Actions)集成,可确保自动构建、测试和部署我们的代码。CI 有助于及早发现问题并在整个团队中提供一致的构建流程。以下是 Maven 项目的简单 GitHub Actions 工作流程示例: -```groovy +```yaml name: Java CI with Maven on: [push] @@ -169,19 +184,22 @@ jobs: runs-on: ubuntu-latest steps: - - name: Checkout code - uses: actions/checkout@v2 - - - name: Set up JDK 11 - uses: actions/setup-java@v2 - with: - java-version: '11' - distribution: 'adopt' - - - name: Build with Maven - run: ./mvnw clean install + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up JDK 17 + uses: actions/setup-java@v4 + with: + java-version: "17" + distribution: "temurin" + cache: "maven" + + - name: Build with Maven + run: ./mvnw -B clean verify ``` +CI 中建议使用 `clean verify`,它会执行测试和必要的校验流程。`install` 会把构建产物安装到本地仓库,只有后续步骤确实依赖本地安装结果时才需要使用。 + ## 利用 Maven 插件获得附加功能 有许多 Maven 插件可用于扩展 Maven 的功能。一些流行的插件包括(前三个是 Maven 自带的插件,后三个是第三方提供的插件): @@ -190,7 +208,7 @@ jobs: - maven-failsafe-plugin:配置并执行集成测试。 - maven-javadoc-plugin:生成 Javadoc 格式的项目文档。 - maven-checkstyle-plugin:强制执行编码标准和最佳实践。 -- jacoco-maven-plugin: 单测覆盖率。 +- jacoco-maven-plugin:单测覆盖率。 - sonar-maven-plugin:分析代码质量。 - …… @@ -202,7 +220,7 @@ jacoco-maven-plugin 使用示例: org.jacoco jacoco-maven-plugin - 0.8.8 + 0.8.12 @@ -228,4 +246,4 @@ jacoco-maven-plugin 使用示例: ## 总结 -Maven 是一个强大的工具,可以简化 Java 项目的构建过程和依赖关系管理。通过遵循这些最佳实践和技巧,我们可以优化 Maven 的使用并改善我们的 Java 开发体验。请记住使用标准目录结构,有效管理依赖关系,利用不同环境的配置文件,并将项目与持续集成系统集成,以确保构建一致。 +Maven 最重要的不是“能不能把项目跑起来”,而是让团队在本地、CI 和部署环境中使用一致的构建方式。实际项目里,建议优先做好这几件事:使用标准目录结构,显式声明 Java 和插件版本,通过父 POM、BOM、`dependencyManagement` 管理依赖版本,提交 Maven Wrapper,并在 CI 中固定 JDK 和 Maven 构建命令。 diff --git a/docs/tools/maven/maven-core-concepts.md b/docs/tools/maven/maven-core-concepts.md index 8711f7076ff..0b90e048e6e 100644 --- a/docs/tools/maven/maven-core-concepts.md +++ b/docs/tools/maven/maven-core-concepts.md @@ -1,5 +1,5 @@ --- -title: Maven核心概念总结 +title: Maven 核心概念总结 description: Apache Maven 的本质是一个软件项目管理和理解工具。基于项目对象模型 (Project Object Model,POM) 的概念,Maven 可以从一条中心信息管理项目的构建、报告和文档。 category: 开发工具 head: @@ -301,7 +301,7 @@ mvn 阶段 [阶段2] ...[阶段n] test-compile process-test-classes - + test prepare-package @@ -455,7 +455,7 @@ Maven 插件被分为下面两种类型: - 《Maven 实战》 - Introduction to Repositories - Maven 官方文档: - Introduction to the Build Lifecycle - Maven 官方文档: -- Maven 依赖范围: +- Maven 依赖范围: - 解决 maven 依赖冲突,这篇就够了!: - Multi-Module Project with Maven: From 415f10fbc6a7195c2d9e3e08f907d01f1403ad30 Mon Sep 17 00:00:00 2001 From: Guide Date: Fri, 12 Jun 2026 00:32:35 +0800 Subject: [PATCH 012/116] docs: enhance data structure and algorithm guides --- docs/.vuepress/sidebar/cs-basics.ts | 6 ++ docs/.vuepress/sidebar/index.ts | 20 ++++-- docs/cs-basics/README.md | 6 ++ .../10-classical-sorting-algorithms.md | 64 +++++++++++++++++ .../linkedlist-algorithm-problems.md | 28 +++++++- .../algorithms/string-algorithm-problems.md | 2 +- docs/cs-basics/data-structure/graph.md | 69 +++++++++++++++++++ docs/cs-basics/data-structure/heap.md | 60 ++++++++++++++++ docs/cs-basics/data-structure/tree.md | 67 ++++++++++++++++++ docs/database/mysql/mysql-index.md | 7 ++ docs/database/redis/cache-basics.md | 8 +++ .../redis/redis-data-structures-01.md | 8 +++ docs/database/redis/redis-skiplist.md | 4 ++ .../backend-interview-plan.md | 4 +- .../java-collection-questions-01.md | 11 ++- 15 files changed, 354 insertions(+), 10 deletions(-) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index e456bdf0512..fb4a0315a06 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -24,6 +24,7 @@ export const csBasics = [ { text: "基础", icon: ICONS.STAR, + collapsible: true, children: [ { text: "OSI 七层模型与 TCP/IP 四层模型详解", @@ -38,6 +39,7 @@ export const csBasics = [ { text: "应用层", icon: ICONS.CODE, + collapsible: true, children: [ { text: "⭐️应用层常见协议总结", link: "application-layer-protocol" }, { text: "⭐️HTTP vs HTTPS", link: "http-vs-https" }, @@ -54,6 +56,7 @@ export const csBasics = [ { text: "传输层", icon: ICONS.NETWORK, + collapsible: true, children: [ { text: "⭐️TCP 三次握手和四次挥手", @@ -89,6 +92,7 @@ export const csBasics = [ { text: "网络层", icon: ICONS.NETWORK, + collapsible: true, children: [ { text: "ARP 协议详解", link: "arp" }, { text: "NAT 协议详解", link: "nat" }, @@ -97,6 +101,7 @@ export const csBasics = [ { text: "安全", icon: ICONS.SECURITY, + collapsible: true, children: [ { text: "网络攻击常见手段总结", link: "network-attack-means" }, ], @@ -134,6 +139,7 @@ export const csBasics = [ { text: "进程与线程", icon: ICONS.STAR, + collapsible: true, children: [ { text: "⭐️进程与线程详解", link: "process-and-thread" }, { text: "进程间通信(IPC)详解", link: "ipc" }, diff --git a/docs/.vuepress/sidebar/index.ts b/docs/.vuepress/sidebar/index.ts index 7479ae85297..bd0b52f0aff 100644 --- a/docs/.vuepress/sidebar/index.ts +++ b/docs/.vuepress/sidebar/index.ts @@ -43,12 +43,15 @@ export default sidebar({ text: "面试准备知识体系", link: "/interview-preparation/", }, - "backend-interview-plan", + { text: "Java 后端面试通关计划", link: "backend-interview-plan" }, "teach-you-how-to-prepare-for-the-interview-hand-in-hand", "resume-guide", - "key-points-of-interview", - "pdf-interview-javaguide", - "java-roadmap", + { text: "Java 后端面试重点总结", link: "key-points-of-interview" }, + { + text: "Java 面试 + 后端面试 PDF 资料", + link: "pdf-interview-javaguide", + }, + { text: "Java 学习路线", link: "java-roadmap" }, "project-experience-guide", "how-to-handle-interview-nerves", "internship-experience", @@ -292,7 +295,10 @@ export default sidebar({ text: "Maven", icon: ICONS.MAVEN, prefix: "maven/", - children: ["maven-core-concepts", "maven-best-practices"], + children: [ + { text: "Maven 核心概念总结", link: "maven-core-concepts" }, + { text: "Maven 最佳实践", link: "maven-best-practices" }, + ], }, { text: "Gradle", @@ -527,7 +533,9 @@ export default sidebar({ { text: "负载均衡", icon: ICONS.LOAD_BALANCING, - children: ["load-balancing"], + children: [ + { text: "负载均衡原理及算法详解", link: "load-balancing" }, + ], }, { text: "数据库优化", diff --git a/docs/cs-basics/README.md b/docs/cs-basics/README.md index 384f705b252..554181788cb 100644 --- a/docs/cs-basics/README.md +++ b/docs/cs-basics/README.md @@ -50,6 +50,8 @@ head: 4. [算法专题](./algorithms/):结合复杂度分析、核心算法模板和 LeetCode 高频题进行练习。 5. 回到面试题做查缺补漏:重点复盘网络和操作系统高频问题,再把数据结构与算法题按类型刷一遍。 +如果你的目标公司比较重算法,建议把第 3 步和第 4 步合在一起复习:先看一个数据结构,再刷对应题型。例如,看完 [哈希表](./data-structure/hash-table.md) 就刷两数之和、前缀和;看完 [堆](./data-structure/heap.md) 就刷 [Top K](./algorithms/top-k.md);看完 [树](./data-structure/tree.md) 和 [图](./data-structure/graph.md) 后,再集中练 [DFS 与 BFS](./algorithms/dfs-bfs.md)、[回溯](./algorithms/backtracking.md) 和 [动态规划](./algorithms/dynamic-programming.md)。 + ## 核心文章 ### 计算机网络 @@ -85,6 +87,8 @@ head: - [堆详解](./data-structure/heap.md)、[红黑树详解](./data-structure/red-black-tree.md)、[布隆过滤器详解](./data-structure/bloom-filter.md):补齐高频工程结构和面试考点。 - [Trie 前缀树面试题总结](./data-structure/trie.md)、[并查集面试题总结](./data-structure/union-find.md)、[跳表面试题总结](./data-structure/skip-list.md)、[LRU 缓存面试题总结](./data-structure/lru-cache.md):补齐字符串集合、连通性、Redis ZSet 和缓存淘汰等高频场景。 +复习数据结构时,可以同步回看 Java 和数据库专题:数组/链表/哈希表对应 [Java 集合](../java/collection/),B+ 树对应 [MySQL 索引](../database/mysql/mysql-index.md),跳表对应 [Redis 跳表](../database/redis/redis-skiplist.md),LRU 和布隆过滤器对应缓存场景。 + ### 算法 - [算法专题](./algorithms/):整理常见算法思想、LeetCode 高频题和经典排序。 @@ -97,6 +101,8 @@ head: - [几道常见的字符串算法题](./algorithms/string-algorithm-problems.md)、[几道常见的链表算法题](./algorithms/linkedlist-algorithm-problems.md):集中练习高频题型。 - [剑指 Offer 部分编程题](./algorithms/the-sword-refers-to-offer.md)、[十大经典排序算法总结](./algorithms/10-classical-sorting-algorithms.md):适合面试前复盘。 +算法刷题建议先把每类模板写稳,再做题单:[经典算法思想总结](./algorithms/classical-algorithm-problems-recommendations.md) 适合按题型刷,[常见数据结构经典 LeetCode 题目推荐](./algorithms/common-data-structures-leetcode-recommendations.md) 适合按结构刷。 + ## 高频问题 - OSI 七层模型和 TCP/IP 四层模型分别是什么?每层解决什么问题? diff --git a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md index 280255d1406..c11c663b789 100644 --- a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md +++ b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md @@ -797,4 +797,68 @@ public static int[] radixSort(int[] arr) { - 插入排序什么时候表现好?数组基本有序且规模不大时。 - 计数排序、桶排序、基数排序为什么不是通用排序?它们依赖数据范围、分布或位数。 +## Java 代码模板 + +排序面试最常手写的是快速排序和归并排序。快速排序要特别注意分区边界,下面是一个常见写法: + +```java +void quickSort(int[] nums, int left, int right) { + if (left >= right) { + return; + } + int pivotIndex = partition(nums, left, right); + quickSort(nums, left, pivotIndex - 1); + quickSort(nums, pivotIndex + 1, right); +} + +int partition(int[] nums, int left, int right) { + int pivot = nums[right]; + int less = left; + for (int i = left; i < right; i++) { + if (nums[i] <= pivot) { + swap(nums, less, i); + less++; + } + } + swap(nums, less, right); + return less; +} + +void swap(int[] nums, int i, int j) { + int temp = nums[i]; + nums[i] = nums[j]; + nums[j] = temp; +} +``` + +如果担心有序数组导致快排退化,可以在分区前随机选择 pivot,并把它交换到 `right` 位置。 + +```java +int randomIndex = left + new Random().nextInt(right - left + 1); +swap(nums, randomIndex, right); +``` + +## 过程示意和边界样例 + +快速排序的一次分区可以这样理解: + +```text +原数组区间:[left ... right] +pivot:选择 nums[right] +less:指向“小于等于 pivot 区域”的下一个位置 +i:从 left 扫到 right - 1 + +扫描结束后: +[left ... less - 1] <= pivot +[less ... right - 1] > pivot +把 pivot 换到 less,pivot 左右两边分别递归 +``` + +几个边界样例建议手写前先过一遍: + +- 空数组或只有一个元素:直接返回。 +- 已经有序或逆序:固定选择首尾元素做 pivot 容易退化。 +- 大量重复元素:普通二路分区可能不够理想,可以了解三路快排。 +- 面试官问稳定性时,不要说快排稳定;普通快排交换元素会打乱相等元素顺序。 + diff --git a/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md b/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md index 09517584c0b..3923691fb3d 100644 --- a/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md +++ b/docs/cs-basics/algorithms/linkedlist-algorithm-problems.md @@ -110,7 +110,7 @@ public class ListNode { * * @author Snailclimb * @date 2018年9月19日 - * @Description: TODO + * @Description: 反转单链表 */ public class Solution { @@ -417,11 +417,37 @@ ListNode reverseList(ListNode head) { } ``` +## 过程示意和边界样例 + +反转链表时,核心是先保存 `next`,再修改 `cur.next`。可以按下面的指针变化来记: + +```text +初始:prev = null, cur = head + +每一轮: +next = cur.next +cur.next = prev +prev = cur +cur = next + +结束:cur == null,prev 指向新头节点 +``` + +删除节点、合并链表这类题,优先考虑虚拟头节点: + +```java +ListNode dummy = new ListNode(0); +dummy.next = head; +// 中间统一操作 dummy 后面的链表 +return dummy.next; +``` + 几个易错点: - 删除倒数第 N 个节点时,虚拟头节点能统一处理删除头节点的情况。 - 区间反转要先保存区间前一个节点和区间后一个节点。 - 判断链表有环时,循环条件是 `fast != null && fast.next != null`。 - 递归合并链表代码短,但链表很长时可能有递归栈风险。 +- 空链表、单节点链表、删除头节点、删除尾节点都要单独过一遍。 diff --git a/docs/cs-basics/algorithms/string-algorithm-problems.md b/docs/cs-basics/algorithms/string-algorithm-problems.md index bafcf375c8e..3dd1183b1b5 100644 --- a/docs/cs-basics/algorithms/string-algorithm-problems.md +++ b/docs/cs-basics/algorithms/string-algorithm-problems.md @@ -398,7 +398,7 @@ import java.util.Scanner; * * @author Snailclimb * @date 2018年9月6日 - * @Description: TODO 求给定合法括号序列的深度 + * @Description: 求给定合法括号序列的深度 */ public class Main { public static void main(String[] args) { diff --git a/docs/cs-basics/data-structure/graph.md b/docs/cs-basics/data-structure/graph.md index c113d8851ba..29b251ad105 100644 --- a/docs/cs-basics/data-structure/graph.md +++ b/docs/cs-basics/data-structure/graph.md @@ -181,6 +181,75 @@ DFS/BFS 模板可以参考 [DFS 与 BFS 面试题总结](../algorithms/dfs-bfs.m - 无向图连通性和判环可以用 DFS/BFS,也可以用并查集。 - 带权最短路径不是普通 BFS,常见算法有 Dijkstra、Bellman-Ford、Floyd,面试中按题目范围选择。 +## Java 代码模板 + +算法题中最常用的是邻接表。节点编号通常是 `0` 到 `n - 1`,可以用 `List[]` 表示。 + +```java +List[] buildGraph(int n, int[][] edges) { + List[] graph = new ArrayList[n]; + for (int i = 0; i < n; i++) { + graph[i] = new ArrayList<>(); + } + for (int[] edge : edges) { + int from = edge[0]; + int to = edge[1]; + graph[from].add(to); + // 无向图需要再加一条反向边: + // graph[to].add(from); + } + return graph; +} +``` + +BFS 适合求无权图最短步数: + +```java +int bfs(List[] graph, int start, int target) { + boolean[] visited = new boolean[graph.length]; + Queue queue = new ArrayDeque<>(); + queue.offer(start); + visited[start] = true; + int step = 0; + while (!queue.isEmpty()) { + int size = queue.size(); + for (int i = 0; i < size; i++) { + int cur = queue.poll(); + if (cur == target) { + return step; + } + for (int next : graph[cur]) { + if (!visited[next]) { + visited[next] = true; + queue.offer(next); + } + } + } + step++; + } + return -1; +} +``` + +## 过程示意和边界样例 + +以无权图最短路径为例,BFS 的层序扩散过程可以这样理解: + +```text +第 0 层:start +第 1 层:start 的所有未访问邻居 +第 2 层:第 1 层节点的所有未访问邻居 +... +第一次遇到 target 时,当前层数就是最短步数 +``` + +几个边界样例建议先过一遍: + +- `start == target`,答案应该是 `0`。 +- 图不连通,目标点不可达,答案应该是 `-1`。 +- 无向图建图时忘记加反向边,会把连通图误判成不连通。 +- 有环图如果不标记 `visited`,BFS/DFS 会重复访问甚至死循环。 + ## 推荐练习题 - [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) diff --git a/docs/cs-basics/data-structure/heap.md b/docs/cs-basics/data-structure/heap.md index eeee10518af..a55d4f59018 100644 --- a/docs/cs-basics/data-structure/heap.md +++ b/docs/cs-basics/data-structure/heap.md @@ -233,6 +233,66 @@ Top K 问题常见选择: - 求前 K 高频:先用哈希表计数,再用小顶堆保留 K 个高频元素。 - 数据流中位数:一个大顶堆维护较小的一半,一个小顶堆维护较大的一半。 +## Java 代码模板 + +第 K 大问题可以用大小为 K 的小顶堆。堆顶始终是当前前 K 大里最小的那个元素,如果新元素比堆顶大,就替换堆顶。 + +```java +int findKthLargest(int[] nums, int k) { + PriorityQueue heap = new PriorityQueue<>(); + for (int num : nums) { + if (heap.size() < k) { + heap.offer(num); + } else if (num > heap.peek()) { + heap.poll(); + heap.offer(num); + } + } + return heap.peek(); +} +``` + +前 K 高频元素通常是“哈希表计数 + 小顶堆”: + +```java +int[] topKFrequent(int[] nums, int k) { + Map count = new HashMap<>(); + for (int num : nums) { + count.put(num, count.getOrDefault(num, 0) + 1); + } + PriorityQueue heap = new PriorityQueue<>((a, b) -> Integer.compare(a[1], b[1])); + for (Map.Entry entry : count.entrySet()) { + heap.offer(new int[] {entry.getKey(), entry.getValue()}); + if (heap.size() > k) { + heap.poll(); + } + } + int[] ans = new int[k]; + for (int i = k - 1; i >= 0; i--) { + ans[i] = heap.poll()[0]; + } + return ans; +} +``` + +## 过程示意和边界样例 + +维护大小为 K 的小顶堆时,可以把堆理解成“候选池”: + +```text +1. 候选池没满:直接放入。 +2. 候选池已满,新元素 <= 堆顶:进不了前 K,跳过。 +3. 候选池已满,新元素 > 堆顶:弹出堆顶,放入新元素。 +4. 遍历结束后,堆顶就是第 K 大。 +``` + +几个边界样例建议先过一遍: + +- `k == 1`:求最大值。 +- `k == nums.length`:求最小值。 +- 数组里有重复元素:第 K 大通常按排序位置算,不是第 K 个不同元素。 +- 比较器不要写 `b - a`,极端值可能溢出。 + ## 推荐练习题 - [215. 数组中的第 K 个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) diff --git a/docs/cs-basics/data-structure/tree.md b/docs/cs-basics/data-structure/tree.md index f09060ec3a8..df04627eca1 100644 --- a/docs/cs-basics/data-structure/tree.md +++ b/docs/cs-basics/data-structure/tree.md @@ -222,6 +222,73 @@ BST 高频回答: - AVL 树比红黑树更严格平衡,查询更稳定;红黑树平衡要求宽一些,插入删除调整成本更低。 - B+ 树适合数据库索引,一个节点能存更多 key,树高更低,叶子节点有序链表适合范围查询。 +## Java 代码模板 + +层序遍历是二叉树面试中最常见的非递归模板,很多“每层最大值”“锯齿形遍历”“最小深度”都可以从它变形。 + +```java +List> levelOrder(TreeNode root) { + List> ans = new ArrayList<>(); + if (root == null) { + return ans; + } + Queue queue = new ArrayDeque<>(); + queue.offer(root); + while (!queue.isEmpty()) { + int size = queue.size(); + List level = new ArrayList<>(); + for (int i = 0; i < size; i++) { + TreeNode node = queue.poll(); + level.add(node.val); + if (node.left != null) { + queue.offer(node.left); + } + if (node.right != null) { + queue.offer(node.right); + } + } + ans.add(level); + } + return ans; +} +``` + +验证 BST 时,不要只比较当前节点和左右孩子。正确做法是给每棵子树传上下界: + +```java +boolean isValidBST(TreeNode root) { + return check(root, Long.MIN_VALUE, Long.MAX_VALUE); +} + +boolean check(TreeNode node, long lower, long upper) { + if (node == null) { + return true; + } + if (node.val <= lower || node.val >= upper) { + return false; + } + return check(node.left, lower, node.val) && check(node.right, node.val, upper); +} +``` + +## 过程示意和边界样例 + +二叉树题可以先判断“当前节点要做什么”,再决定用前序、中序、后序还是层序。 + +```text +前序:先处理当前节点,再处理左右子树,适合复制树、构造路径。 +中序:左 -> 根 -> 右,BST 中序结果有序。 +后序:先处理左右子树,再处理当前节点,适合求高度、直径、删除节点。 +层序:按层推进,适合最短深度、每层统计、序列化。 +``` + +几个边界样例建议手写前先过一遍: + +- 空树:很多题应该返回空列表、`0` 或 `true`。 +- 只有一个节点:递归出口和层序队列都要能处理。 +- 退化链表:递归深度可能达到 `n`,复杂度不要误写成 `O(logn)`。 +- BST 中存在 `Integer.MIN_VALUE` / `Integer.MAX_VALUE`:上下界建议用 `long`。 + ## 推荐练习题 - [144. 二叉树的前序遍历](https://leetcode.cn/problems/binary-tree-preorder-traversal/) diff --git a/docs/database/mysql/mysql-index.md b/docs/database/mysql/mysql-index.md index 7c75909612d..c15aa41d82e 100644 --- a/docs/database/mysql/mysql-index.md +++ b/docs/database/mysql/mysql-index.md @@ -570,4 +570,11 @@ mysql> EXPLAIN SELECT `score`,`name` FROM `cus_order` ORDER BY `score` DESC; 篇幅问题,我这里只是简单介绍了一下 MySQL 执行计划,详细介绍请看:[MySQL 执行计划分析](./mysql-query-execution-plan.md)这篇文章。 +## 数据结构延伸阅读 + +理解 MySQL 索引时,建议回到树结构本身看一遍: + +- [树结构详解](../../cs-basics/data-structure/tree.md):对比二叉搜索树、AVL、红黑树、B 树和 B+ 树。 +- [红黑树详解](../../cs-basics/data-structure/red-black-tree.md):理解内存中自平衡搜索树的取舍,再对比 B+ 树为什么更适合磁盘索引。 + diff --git a/docs/database/redis/cache-basics.md b/docs/database/redis/cache-basics.md index 15cb0eb33bb..51b8b25c972 100644 --- a/docs/database/redis/cache-basics.md +++ b/docs/database/redis/cache-basics.md @@ -189,6 +189,14 @@ Memcached 是分布式缓存最开始兴起的那会,比较常用的。后来 详细介绍:[分布式多级缓存系统设计与实战](https://juejin.cn/post/7225634879152570405) +## 数据结构延伸阅读 + +缓存问题经常会追到具体数据结构: + +- [布隆过滤器详解](../../cs-basics/data-structure/bloom-filter.md):理解缓存穿透、误判率和删除困难。 +- [LRU 缓存面试题总结](../../cs-basics/data-structure/lru-cache.md):理解本地缓存淘汰策略、`LinkedHashMap` 写法和页面置换思想。 +- [哈希表面试题总结](../../cs-basics/data-structure/hash-table.md):理解缓存 key 映射、哈希冲突和扩容。 + ## 参考 - 缓存那些事:https://tech.meituan.com/2017/03/17/cache-about.html diff --git a/docs/database/redis/redis-data-structures-01.md b/docs/database/redis/redis-data-structures-01.md index 64468c03f02..067f4c82803 100644 --- a/docs/database/redis/redis-data-structures-01.md +++ b/docs/database/redis/redis-data-structures-01.md @@ -491,6 +491,14 @@ value1 | Set | 无序集合,集合中的元素没有先后顺序但都唯一,有点类似于 Java 中的 `HashSet` 。 | | Zset | 和 Set 相比,Sorted Set 增加了一个权重参数 `score`,使得集合中的元素能够按 `score` 进行有序排列,还可以通过 `score` 的范围来获取元素的列表。有点像是 Java 中 `HashMap` 和 `TreeSet` 的结合体。 | +## 数据结构延伸阅读 + +Redis 数据类型背后大量使用了基础数据结构。想从面试角度补底层,可以结合这些文章看: + +- [线性数据结构详解](../../cs-basics/data-structure/linear-data-structure.md):理解 List、队列和链表的关系。 +- [哈希表面试题总结](../../cs-basics/data-structure/hash-table.md):理解 Hash、Set 这类结构的查找和冲突处理。 +- [跳表面试题总结](../../cs-basics/data-structure/skip-list.md):理解 Sorted Set 范围查询和排名能力背后的结构取舍。 + ## 参考 - Redis Data Structures: 。 diff --git a/docs/database/redis/redis-skiplist.md b/docs/database/redis/redis-skiplist.md index 777fa3e8748..efb603bb5dc 100644 --- a/docs/database/redis/redis-skiplist.md +++ b/docs/database/redis/redis-skiplist.md @@ -719,6 +719,10 @@ private Node < K, V > add(Node < K, V > node, K key, V val) { 本文通过大量篇幅介绍跳表的工作原理和实现,帮助读者更进一步的熟悉跳表这一数据结构的优劣,最后再结合各个数据结构操作的特点进行比对,从而帮助读者更好的理解这道面试题,建议读者实现理解跳表时,尽可能配合执笔模拟来了解跳表的增删改查详细过程。 +## 数据结构延伸阅读 + +如果想从面试角度快速复盘跳表,可以看 [跳表面试题总结](../../cs-basics/data-structure/skip-list.md)。如果想对比 Redis ZSet 背后的其他结构,也可以顺手复习 [红黑树详解](../../cs-basics/data-structure/red-black-tree.md) 和 [哈希表面试题总结](../../cs-basics/data-structure/hash-table.md)。 + ## 参考 - 为啥 redis 使用跳表(skiplist)而不是使用 red-black?: diff --git a/docs/interview-preparation/backend-interview-plan.md b/docs/interview-preparation/backend-interview-plan.md index a60c84421f6..f798a8df8b8 100644 --- a/docs/interview-preparation/backend-interview-plan.md +++ b/docs/interview-preparation/backend-interview-plan.md @@ -94,7 +94,7 @@ head: - 减少纯业务描述,多挖掘技术亮点,结合具体业务场景描述。 - 优化成果要量化(QPS、响应时间、成本节省等),非真实项目包装合理数值即可。 - 工作内容介绍控制在 6~8 条左右比较好,多了少了都有影响,一定要至少有 3-4 条是有技术亮点的,能吸引到面试官。 -- 避免模糊性描述(如"负责开发"),要具体(技术+场景+效果)。 +- 避免模糊性描述(如“负责开发”),要具体(技术+场景+效果)。 - 一定要包装项目,但也不要过度包装,准备时多想“如果面试官问为什么”,确保逻辑自洽。 ### 第二阶段:Java 核心 + MySQL + Redis (约 2~3 周) @@ -173,6 +173,8 @@ head: - **操作系统**:[操作系统常见面试题(上)](https://javaguide.cn/cs-basics/operating-system/operating-system-basic-questions-01.html)、[(下)](https://javaguide.cn/cs-basics/operating-system/operating-system-basic-questions-02.html)、[Linux 基础](https://javaguide.cn/cs-basics/operating-system/linux-intro.html) - **数据结构**:先过 [数据结构专题](https://javaguide.cn/cs-basics/data-structure/),再重点复盘 [数组/链表/栈/队列](https://javaguide.cn/cs-basics/data-structure/linear-data-structure.html)、[哈希表](https://javaguide.cn/cs-basics/data-structure/hash-table.html)、[树](https://javaguide.cn/cs-basics/data-structure/tree.html)、[图](https://javaguide.cn/cs-basics/data-structure/graph.html)、[堆](https://javaguide.cn/cs-basics/data-structure/heap.html)、[Trie](https://javaguide.cn/cs-basics/data-structure/trie.html)、[并查集](https://javaguide.cn/cs-basics/data-structure/union-find.html)、[跳表](https://javaguide.cn/cs-basics/data-structure/skip-list.html)、[红黑树](https://javaguide.cn/cs-basics/data-structure/red-black-tree.html)、[布隆过滤器](https://javaguide.cn/cs-basics/data-structure/bloom-filter.html)、[LRU](https://javaguide.cn/cs-basics/data-structure/lru-cache.html)。 +算法与数据结构建议合并复习,不要只背概念或只刷题。时间紧时按 7 天路线走:复杂度和排序、数组/链表、二分/双指针/滑动窗口、树和图、回溯和动态规划、哈希/堆/Top K、错题复盘。时间充足时按 30 天路线走:先打牢线性结构和哈希表,再刷树图、回溯、动态规划、贪心、Top K,最后只复盘错题和边界样例。 + **自测**:能画访问网页全过程、TCP 握手挥手等等;算法题能手写常见套路;OS 进程/线程、内存、死锁能说清概念与例子。 ### 第五阶段:分布式与高并发(按简历与岗位) diff --git a/docs/java/collection/java-collection-questions-01.md b/docs/java/collection/java-collection-questions-01.md index ad6d14f797d..ee2d2e04fc2 100644 --- a/docs/java/collection/java-collection-questions-01.md +++ b/docs/java/collection/java-collection-questions-01.md @@ -29,7 +29,7 @@ Java 集合框架如下图所示: - `List`(对付顺序的好帮手): 存储的元素是有序的、可重复的。 - `Set`(注重独一无二的性质): 存储的元素不可重复的。 - `Queue`(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序,存储的元素是有序的、可重复的。 -- `Map`(用 key 来搜索的专家): 使用键值对(key-value)存储,类似于数学上的函数 y=f(x),"x" 代表 key,"y" 代表 value,key 无序、不可重复,value 无序、可重复,每个键最多映射到一个值。注意,这里的"无序"指的是 `HashMap` 这类实现——键值对之间没有显式的关联顺序。`LinkedHashMap` 和 `TreeMap` 等实现则是有序的,它们通过额外的数据结构(双向链表或红黑树)来维护键值对的顺序。 +- `Map`(用 key 来搜索的专家): 使用键值对(key-value)存储,类似于数学上的函数 y=f(x),"x" 代表 key,"y" 代表 value,key 无序、不可重复,value 无序、可重复,每个键最多映射到一个值。注意,这里的“无序”指的是 `HashMap` 这类实现——键值对之间没有显式的关联顺序。`LinkedHashMap` 和 `TreeMap` 等实现则是有序的,它们通过额外的数据结构(双向链表或红黑树)来维护键值对的顺序。 ### 集合框架底层数据结构总结 @@ -612,4 +612,13 @@ Java 中常用的阻塞队列实现类有以下几种: - 锁是否分离: `ArrayBlockingQueue`中的锁是没有分离的,即生产和消费用的是同一个锁;`LinkedBlockingQueue`中的锁是分离的,即生产用的是`putLock`,消费是`takeLock`,这样可以防止生产者和消费者线程之间的锁争夺。 - 内存占用:`ArrayBlockingQueue` 需要提前分配数组内存,而 `LinkedBlockingQueue` 则是动态分配链表节点内存。这意味着,`ArrayBlockingQueue` 在创建时就会占用一定的内存空间,且往往申请的内存比实际所用的内存更大,而`LinkedBlockingQueue` 则是根据元素的增加而逐渐占用内存空间。 +## 数据结构延伸阅读 + +Java 集合面试经常会追到底层数据结构。建议结合下面几篇一起复习: + +- [线性数据结构详解](../../cs-basics/data-structure/linear-data-structure.md):理解数组、链表、栈、队列和 `ArrayList`、`LinkedList`、`ArrayDeque` 的关系。 +- [哈希表面试题总结](../../cs-basics/data-structure/hash-table.md):理解哈希冲突、扩容和 `HashMap` 的底层思想。 +- [红黑树详解](../../cs-basics/data-structure/red-black-tree.md):理解 `TreeMap`、`TreeSet` 以及 `HashMap` 树化链表时涉及的红黑树。 +- [堆详解](../../cs-basics/data-structure/heap.md):理解 `PriorityQueue` 的底层结构和 Top K 题型。 + From 6c78c91a6fb5edd999a7e8c6da5a7c09416c03a2 Mon Sep 17 00:00:00 2001 From: Guide Date: Fri, 12 Jun 2026 23:50:58 +0800 Subject: [PATCH 013/116] docs: improve cs basics guides and assets --- .../10-classical-sorting-algorithms.md | 18 +-- .../algorithms/the-sword-refers-to-offer.md | 2 +- docs/cs-basics/data-structure/bloom-filter.md | 2 +- docs/cs-basics/data-structure/hash-table.md | 73 ++++++++++- docs/cs-basics/data-structure/heap.md | 44 +++---- .../data-structure/linear-data-structure.md | 4 +- docs/cs-basics/data-structure/lru-cache.md | 118 ++++++++++++++++++ ...\351\241\266\345\205\203\347\264\2401.png" | Bin 8265 -> 0 bytes ...\351\241\266\345\205\203\347\264\2402.png" | Bin 8407 -> 0 bytes ...\351\241\266\345\205\203\347\264\2403.png" | Bin 8422 -> 0 bytes ...\351\241\266\345\205\203\347\264\2404.png" | Bin 8479 -> 0 bytes ...\351\241\266\345\205\203\347\264\2405.png" | Bin 8628 -> 0 bytes ...\351\241\266\345\205\203\347\264\2406.png" | Bin 8637 -> 0 bytes ...\345\205\245\345\205\203\347\264\2401.png" | Bin 11282 -> 0 bytes ...\345\205\245\345\205\203\347\264\2402.png" | Bin 14126 -> 0 bytes ...\345\205\245\345\205\203\347\264\2403.png" | Bin 14172 -> 0 bytes .../pictures/\345\240\206/\345\240\2061.png" | Bin 14094 -> 0 bytes .../pictures/\345\240\206/\345\240\2062.png" | Bin 11686 -> 0 bytes ...\345\240\206\346\216\222\345\272\2171.png" | Bin 5904 -> 0 bytes ...\345\240\206\346\216\222\345\272\2172.png" | Bin 5429 -> 0 bytes ...\345\240\206\346\216\222\345\272\2173.png" | Bin 4870 -> 0 bytes ...\345\240\206\346\216\222\345\272\2174.png" | Bin 4249 -> 0 bytes ...\345\240\206\346\216\222\345\272\2175.png" | Bin 3263 -> 0 bytes ...\345\240\206\346\216\222\345\272\2176.png" | Bin 2453 -> 0 bytes ...6\347\232\204\345\255\230\345\202\250.png" | Bin 10847 -> 0 bytes .../\345\273\272\345\240\2061.png" | Bin 6217 -> 0 bytes .../\345\273\272\345\240\2062.png" | Bin 6407 -> 0 bytes .../\345\273\272\345\240\2063.png" | Bin 6379 -> 0 bytes .../\345\273\272\345\240\2064.png" | Bin 6345 -> 0 bytes ...\347\272\242\351\273\221\346\240\2211.PNG" | Bin 11626 -> 0 bytes ...\347\272\242\351\273\221\346\240\2211.png" | Bin 11626 -> 0 bytes ...\347\272\242\351\273\221\346\240\2212.PNG" | Bin 11668 -> 0 bytes ...\347\272\242\351\273\221\346\240\2212.png" | Bin 11668 -> 0 bytes ...\347\272\242\351\273\221\346\240\2213.PNG" | Bin 12764 -> 0 bytes ...\347\272\242\351\273\221\346\240\2213.png" | Bin 12764 -> 0 bytes ...\347\272\242\351\273\221\346\240\2214.PNG" | Bin 11158 -> 0 bytes ...\347\272\242\351\273\221\346\240\2214.png" | Bin 11158 -> 0 bytes ...\347\272\242\351\273\221\346\240\2215.PNG" | Bin 13184 -> 0 bytes ...\347\272\242\351\273\221\346\240\2215.png" | Bin 13184 -> 0 bytes ...\347\272\242\351\273\221\346\240\2216.PNG" | Bin 10965 -> 0 bytes ...\347\272\242\351\273\221\346\240\2216.png" | Bin 10965 -> 0 bytes ...\345\215\225\351\223\276\350\241\2502.png" | Bin 7550 -> 0 bytes ...2\347\216\257\351\223\276\350\241\250.png" | Bin 10091 -> 0 bytes ...4\345\220\221\351\223\276\350\241\250.png" | Bin 9295 -> 0 bytes ...\345\210\227-\345\240\206\346\273\241.png" | Bin 5642 -> 0 bytes .../\346\225\260\347\273\204.png" | Bin 3369 -> 0 bytes .../\346\240\210.png" | Bin 6009 -> 0 bytes ...45\222\214\345\211\215\350\277\233.drawio" | 1 - ...0\345\222\214\345\211\215\350\277\233.png" | Bin 10045 -> 0 bytes .../\351\230\237\345\210\227.png" | Bin 2434 -> 0 bytes ...7\345\201\207\346\272\242\345\207\272.png" | Bin 4067 -> 0 bytes .../data-structure/red-black-tree.md | 17 +-- docs/cs-basics/data-structure/skip-list.md | 84 +++++++++++++ docs/cs-basics/data-structure/trie.md | 80 ++++++++++++ docs/cs-basics/data-structure/union-find.md | 87 ++++++++++++- docs/cs-basics/network/arp.md | 4 +- .../can-ping-but-tcp-may-not-connect.md | 2 +- .../can-tcp-and-udp-use-the-same-port.md | 2 +- .../computer-network-xiexiren-summary.md | 16 +-- docs/cs-basics/network/dns.md | 14 +-- docs/cs-basics/network/http-status-codes.md | 2 +- docs/cs-basics/network/http-vs-https.md | 12 +- docs/cs-basics/network/http-vs-rpc.md | 4 +- docs/cs-basics/network/http1.0-vs-http1.1.md | 8 +- docs/cs-basics/network/https-rsa-vs-ecdhe.md | 2 +- ...imum-number-of-tcp-connections-per-host.md | 4 +- docs/cs-basics/network/nat.md | 2 +- .../cs-basics/network/network-attack-means.md | 42 +++---- .../cs-basics/network/osi-and-tcp-ip-model.md | 8 +- .../network/other-network-questions.md | 20 +-- .../network/other-network-questions2.md | 8 +- .../tcp-keepalive-vs-http-keepalive.md | 2 +- docs/cs-basics/network/tcp-time-wait.md | 2 +- ...he-whole-process-of-accessing-web-pages.md | 2 +- .../cs-basics/operating-system/linux-intro.md | 6 +- .../operating-system-basic-questions-01.md | 12 +- .../cs-basics/operating-system/shell-intro.md | 2 +- 77 files changed, 568 insertions(+), 138 deletions(-) delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2401.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2402.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2403.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2404.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2405.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2406.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2401.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2402.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2403.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\2061.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\2062.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2171.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2172.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2173.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2174.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2175.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2176.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\347\232\204\345\255\230\345\202\250.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2061.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2062.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2063.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2064.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2211.PNG" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2211.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2212.PNG" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2212.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2213.PNG" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2213.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2214.PNG" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2214.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2215.PNG" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2215.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2216.PNG" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2216.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\215\225\351\223\276\350\241\2502.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\217\214\345\220\221\345\276\252\347\216\257\351\223\276\350\241\250.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\217\214\345\220\221\351\223\276\350\241\250.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\276\252\347\216\257\351\230\237\345\210\227-\345\240\206\346\273\241.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\346\225\260\347\273\204.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\346\240\210.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\346\240\210\345\256\236\347\216\260\346\265\217\350\247\210\345\231\250\345\200\222\351\200\200\345\222\214\345\211\215\350\277\233.drawio" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\346\240\210\345\256\236\347\216\260\346\265\217\350\247\210\345\231\250\345\200\222\351\200\200\345\222\214\345\211\215\350\277\233.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\351\230\237\345\210\227.png" delete mode 100644 "docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\351\241\272\345\272\217\351\230\237\345\210\227\345\201\207\346\272\242\345\207\272.png" diff --git a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md index c11c663b789..93ba2380690 100644 --- a/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md +++ b/docs/cs-basics/algorithms/10-classical-sorting-algorithms.md @@ -126,7 +126,7 @@ public static int[] bubbleSort(int[] arr) { ### 图解算法 -![Selection Sort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/selection_sort.gif) +![选择排序每轮选择最小元素放到已排序区末尾](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/selection_sort.gif) ### 代码实现 @@ -180,7 +180,7 @@ public static int[] selectionSort(int[] arr) { ### 图解算法 -![insertion_sort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/insertion_sort.gif) +![插入排序过程演示](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/insertion_sort.gif) ### 代码实现 @@ -229,7 +229,7 @@ public static int[] insertionSort(int[] arr) { ### 图解算法 -![shell_sort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/shell_sort.png) +![希尔排序按增量分组并插入排序的过程](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/shell_sort.png) ### 代码实现 @@ -286,7 +286,7 @@ public static int[] shellSort(int[] arr) { ### 图解算法 -![MergeSort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/merge_sort.gif) +![归并排序递归拆分数组并合并有序子数组](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/merge_sort.gif) ### 代码实现 @@ -371,7 +371,7 @@ public static int[] merge(int[] arr_1, int[] arr_2) { ### 图解算法 -![RandomQuickSort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/random_quick_sort.gif) +![随机快速排序选择基准并递归划分子序列](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/random_quick_sort.gif) ### 代码实现 @@ -451,7 +451,7 @@ class Solution { ### 图解算法 -![HeapSort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/heap_sort.gif) +![堆排序构建大顶堆并依次取出堆顶元素](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/heap_sort.gif) ### 代码实现 @@ -545,7 +545,7 @@ public static int[] heapSort(int[] arr) { ### 图解算法 -![CountingSort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/counting_sort.gif) +![计数排序通过统计元素出现次数确定有序位置](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/counting_sort.gif) ### 代码实现 @@ -626,7 +626,7 @@ public static int[] countingSort(int[] arr) { ### 图解算法 -![BucketSort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/bucket_sort.gif) +![桶排序将数据分配到多个桶后分别排序再合并](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/bucket_sort.gif) ### 代码实现 @@ -707,7 +707,7 @@ public static List bucketSort(List arr, int bucket_size) { ### 图解算法 -![RadixSort](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/radix_sort.gif) +![基数排序按数字位从低到高依次排序并收集](https://oss.javaguide.cn/github/javaguide/cs-basics/sorting-algorithms/radix_sort.gif) ### 代码实现 diff --git a/docs/cs-basics/algorithms/the-sword-refers-to-offer.md b/docs/cs-basics/algorithms/the-sword-refers-to-offer.md index c8e6348dde6..6e97222e8f3 100644 --- a/docs/cs-basics/algorithms/the-sword-refers-to-offer.md +++ b/docs/cs-basics/algorithms/the-sword-refers-to-offer.md @@ -429,7 +429,7 @@ public class Solution { 思路就是我们根据链表的特点,前一个节点指向下一个节点的特点,把后面的节点移到前面来。 就比如下图:我们把 1 节点和 2 节点互换位置,然后再将 3 节点指向 2 节点,4 节点指向 3 节点,这样以来下面的链表就被反转了。 -![链表](https://oss.javaguide.cn/p3-juejin/844773c7300e4373922bb1a6ae2a55a3~tplv-k3u1fbpfcp-zoom-1.png) +![反转链表时交换相邻节点指向的过程](https://oss.javaguide.cn/p3-juejin/844773c7300e4373922bb1a6ae2a55a3~tplv-k3u1fbpfcp-zoom-1.png) **考察内容:** diff --git a/docs/cs-basics/data-structure/bloom-filter.md b/docs/cs-basics/data-structure/bloom-filter.md index 1387a2f0b6c..faaf5f212ad 100644 --- a/docs/cs-basics/data-structure/bloom-filter.md +++ b/docs/cs-basics/data-structure/bloom-filter.md @@ -33,7 +33,7 @@ head: Bloom Filter 会使用一个较大的 bit 数组来保存所有的数据,数组中的每个元素都只占用 1 bit,并且每个元素只能是 0 或者 1(代表 false 或者 true),这也是 Bloom Filter 节省内存的核心所在。这样来算的话,申请一个 100w 个元素的位数组只占用 1000000 Bit / 8 = 125000 Byte = 125000 / 1024 KB ≈ 122 KB 的空间。 -![位数组](https://oss.javaguide.cn/github/javaguide/cs-basics/algorithms/bloom-filter-bit-table.png) +![布隆过滤器使用的位数组结构](https://oss.javaguide.cn/github/javaguide/cs-basics/algorithms/bloom-filter-bit-table.png) 总结:**一个名叫 Bloom 的人提出了一种来检索元素是否在给定大集合中的数据结构,这种数据结构是高效且性能很好的,但缺点是具有一定的错误识别率和删除难度。并且,理论情况下,添加到集合中的元素越多,误报的可能性就越大。** diff --git a/docs/cs-basics/data-structure/hash-table.md b/docs/cs-basics/data-structure/hash-table.md index 8e82f0607e0..2fcff615f6d 100644 --- a/docs/cs-basics/data-structure/hash-table.md +++ b/docs/cs-basics/data-structure/hash-table.md @@ -10,10 +10,56 @@ head: content: 哈希表,HashMap,哈希函数,哈希冲突,拉链法,开放寻址法,负载因子,扩容,Java集合,数据结构面试题 --- -哈希表的面试价值很高,因为它一头连着算法题里的快速查找和计数,另一头连着 Java `HashMap`、缓存、去重和分布式系统里的分片路由。 +哈希表(Hash Table,也叫散列表)的面试价值很高,因为它一头连着算法题里的快速查找和计数,另一头连着 Java `HashMap`、缓存、去重和分布式系统里的分片路由。 这个问题问的是:如何把一个 key 快速映射到数组下标,并在冲突、扩容和极端数据下仍然保持可接受的查询效率。 +文章内容概览: + +1. 什么是哈希表? +2. 哈希表怎么从 key 定位到数组下标? +3. 哈希冲突、负载因子和扩容分别解决什么问题? +4. Java `HashMap` 和普通哈希表有什么关系? +5. 哈希表在算法题和工程场景中怎么用? + +![哈希表通过哈希函数把键映射到数组位置的结构示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/hash-table.png) + +## 什么是哈希表? + +哈希表是一种用来存储 key-value 映射关系的数据结构。我们平时说的 Map、Dictionary、Associative Array,本质上都可以用哈希表来实现。 + +如果 key 是连续整数,比如学生编号刚好是 `0` 到 `999`,直接用数组就能做到 `students[id]` 这种 `O(1)` 访问。但真实业务里的 key 通常不是这么规整:可能是字符串、用户 ID、订单号、URL,也可能是自定义对象。哈希表要做的事情,就是先把这些不同类型、不同长度的 key 通过哈希函数转换成一个整数,再把这个整数映射到数组下标。 + +可以把哈希表拆成三层来看: + +1. **数组**:真正存放数据的位置,也常被称为桶(bucket)。 +2. **哈希函数**:负责把 key 转换成哈希值。 +3. **冲突解决策略**:当多个 key 落到同一个桶时,决定这些 key 怎么继续存。 + +所以,哈希表不是“完全没有查找过程”,而是通过哈希函数把查找范围大幅缩小:理想情况下,一次定位就能找到目标桶;发生冲突时,再在桶内部做少量比较。 + +## 为什么需要哈希表? + +假设要判断一个 URL 是否已经爬取过,最直接的方式是把爬过的 URL 放到列表里,每来一个新 URL 就从头扫一遍。数据量很小时问题不大,但如果已经爬了几百万个 URL,每次都线性扫描,性能很快就扛不住。 + +哈希表的思路是用空间换时间:多开一块数组空间,把 URL 通过哈希函数分散到不同桶里。查询时不再从头遍历所有 URL,而是先计算哈希值,直接跳到对应桶附近查找。 + +这也是哈希表适合做查找、计数、去重、缓存索引的原因。它不关心元素之间的大小关系,也不保证有序;它关心的是“给定 key,能不能尽快找到对应的 value”。 + +## 哈希函数要解决什么问题? + +哈希函数的目标不是把 key 变得神秘,而是尽量把 key 均匀地分散到数组里。一个好的哈希函数通常要满足三个要求: + +| 要求 | 含义 | +| ---------- | ------------------------------------------------ | +| 稳定 | 同一个 key 多次计算得到的哈希值应该一致 | +| 计算快 | 哈希函数本身不能太慢,否则会抵消哈希表的性能优势 | +| 分布尽量散 | 不同 key 尽量落到不同位置,减少哈希冲突 | + +需要注意的是,普通哈希表里的哈希函数和密码学哈希不是一回事。哈希表更关注速度和分布质量;密码学哈希更关注抗碰撞、抗篡改等安全性质。 + +在 Java 里,自定义对象作为 `HashMap` 的 key 时,`hashCode()` 和 `equals()` 必须配合好:如果两个对象通过 `equals()` 判断相等,它们的 `hashCode()` 也必须相同;但两个对象的 `hashCode()` 相同,不代表它们一定相等。这一点正是哈希冲突会存在的根源之一。 + ## 面试考察重点 - 哈希函数负责把 key 映射成数组下标。 @@ -24,7 +70,7 @@ head: ## 哈希表怎么工作? -哈希表通常由数组和哈希函数组成: +以插入一个 key-value 为例,哈希表通常会做这几步: 1. 对 key 计算哈希值。 2. 根据数组长度把哈希值映射成下标。 @@ -37,6 +83,8 @@ int index = hash(key) & (table.length - 1); `HashMap` 的容量是 2 的幂时,可以用位运算替代取模。位运算更快,也方便扩容后重新分布。 +这里的 `hash(key)` 通常不是直接使用对象原始的 `hashCode()`,还会做一次扰动,让高位信息也参与到低位下标计算中。原因也很好理解:当数组长度是 2 的幂时,`length - 1` 的二进制低位全是 1,直接 `&` 会更依赖哈希值低位。如果低位分布不好,冲突就会更集中。 + ## 哈希冲突怎么解决? | 方法 | 思路 | 典型应用 | 注意点 | @@ -47,6 +95,10 @@ int index = hash(key) & (table.length - 1); Java `HashMap` 主要使用拉链法。JDK 8 开始,当链表长度达到阈值并且数组容量足够大时,会把链表转换成红黑树,降低极端冲突下的查询成本。 +拉链法的优点是实现直观,删除也比较容易。数组中的每个桶不只放一个元素,而是挂一条链表,冲突的元素追加到这条链上。查询时先通过哈希定位桶,再在桶里的链表或树中比较 key。 + +开放寻址法则不额外挂链表,所有元素都放在数组内部。发生冲突后,它会按照某种探测规则继续找下一个可用位置,比如线性探测、二次探测、双重哈希。它的好处是内存局部性通常更好,但删除元素、控制负载因子和处理连续聚集会更麻烦。 + ## 负载因子和扩容 负载因子表示哈希表使用程度: @@ -59,6 +111,16 @@ Java `HashMap` 主要使用拉链法。JDK 8 开始,当链表长度达到阈 扩容会带来一次 rehash 成本。面试里可以这样回答:哈希表单次插入平均是 `O(1)`,但触发扩容的那次会搬迁元素;从摊还角度看,多次插入仍然可以看作平均 `O(1)`。 +负载因子不能只看“空间利用率”。负载因子越高,数组越满,空间越省,但冲突概率也会上升;负载因子越低,冲突少一些,但会浪费更多桶位。`0.75` 是 Java `HashMap` 在时间和空间之间做的一个经验折中。 + +## 哈希表为什么平均是 O(1)? + +哈希表的 `O(1)` 说的是平均情况或者期望情况,不是所有输入下的绝对保证。 + +在哈希函数分布比较均匀、负载因子控制得当时,元素会比较分散,每个桶里的元素数量很少。因此查询时的主要成本就是:计算哈希值、定位数组下标、在桶里做少量比较,这些操作可以看作常数级。 + +但如果大量 key 落到同一个桶,哈希表就会退化。使用拉链法时,桶内链表太长,查询会接近 `O(n)`;JDK 8 之后的 `HashMap` 会在满足条件时树化,把极端冲突下的桶内查询成本降到 `O(logn)` 级别,但这不代表哈希表永远不会受冲突影响。 + ## 和 Java HashMap 的关系 `HashMap` 常见追问: @@ -163,4 +225,11 @@ int subarraySum(int[] nums, int k) { - [560. 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k/) - [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/) +## 参考资料 + +- [Algorithms, 4th Edition:Hash Tables](https://algs4.cs.princeton.edu/34hash/) +- [Java SE 21 API:HashMap](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/HashMap.html) +- [OpenJDK:HashMap 源码](https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/HashMap.java) +- [Java SE 21 API:Object#hashCode](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Object.html#hashCode%28%29) + diff --git a/docs/cs-basics/data-structure/heap.md b/docs/cs-basics/data-structure/heap.md index a55d4f59018..5beffd5a39f 100644 --- a/docs/cs-basics/data-structure/heap.md +++ b/docs/cs-basics/data-structure/heap.md @@ -27,7 +27,7 @@ head: 大家可以尝试判断下面给出的图是否是堆? -![](./pictures/堆/堆1.png) +![判断是否满足堆性质的示例](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-1.png) 第 1 个和第 2 个是堆。第 1 个是最大堆,每个节点都比子树中所有节点大。第 2 个是最小堆,每个节点都比子树中所有节点小。 @@ -52,7 +52,7 @@ head: 如下图所示,图 1 是最大堆,图 2 是最小堆 -![](./pictures/堆/堆2.png) +![最大堆和最小堆示例](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-2.png) ## 堆的存储 @@ -60,7 +60,7 @@ head: 为了方便存储和索引,(二叉)堆可以用完全二叉树的形式进行存储。存储的方式如下图所示: -![堆的存储](./pictures/堆/堆的存储.png) +![堆的数组顺序存储示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-storage.png) ## 堆的操作 @@ -74,15 +74,15 @@ head: **1. 将要插入的元素放到最后** -![堆-插入元素-1](./pictures/堆/堆-插入元素1.png) +![堆插入元素:新元素放到数组末尾](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-insert-1.png) > 有能力的人会逐渐升职加薪,是金子总会发光的!!! **2. 从底向上,如果父结点比该元素小,则该节点和父结点交换,直到无法交换** -![堆-插入元素2](./pictures/堆/堆-插入元素2.png) +![堆插入元素:新元素与父节点比较并上浮](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-insert-2.png) -![堆-插入元素3](./pictures/堆/堆-插入元素3.png) +![堆插入元素:上浮后恢复堆性质](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-insert-3.png) ### 删除堆顶元素 @@ -99,19 +99,19 @@ head: 首先删除堆顶元素,使得数组中下标为 1 的位置空出。 -![删除堆顶元素1](./pictures/堆/删除堆顶元素1.png) +![删除堆顶元素:移除根节点](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-delete-top-1.png) > 那么他的位置由谁来接替呢,当然是他的直接下属了,谁能力强就让谁上呗 比较根结点的左子节点和右子节点,也就是下标为 2,3 的数组元素,将较大的元素填充到根结点(下标为 1)的位置。 -![删除堆顶元素2](./pictures/堆/删除堆顶元素2.png) +![删除堆顶元素:较大的子节点上移到根节点](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-delete-top-2.png) > 这个时候又空出一个位置了,老规矩,谁有能力谁上 一直循环比较空出位置的左右子节点,并将较大者移至空位,直到堆的最底部 -![删除堆顶元素3](./pictures/堆/删除堆顶元素3.png) +![删除堆顶元素:自底向上堆化后留下空位](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-delete-top-3.png) 这个时候已经完成了自底向上的堆化,没有元素可以填补空缺了,但是,我们可以看到数组中出现了“气泡”,这会导致存储空间的浪费。接下来我们试试自顶向下堆化。 @@ -119,13 +119,13 @@ head: 自顶向下的堆化用一个词形容就是“石沉大海”,那么第一件事情,就是把石头抬起来,从海面扔下去。这个石头就是堆的最后一个元素,我们将最后一个元素移动到堆顶。 -![删除堆顶元素4](./pictures/堆/删除堆顶元素4.png) +![删除堆顶元素:将末尾元素移动到堆顶](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-delete-top-4.png) 然后开始将这个石头沉入海底,不停与左右子节点的值进行比较,和较大的子节点交换位置,直到无法交换位置。 -![删除堆顶元素5](./pictures/堆/删除堆顶元素5.png) +![删除堆顶元素:堆顶元素向下调整](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-delete-top-5.png) -![删除堆顶元素6](./pictures/堆/删除堆顶元素6.png) +![删除堆顶元素:自顶向下堆化完成](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-delete-top-6.png) ### 堆的操作总结 @@ -147,21 +147,21 @@ head: 具体过程如下图: -![建堆1](./pictures/堆/建堆1.png) +![建堆过程:初始无序数组对应的完全二叉树](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-build-1.png) 将初始的无序数组抽象为一棵树,图中的节点个数为 6,所以 4,5,6 节点为叶节点,1,2,3 节点为非叶节点,所以要对 1-3 号节点进行自顶向下(沉底)堆化,注意,顺序是从后往前堆化,从 3 号节点开始,一直到 1 号节点。 3 号节点堆化结果: -![建堆1](./pictures/堆/建堆2.png) +![建堆过程:3 号节点完成下沉](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-build-2.png) 2 号节点堆化结果: -![建堆1](./pictures/堆/建堆3.png) +![建堆过程:2 号节点完成下沉](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-build-3.png) 1 号节点堆化结果: -![建堆1](./pictures/堆/建堆4.png) +![建堆过程:1 号节点完成下沉并形成最大堆](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-build-4.png) 至此,数组所对应的树已经成为了一个最大堆,建堆完成! @@ -182,27 +182,27 @@ head: 取出第一个元素并堆化: -![堆排序1](./pictures/堆/堆排序1.png) +![堆排序过程:第 1 轮取出堆顶元素并堆化](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-sort-1.png) 取出第二个元素并堆化: -![堆排序2](./pictures/堆/堆排序2.png) +![堆排序过程:第 2 轮取出堆顶元素并堆化](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-sort-2.png) 取出第三个元素并堆化: -![堆排序3](./pictures/堆/堆排序3.png) +![堆排序过程:第 3 轮取出堆顶元素并堆化](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-sort-3.png) 取出第四个元素并堆化: -![堆排序4](./pictures/堆/堆排序4.png) +![堆排序过程:第 4 轮取出堆顶元素并堆化](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-sort-4.png) 取出第五个元素并堆化: -![堆排序5](./pictures/堆/堆排序5.png) +![堆排序过程:第 5 轮取出堆顶元素并堆化](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-sort-5.png) 取出第六个元素并堆化: -![堆排序6](./pictures/堆/堆排序6.png) +![堆排序过程:所有元素完成排序](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/heap-sort-6.png) 堆排序完成! diff --git a/docs/cs-basics/data-structure/linear-data-structure.md b/docs/cs-basics/data-structure/linear-data-structure.md index 45a62e573cb..04f5b5200f6 100644 --- a/docs/cs-basics/data-structure/linear-data-structure.md +++ b/docs/cs-basics/data-structure/linear-data-structure.md @@ -104,7 +104,7 @@ head: 插入删除:O(1) //顶端插入和删除元素 ``` -![栈](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/%E6%A0%88.png) +![栈的后进先出结构示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/stack.png) ### 3.2. 栈的常见应用场景 @@ -114,7 +114,7 @@ head: 我们只需要使用两个栈(Stack1 和 Stack2)就能实现这个功能。比如你按顺序查看了 1,2,3,4 这四个页面,我们依次把 1,2,3,4 这四个页面压入 Stack1 中。当你想回头看 2 这个页面的时候,你点击回退按钮,我们依次把 4,3 这两个页面从 Stack1 弹出,然后压入 Stack2 中。假如你又想回到页面 3,你点击前进按钮,我们将 3 页面从 Stack2 弹出,然后压入到 Stack1 中。示例图如下: -![栈实现浏览器倒退和前进](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/%E6%A0%88%E5%AE%9E%E7%8E%B0%E6%B5%8F%E8%A7%88%E5%99%A8%E5%80%92%E9%80%80%E5%92%8C%E5%89%8D%E8%BF%9B.png) +![使用两个栈实现浏览器后退和前进功能](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/stack-browser-back-forward.png) #### 3.2.2. 检查符号是否成对出现 diff --git a/docs/cs-basics/data-structure/lru-cache.md b/docs/cs-basics/data-structure/lru-cache.md index 9bc4e69686d..604fc88cd97 100644 --- a/docs/cs-basics/data-structure/lru-cache.md +++ b/docs/cs-basics/data-structure/lru-cache.md @@ -14,6 +14,53 @@ LRU 是 Least Recently Used 的缩写,意思是最近最少使用。当缓存 面试里手写 LRU 很高频,因为它把哈希表和双向链表结合在一起:哈希表负责 `O(1)` 查找节点,双向链表负责 `O(1)` 移动节点和删除尾节点。 +文章内容概览: + +1. 什么是 LRU 缓存? +2. LRU 为什么适合做缓存淘汰? +3. 为什么需要哈希表 + 双向链表? +4. 如何手写 `get` 和 `put`? +5. Java `LinkedHashMap` 如何实现 LRU? +6. 真实工程里的 LRU 还要考虑什么? + +![LRU 缓存通过哈希表和双向链表维护最近访问顺序](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/lru-cache.png) + +## 什么是 LRU 缓存? + +缓存的核心矛盾是:空间有限,但希望尽量把“未来还会被访问”的数据留在内存里。 + +问题是,程序并不知道未来。LRU 的做法是用“最近访问过”去近似预测“接下来还可能访问”。如果一个数据刚刚被访问过,它很可能还会再被访问;如果一个数据很久没被访问,缓存满的时候就优先淘汰它。 + +举个例子,容量为 2 的缓存按顺序访问: + +```text +put(1, 1) +put(2, 2) +get(1) +put(3, 3) +``` + +在 `put(3, 3)` 之前,缓存里有 `1` 和 `2`。虽然 `1` 更早插入,但它刚被 `get(1)` 访问过,所以最近最少使用的是 `2`,最终应该淘汰 `2`。 + +这个例子也说明了一点:LRU 看的不是“谁最早插入”,而是“谁最久没被访问”。 + +## 为什么需要缓存淘汰策略? + +缓存不是无限大的。无论是本地内存缓存、Redis、数据库 Buffer Pool,还是操作系统里的页面缓存,都要面对容量上限。 + +容量满了之后,如果没有淘汰策略,就只能拒绝新数据或者随机删数据。随机删当然简单,但可能把刚好很热的数据删掉,导致命中率变差。LRU 则利用访问时间顺序做了一个经验判断:长期没被碰过的数据,短期内再次访问的概率通常更低。 + +常见淘汰策略可以简单对比一下: + +| 策略 | 淘汰依据 | 特点 | +| ---- | -------------------- | -------------------------------------------- | +| FIFO | 最早进入缓存的数据 | 实现简单,但不关心数据后来是否被频繁访问 | +| LRU | 最久没有被访问的数据 | 适合有时间局部性的访问模式 | +| LFU | 访问次数最少的数据 | 适合长期热点明显的场景,但需要维护频率信息 | +| TTL | 过期时间 | 适合数据有明确有效期的场景,不等同于容量淘汰 | + +LRU 之所以常被拿来面试,是因为它既有真实工程背景,又能很好地考察数据结构组合。 + ## 面试考察重点 - 能说清为什么只用哈希表或只用链表都不够。 @@ -22,6 +69,21 @@ LRU 是 Least Recently Used 的缩写,意思是最近最少使用。当缓存 - 能处理容量满、更新已有 key、删除尾节点等边界。 - 能知道 Java `LinkedHashMap` 可以实现 LRU。 +## LRU 的访问顺序怎么维护? + +LRU 缓存里,每一次访问都会改变数据的新旧程度。 + +通常我们会约定: + +- 链表头部表示最近使用的数据。 +- 链表尾部表示最久未使用的数据。 +- `get(key)` 命中后,把对应节点移动到头部。 +- `put(key, value)` 如果是新 key,把新节点插入头部。 +- `put(key, value)` 如果是已有 key,更新 value 后也要移动到头部。 +- 容量超过上限时,删除尾部节点。 + +这里最容易漏的是 `get()`。很多同学会觉得 `get()` 只是读数据,不该改结构。但对 LRU 来说,读也是一次访问;只要命中缓存,这个 key 的“最近使用时间”就变新了。 + ## 数据结构设计 | 组件 | 作用 | @@ -32,6 +94,18 @@ LRU 是 Least Recently Used 的缩写,意思是最近最少使用。当缓存 访问一个 key 后,需要把它移动到链表头部。插入新 key 时,也放到头部。容量超限时,删除尾部前一个节点。 +为什么必须两个结构配合? + +只用哈希表,可以 `O(1)` 找到 value,但不知道哪个 key 最久没用。你还得额外维护访问顺序。 + +只用链表,可以维护访问顺序,尾部就是该淘汰的节点。但每次根据 key 查找节点都要从头扫到尾,复杂度是 `O(n)`。 + +哈希表 + 双向链表刚好补齐彼此短板: + +- 哈希表让我们能根据 key 直接定位链表节点。 +- 双向链表让我们能快速移动节点、删除尾部节点。 +- 节点里同时存 key 和 value,是为了淘汰尾节点时能从哈希表里删除对应 key。 + ## 面试手写路径 LRU 的代码细节多,建议不要一上来就写完整类。面试时可以先把操作拆开: @@ -44,6 +118,23 @@ LRU 的代码细节多,建议不要一上来就写完整类。面试时可以 这样写的好处是,`get` 和 `put` 都只组合几个基础链表操作,不会在主流程里反复改指针,出错概率低很多。 +## 为什么用双向链表? + +把一个节点移动到头部,需要先把它从原位置摘下来,再插到头节点后面。 + +如果用单向链表,删除当前节点时必须知道它的前驱节点。哈希表里即使能直接找到当前节点,也找不到它前面的节点,还是要从头遍历。 + +双向链表的节点同时有 `prev` 和 `next`,删除任意节点只需要改四个指针: + +```java +node.prev.next = node.next; +node.next.prev = node.prev; +``` + +这就是 LRU 要用双向链表的关键原因:它不只是要删除尾节点,还要在 `get()` 命中和 `put()` 更新已有 key 时,把任意节点移动到头部。 + +虚拟头尾节点也很重要。有了 `head` 和 `tail` 两个哨兵节点,插入头部、删除尾部、处理空链表时都能走同一套代码,不需要到处写 `null` 判断。 + ## 手写 LRU ```java @@ -168,6 +259,24 @@ class LRUCacheWithLinkedHashMap extends LinkedHashMap { 构造函数里的第三个参数 `accessOrder` 设置为 `true`,表示按照访问顺序排序,而不是插入顺序。 +`LinkedHashMap` 官方文档里也专门提到过这种 access-order 模式适合构建 LRU 缓存。这里有两个点要记住: + +1. `accessOrder = false` 时,遍历顺序是插入顺序;`accessOrder = true` 时,遍历顺序是访问顺序。 +2. `removeEldestEntry()` 会在插入新映射后被调用,返回 `true` 时删除最旧的 entry。 + +不过,`LinkedHashMap` 不是线程安全的。如果要在多线程环境里直接用它做本地缓存,需要自己加锁,或者选择成熟缓存库。 + +## LRU 和 Redis 有什么关系? + +Redis 作为缓存使用时,也需要在内存达到 `maxmemory` 上限后执行淘汰策略。Redis 支持 `allkeys-lru`、`volatile-lru` 等策略: + +- `allkeys-lru`:从所有 key 里淘汰最近最少使用的 key。 +- `volatile-lru`:只从设置了过期时间的 key 里淘汰最近最少使用的 key。 + +不过 Redis 的 LRU 不是面试手写题里的“精确 LRU”。为了节省内存和 CPU,Redis 使用的是近似 LRU:随机采样一小批 key,从中挑出最久没访问的 key 淘汰。采样数量可以通过 `maxmemory-samples` 调整。 + +这也能帮助我们理解真实工程和面试题的区别:面试题通常要求用哈希表 + 双向链表实现精确 LRU;工程系统会根据内存、吞吐、并发和命中率做折中。 + ## 工程场景 - 本地缓存淘汰。 @@ -177,6 +286,8 @@ class LRUCacheWithLinkedHashMap extends LinkedHashMap { 真实工程里还要考虑线程安全、过期时间、最大内存、统计指标和淘汰回调。面试手写 LRU 主要考数据结构组合,不需要把这些都写进代码。 +如果是 Java 项目里的本地缓存,很多时候不会自己手写 LRU,而是直接用 Caffeine 这类缓存库。原因也很现实:工程缓存不只要容量淘汰,还要处理过期、并发、加载、统计、异步刷新、不同 entry 的权重等问题。Caffeine 官方文档里就把淘汰分成基于大小、基于时间、基于引用等多类。 + ## 面试追问 | 追问 | 回答重点 | @@ -209,4 +320,11 @@ class LRUCacheWithLinkedHashMap extends LinkedHashMap { - [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/) - [460. LFU 缓存](https://leetcode.cn/problems/lfu-cache/) +## 参考资料 + +- [Java SE 17 API:LinkedHashMap](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/LinkedHashMap.html) +- [Redis Docs:Key eviction](https://redis.io/docs/latest/develop/reference/eviction/) +- [Operating Systems: Three Easy Pieces](https://pages.cs.wisc.edu/~remzi/OSTEP/) +- [Caffeine Wiki:Eviction](https://github.com/ben-manes/caffeine/wiki/Eviction) + diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2401.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2401.png" deleted file mode 100644 index f150d59686893e80e75c1460de1ad949dc9698fc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8265 zcmb7|cQBmq_xBe;^b#dPltldyJxY|-MU)kycTuB+Xt7wG2qB1GmgrrG7H#!zMO|I= z-WF@E<&p2__slcDndgt+@0vL?*LBY8dSBOl&bepqxudkTRLO`R5d#1KGPRdVIsgDJ z6ac`PxsP|}8JX%Ryj#R*YrIjuy}g~=zP{ZYc8+bo3oVs#{rvfJtw{rsiF>&}ie2qQ z&E#%1g02?pju07pBaowh@J|1SofebTpK`NMV#MYZ2?_Co2Q)Vu11{DE(cf}w+s68T z=Ae(~P`iU?YYoWNpUAPVr=!vP@bHtN(1RZLgKpQ2HlvODmw#%cSE|L9D+Cvd+2#u# z&E-<5gY@&O+ETy&;N;?Y%*@vFd##~sGB7ehPVuF(toXx+j|LIDItCVH4SjK`1>-Bo z(fPx~%u+X>U?X!|Xh{>FfH3P*4lzlY_MwI1n$E4Urm&baZ^$QW2X_v($IX3+@{A~F zj{qe#P+q85)vrO+a*vRx_(ET`G*BVuYhX0Q&ECalysa3sI-v1V<%KA}skIZ>)ymz@ zScISZ7y$!^e9_b~GSpVd$;oLfNVprdxp6)|KDxTP@Iv+3+1atNvC`7gFmFd&TU!(g zwXw0$($dmeni3is`ql`P9Qo1J)m2tPsG~Cd`1rWLzyI^+&wG1&U0q#K@A=^c63VQ~ z1pol^M>Qq+Hy`Kr7uD367Vhpic&1jtXMEobc zGCaKachncCC>~C-bE}QY6u1}^e!koPZ5rP&Tl2ln7ti$K7bjx)hOrfGJbOcfh3y=$ zRs3wnojv2;r<6UNN$*@Vi_Cb5s$X{G7>xZSZpAU-rYqh~@uIVB=Z1y6(a5ij(ohZx z-{#C6{YT>$E?*G66WtFkm~JH>h>n{sm(fXIsQu%5d4hvCQ6&3%se{4@zi58i*F0F9 zCv!aLJ2RT$o0sfHFhG*$+|yj*mDp+Y#m0PMimXF_8+S zNI8KJX7*xK-58GgIviWtiHc4jLZ-c#BRAvUVd-WL#TlxV|3ulPjCqG;dc7U_=aBeo z?RyK+41wi){WCLIEa-?x4YtP!NH4-`UN)-9%ddhc;X`^r0@7Eu^PA*;o<}3MSnFrthSEc1y+ZS2<&8c9e zkyCHciY3$2o^y2x*MIym>ly$jeeYXY#JztTg(TbPpuq>%&>dV8zz;|4X4JHmJ71Zc z#`KwVY9ri{n<|BfGtQ}(MNy>>-s=`hNX^R7TWW31OBD$(f(K$s&$Xe%dsFc|744TB zi+G*d!y9}(R#Fa}ZBbHRiYY61j150M%0gVKiM)&lwFc0z<_)b)Jyo;KGdzh{OFzQY zos5;yh_fd(uT2r+2uu3=xN}HKNzHPSDiffNP*t`#`m!twB!Y>}_?$tpvZkg)g6bSE zKi~T`B7sr~I!j_jC4@}z1}Wm`=!LYHbQ(7;`Q7RT%}5XHe@DMBAUTdRnKd(a`Mq(% z*s0yJ;%VPB+dq-z6PBC0X@|zloZrZ5dM?j4r!2F7=Z;+y=kgg8lpf^$L?n9!@p(-@ z-pX$%%C4zQikM7ys5sH9>n#@Q4P0ROXS#I4oIf<%?>c}kxlwS_k4La8KyFxrlDuq& zdD-%08DQRtb~Q~lYnd=qBD8O@d;WTDgi1C7cgsY|qB;dHv$ELc(gtQuK8A|g(_!7; z0Q}aVtXJn*W^y^b9tm#WI9SZcD@VAsdKYLu)UK`5#%ua#+EWJP06NZk$9xaDsbLW+`6I7i-RIF|Qpp`H&&oYJ6-Ze?;7Sy_P# zsoS7d`x??l?)^Xvb%^1aEA%<9FD_fSWfBRm_l@O=PcyjvT5bH|3GUr1(y$LP+~2TF z!P(-Cg<^LUGgO~=i^N=fs2&M=K-c%o)(-{Yo9%x49Rmj$*hS}XV$K(XT=KRbEQfV_J zH$(PBwENfKk~hH#uidWl=!K6xZL<<;4v)bmcW8~08jqwul7b=iRQTJsn4-*ZQt1K% z9?7!NrA!rqLc3SrGRI>+&PgiNgqVv8?zQ_9Xw?qw*pPht$G;Q(L z`P{1T@!CYwu06jg3sd_Hw*AxAHteB&V>zg<$9ARf@*J5nC3y{b-h6x81{oiXxXI<= z#{(9!v=F4fc=G_&F(lnJTBdIN-aK|`#qUn*E%=Y|-Z_|NcSl=uA-wE$M6g|=gW}#Z z-v*&eqk&X1jV;WV_P9Ur0AKMN4H50K3CV~4Yyx*VC~>R}-pMv?L@_I;sGYV+5Q(H( zaC(=_+z({xzk4?KrH_^h7%VX3wC$tVXmybyODPu3b}D?F2!BMbVL;(|PisMF^w>=u zTI`K)x3U!y6?Z<-fOJ(<<)2bp=~hLO9$;S7EGMM~vjJIk54up12alpMC1jN%T=&e2 zw1h>DL(f(FVGMNqPw?ywFTaqMTdk4WtdKHNu;JMw8p#+8yLwaZ;$q|~1k=?gFNED9 zLV3RiKWDlQCC&V^B5GqvMhJR>=Oocc&mhs&vDFVVULxr?Um;2pj3qUt9kQw7vuh<2 zcB}i!VKR%)L2x(2#_UVa>xZ!7fgXUR)WvG%!3t5qq|%yUUi5=FWW3x0#YB=%LrJBx zem(=I zX)s^s)oA~ne!Hk5fZ-;g3~l|+wqg|nv323l8@6b5Gc~;R>u0?mY2jH$|HS69cPVRL zjw~GWylH|F-UUC76Jq&~<;B3H znP>7ly#6s?nDMv*es@!|Sm*Vvs98+bc1I%qYS3p@oKW3i*=Ne}PX1y4Vuw#yEdPVO zY3nCMT+cQ^Q*1&6$yZJ{c+rKlM*FVS_zWL+`f_!#M1F=Xd^)Mt#7~xfg(U=D57qC@ zo2oEdoBOI3o+rU}(G$Y%`^HlDf}m7&wC-i7LLxipT;mQ4AN7}Uv^fFD$f z?$xDNp-aWK&$h@97qBPKEv5(xT<6@10@j?`O37YjnJMxQRZpGIlAjU{AO|7`p3q#> zkzI+B{}_q!S7kFVTwj+7UbK2UgC6q}?iTDvrgb4k+Hp_arIqCk7-MFsH;_GgkLS? z?G_sHL$>FRTR|4xkS@Qe>qvbToGiYa2R!I3q!%>MZ+U{IsnSirGxP#2Zq2*4@eRkQ zW=KH&ANt2L^_2zL#Do-zJ*?#zJKto9Cx21xn`?CP$p)A2Wvtbdq#G2p8M6Ke-(40h zNHxF(IAS;8E`HYqcP8>|X9mu5^krPLhhcy!h-ZMPJiXx%8Fls&lEXgA#llI{ z<)+6UN>6ilr_5(+vY-VPtBl5C#K&_8r=sEG#b!8H{Jr%xMvYVdQ>(853`gR-bJb~o z!AzFHe`3X4TO+yvJ5lo$N(R^VQyyaeZ7(sg6rw4ga(*bRt9bnu1yJOz&EN zgFP6ZK+ic^eQDMKQFaEKQvU2@PSxHSQJX^ZmS0xmfBC5&4u(EN2Me%%LUsH#M9mBqHrKS|&a6AjmV6PCno-$ir z)N3EY|FBSZJyjL9I3=)%-LBAT6xvIfoH(t5IC9P`oj_GM=0|~zoqdn7YPnrkaOkbY z(XBabI5dbw;kf<0nCtE29=B+h10P_U4~A-(v6R=;ySfLV%WTc|2n@XC`WucM*= zy3Dho8Vb;006_-w+L!ujj>uBz-q8_jE?f=}?e+1NiYS2K+Crljv-WaZQcMf zUz~33^v3${f$fHwsP@FMnaAP7VKQla-wEEFyFb+C;k5$ksl3lAjq3^;l%}s=M{Ym< zPoRXpGgkR=0D-$J#?)F)eA_B0Z@J8)8B^(pEhhWQmDu;yb*u}ZV!<)nGT2>jGj+W& z2ZHId6f>R)%AKTJ7ce=SMVs+g9X>J%sQycK3wM0B;j6dGq`A6s{V_$jPas1oxPA6Y zU^K#7H^QFYu}dKmu^Z|g%1l7{XyAEz_NNhvv{+KHg|{UXOJ5qUOpA&*zigm1cTH_G zAC))u>9F94FYS6{XQzjHNYb&0BySONN*(@~Q0=~hGmDDsfNg1{VNo6HoJ-=yAL5c^ z6fY%R`69;@Y% z_NLD<|MK)6R*psOj&Ty?9lSgRr?U^7T?z9?&(58N)o<-X92-ycS%z<=Y=6fAJvpyV z>EmsMbKBs;ZGbaB6C<+INY1?A8}pKV0(5TdZ#gK6dq|$yQ}EF?@`J5Zf2g$zp4t2S zazZ1AE{B}G=Sf&r5?Tf_&(`KsN}F8qyx>E69oZ1)Z&v!hlbYtSDOpGv%Kj6@P((>^;&3G56fWGa;RkiU|CTcULKaDTOStpy zNQ7UW^vTSUJyWMdzx?0eIxEvbfL(<)IrYSnecS4-e9RmsMxByy_KqbFX1Z6|3SZyd zXU_N#sQ(ZCjQy#XVOQZKxq89Ml}6j3p7X0Z)4%Qyb$-z!O^ale@b$gYh>;Sr|DgWC zBTW)Fxoxfqb#NN>H^D0Pq&HOFZ6}?|gp^M3L7o&8)myNWeI=1pHt!QyhCD$5T`K$a8=t3fe{mjZ6IF_G$8KiPAC>^C6&iQEo7MIpArV z#eQNY-bW5e{mYvN6{+itP|6XL5^!)tw^7`Im+^4+n;TEd6^FP*XdBBxj086_u} z_v&j`7`)rPxvOUTb*y}x>5k%`n*t)>&fEP- zx5)%Io$eSXd=aSO-#)T!!vHT1Z5pg7iSq;%6c8Vo=@x&ctqmXDel+7Ei*+HQ-N`;8 zinS3yz*ziPmZ)pvsQg&2mG((`mI#4F80R0T4#mMX+x>uJsu~I=KNgky2!ps*ir}Q) zosCSMsR!->_se(AKA7d1f7(;DRIE%HBs`C7l)Y!?(W>D(#khKP%$LjpL!o=l*{X9r z!2C00gNmjsxK0{{TLT(-E!}r+;gWMEFP&1V)hkLvup}+Gbk$RBiu+EuVwVD(u4qvb z_m`SXZ@qDT?_A1BITJZHZLhoMUME>KrF6GxZcuhk17ma0RXIuecj;s6deFOL;5xCS zaehnh_4Y{7ZKqOQ1F~Qjjv2S8?62=zU|-}tdH;NgOKp6)s-EYqA5i2% z_U>2l|7TpkqoNV3gPUZ-dr*2XPNTdEb(C^+symm_%Vk0P7Xcu9iNL{BAL@ z5@mQ1dCrwle`7N=4RxNqN_=J#SYx{fs&}Tq*w(IcQ-;3|LlPHg%PMJ1e(G)45{<|w z`Wyyxu1SO38l-v-ldHsi9A3Vg+p&bXtSMf8IA zmWpF`>Q6Dns!Y{h{~%oE-YC~eF0I!meL&gE%W`qb=uPjEv=FxsL|&r#@X8VXfe{0tJRP8uL+F#R z44HXF;c1x8`WCMOke2jHCQD{MnDNqYyJGgVXPvlg9DMjF{e)7%W!aY`rG-5AvJILc zIGokuVi7wc<-&YUTsbrV|BnBjYSFLG#m~F6&;=B@S1soAx@`iU2m*}6|C8fxtWQ=4Qm_h*x4kyLca%c#fx{*Pw_3!b|G z#+%c4NVO=;FKi=87C3;gp0>cWttQ?xk9pB7U%$wUeXFK7v2&pUXo{9&?*z1Okiy4a z_e#pG7sc%5YPjJ+Q`N8kp$c#cYPJyihzsn3kT`JRb-KK}J`2tTvAGXFSG7cYMUGuh zX0jz6j6ArKw8aViBm=D+d%5{;I}AdX+DHx3aj@CSQ$2{LuHInQp{Oj7+3RRM6u205 zRd!(w>b%!xkb3Wo?OhDxiGa{=Gv!e3CnQTBYXfc#inYd*J8Q&>8nebF=?`j-UF_CU z25j`Dg;+0}h(qx9LnpQ3H$9O^>-Q7Qa~SHNf%j%l@m7#nQQGRS2uTOzfJFX%C18W7 zWWBv&TAk2Sb>e-}3`0wbv7_#%tWF2^?GP;qLcN0=v%t1ab))2Sx6}J&hgrxA)HPEJ zZg}s73ZT>Yu#;OCyP#^7)brG_f}C&0oh4%TTq1tDRp|VBz!-9auVDf_aQP90)I2@I z-00wH+Kp_OFEDnA?C(E%igpIZQB}V-%5_}2O}9=I$K4grClIqVBbqcNq!iUy97Gu*h$3hNM1JVrmPCkR<-ruYU^Nm^(+d6b3}98+GTjVD=@}Xz{CZ5&{SJf# zg13tn`w}Zld|!JW_{!b}Lsc!QkDAbucw&1bN=B4;jFuNC4+~-b%$-*rSdHMW8K+l{ z%O4T*O4^QZ^=F_0$G;E})sAp2wpaEf7)aQJ#SUma`c+W{YsUZ08Fg z#pEmky+f_R%H;142X}1R$j-n8M2V6D`UxK2MnSLKF`Z4q561eWLrOO7<2VPGTNIoJ zb6TMmkW0sZSYr;dp3YA=*J$pSJOo(C-YnL#!361{x+>qH@!Lfsp7)Mxbf6VWta=Cu zoXZ5>a-NDgsqm5XjT+I-`zw=rh#e6*$D3m;bj@q#p62P>7LjMm0>Ae*wAvbu^IA)k z-yhS*I{i8Umotl-^zkCmZ%4CN!@;H^Sv`2SH#YE_+H%xHEr0D22>xpr43yau-ou`i z5B<-am^gpaSm^(9)Blri-zwr68Xq|!JhERhTD}?j<&`~GBL=FSOlIZTw~X%%B|M`f z%F;B3e_NW(_j$7e!QEsz^_cPBAN}?s3T8(uC!rh5m=DOO*!HD*kr9^7Q&6jRRD1=$ z7Hx&B4P@Ri*(Dw{2nMeg6vw*T&eY(-Z=;;8d9N-+;IhXanNmAj2014-BpIX6-Tl1r z^A}0j3$gAXH}kANXF<$Qa%m4<<{2C$BP?*y3WV)HW1MY*)T^t!D1^dJ?kpdsFoyU48tY~gl zi4RO7x|+z~3p5eT2OlFFCd#ln%!D@YcrIT`u6vy%SJGaP4T8<49Y-!K4SlGeF^?&- zdx{as=z{GNmtK1CuFYvP2S&>CrFjf?F-Oq^X;QYQUFJord3t_!z-gcfV-cV0FDCUryb)Er=Xu4 zMf}(-`z4R3*uY~wm+OU&l8`#HhcTa*F6e<1S5&1LIF4BhX26l>=g~{A7nu19?TQ;0 zLsP&hj%;U?GC8$s|8blLCe4YtQma{OZ`g0DXmTc|^`YO{C&BU_YNr z@qa!WjQHAMM<_>U1C!fk1IyVbt`yx}!23T`}zUx9x((u>cI%hj4Cje&Ejm%cIk-V)?Acbv#3P9$ zbRLr!V4iac{rY^}@1}wbP*z^;NOyKpTutGtXJK$exiiAqD&nuJzXu~HEb5YT98su~gy5Wxuu z2Zz7{J-NiQ`QU9s2+V%DI&)=8VTO+Osoj0kaa{l`I`t|0g^SMO$weOg@Pnez2 zi^Yb6`JA0m=)pk1cH8rLr zKSL+$-_UFI=<%fEvDjTi#L;lr_JGfJzvo`B=iU$Z%?|U;M$Oe)#g!WA>i_lxl}D|lIR#;0mwQ3<{WLY&;Z{vmOl!wabKW<4W|@VG2nCr@onbskRk z*8cg5oM=@ouy{F<8Ec8uhMW&;hucw0rs>OJA z9kbZ~wY0R<)6-K~O(&chjsO+_h5NlA5|5`#Q!5yd*&+uPIA z)3eZ$d1VexkMvtwTFTDOK0G|^>FKG8laKazh$xax zVs80OKmZ`tQdKtg`?dJi+X<345ky)q*G?t^J^05xStW~mlH+mF+* zV4|MKl;O@sKEWSmUma2pSERe+x1959rLOmp$6oS*TO(QbLTz;Uv@PDs748H$G=KSU zJC%f<=Ig!Z8K%wFeevw5xF+)l&kesh+LDObu4^@?jj>(IaKm4w40;l=7*ORK>xpq3 zA0_D?-}3YGE)7-TEaoleoT#BzewJx}$AOvRakIdni{`Et(P=$Xd9n%_)lmH0vk$C| z9APelQspV?G)%^+eC4*411W)Kcsl(W&`OR;>9xo^eox?o(zKfS#lG2j-Jp)!bJEDX z2w;GInX!Y+j`?a+0-|Bx2(8?YJx#X!phNO8!PHvj`P#ShifeXRz{%B0aWJo*ewj;c z4qZ-8j#=T>=?*?A%iEmGbpC@mFTvaN^@aZGRWHlS+=0%w_oZ)2WD!gcvMjCDZ7cd@ zV)NciBjb~~2;QFLmYnbQZkCwtB)I?`w4^w*mhc+=2}Rw~s9_*v5;)BHtM6CLT3+G@PymDBnK?Q$(8{ zvcMO$A*tSrb2#z}fU>5xec}<;LRPwN5fFFkOQH4sm<4_?s|s$6zT%}A{@f-Bv_gL{ zed5#ZCUF7cl4|LG2{DH?&)BJ7D~9)vp*d@=DfZvva}MEMSH4kFxd0-A_vj4Hp*K(t zRo1cV@CQBEL3(Fd*!==(jPK*mt5@7n5(@zGa`IJ6Y&CdcOWO-U0{ zmo55x>FxKWdI{vooO`GP+j&ygAt0>tt4M;NBOo$ibiSp2h*Z*jL)P)fs0uQrMTrq@ z2wvnSfG2#bYuy;MEBI`ZA=y&pm|kunAg-1F!rhUMqAMddQX_=UV{GA;^Mmt%hU$EM ziv9M-tW;qw)L#keTfM@in8=TbJLIl@;FzKpdC&c(nQ^SI?)F{W4>!bgnqwC zYC7~X?l#(4{0QLk)nZ^phzu;j_`WG@JVXYl3bCv^r!|I$C-mi&NZ z>q{)%Bw)nI>XA)*1%IV`kx29@o%pkY^8Edxr(d=YFA*V~o2R6+Iid!`tDR@z*Yfuo z*h$_f;?Z5PY;E=FVXvtV5$0fUjGS5Wtk;_aLOcr<3VM-yq(^@%P=p-AGCtaBO=^7L zcXi+!`fUESTvLDW`$0ADYABEW#9u`sp_22h^jD`%B_8v;BwuUh{)XH@u^*nF>Y6Gj zv%APO^#%9ANr#I9jw*G4fMYHAUyp{M?uGJB?D_8*<^{QyNF+ExoP;WdX+ae;{DXgv z#oada=f^-XTYB2XIR@facNmjf2PphILRtI-Bg94ip;c4-q)z?RZQ4n^frgjBcBQOE zJ=TKp@HVUXp--DhvD$~{OCIaW)K5u;>YMHy0Is>n^7ZZwg&hTzJhZiTfkYqI)K|5= zXYrGFegNp(>5+{JDf_67E%k@&MBD@$b^VcN=WQak)?X}2+NPDD=aDR#65^Y@(nHUq zLP{q2HXWya%^_|?l5dB=__$-H8>WBuv3EqZ@&Iz{7gtxJr zZ=Ve~U~2T9ZlUy!r($(9<~@{S z0DlW?eb27jZhgBeeB<#=Lv|g|rDYDK%a+nkk%R9cJN!oG2O$1;J_RECeYY_1r}mbe z-x${qgCeM3_ueh$Q<9RqEW;6&YJ=ng~gHV#f!H;ViOGR;7P*u~J$6 zLpG)_%OYO${`<}iRjTSSb;YM6I@=ZM_$hkg*G`JjEYF^-zx>g4j}^{MHY>>Yk8d(V ztqr^Qn}!7*-%)#B65AD*2IVT&a&77#T{BCsywHAN%A0|e|BPYXDEL}JCm>Ew4313k zG0R~X6>_Qi^2AG>O#JYK_m@56RFG|5MOtpMGPR;^N@e(?Yz>i$2fU7UH-cqv5x0sD z0_Dd))wKlVxWicdE(B&=UPsiLJDYqk{EvlBaX)dLYMn^dN|Ryezovl&C9}Hm#pPM2 zK7gu^e|_=dh}7`lcHWPQ+PbtS|zmJK;Tb(F$k@x;)ZJJ~*N<0)7Zy~EXiRF8Lp2T7qW_F>b^dw00uK-_ACl35aeQxCg z)L?@J!0^|%)5$l9E^6YDUy+qDaDe>BC9*kVW+Oz5y6gB@yHM$)h!$0m{;i^%`?YCH zDtF1435^6*WK0<>HO&GJKvO)h$=(6_JPB@pck88t9C{SJR69*yvw!cWwk0Xn#;x*S z)}^tuv_;+%PV?E-?qQ#@-PpBTk^cc%dT>u!M9F_xI9l2gZ;#g zF3=|Y$9pnQce&nHxQQiBeShff6>3}?J+RFa{$d!r6U1_+LqsuzosML<3(2^&7)_EW zrzt`j4mrmD;(LeX@s9_D3%5fRd9@<+9Z3Jp6;Ry!SZm4cVZh>DoY@+!Idpm{%`%3RewJbExrw zst2(7b;_%a4XhyTdh#xDX41kxH=V@XRH)mEL6^~F^*Tw#9LKy$;U+*Keh= zrCh2jXIHO@eLBGX+76*K2{3dNl}8Uo*uLKT#5wwH zPAm#nbQv_PuLk+Ohff zqiMmHNta`DpCkwT68eI?C@Q zeq&i2wPewu^pn1N=?5Tq4GL=<1S8vA#?03+YiN4W;tvpZN4gV97kKlKrBhTka>iV> zrC6lRlqWKH>D1BlDPU#?L3Ogf?1;o#J(ZAfU1x1YDp;;xLBv_8Q+C45VjpBPvgRME6n04VtZAz@5^MEe`f2;kJzATpH4vcZh3<5CCh5zh~#e0rTiZ`Feqjo%njxU%%F-MfsC z1ny^QP~FGFmtnxA>%8Do81S;;`!S65)tSqCGynq=i(e;$UHN(cY17o@rUkO=a8Nlc8oS0K|e$B=$YyGZcxU#0o2dJpPBM!-NhnKv!FNDKEEb*wh z(ua$q90K-h)^$hC!+I71QURHAtS7GsYz?gae=_Eb z>v(&&TfI0XEKvrLu{`x}5FL}ZwUl>c-m@S{Z2A+XccbT=jwx3-udTY{Fkabz7*z;7 zm+Jn5HqOsh;ssT&dw+02-0mfIzo7U`X$r4Co@UP-&iBj7R|M7kI10`I{^J}vgDO{i zg!@yxd|TQA&(`1(y+ON0|A$ylXxF0?Ulfu#3bCAr~9^j)P-?wtqE+ip=$i z!^U?@G%EF^nR+UwK;1o$??{`g~Mj#t6Zhb|;>TG=kdvnuAg;IhNWKNx}WAsH6IpU8ox3<|0q=&>1 z4}L?39SUP=CzAYCbid+e%FT1*e_qeGrotOT9we;KPSv?Oa>uTz{~=40s<&5A$1{6H z%c=@SMaAf3Q*;w<8ed_udHSpE2G4Gy{Hcx6^GI zNDe#=00<{tD<@6jtO-fOe2Oq3AqmPGH|U`Vxt!)f7%3Bb_+P4#S5oE)@Y&;T<+z(9 zke3{(eLyTpLmr}YKwRGb}pZ!W4usnj_b{L+1>k zjs0`cRkir@|-d4Bs{FNui75gA41jyP56-#^=s48&5 zX|!}Kl5m#Q8dVwM}Y9XIr-c9jG>5S>o7I|NMpT%-NdV{ z?cPG6+U*#N24p;E3}Dr%r;looDw#`{h|fpaNg(d z{86Ocokt5N$VCZn8C`E7v{Zx(J{)@Rbuw>$cEAmDzmgHGn3Bh=<$KBGu26~_rO z9_D4M^6osyAr^n(0||gWQALd?-VVUG?ReWtaJ~Sc`A#vd_xWv;mqC%bdN1f1I$&Gz zr&qFiidS2z!UtD)e@GonopPZQ6@Q9dlamBTI}MC*haf;@b9P&UnfF()j!Vzx9QX6x z7uG2yt+Zc&T$D)ifze-~X_9+-U-ong`{7E_I|rciZ-leU-hCaQ-wBRmS}RvY;@398 zcpbS^TiB*~2B1xz>vq$%_W+E=`r2_RoWb03abfvIuPTrC^(FNg0;LaJ0{!zHr-9|c z<2AP-)&=W$ubZXV78rQ~6f+cG)(ik-I%m@Hx6_RnkIbblk&|g}G3p$IVW&rYGybBn z{-h;x2f;Dsl$(Wh%rW&}^zARxVvIa}iJVV<%qgA2F%vt+&=?-y!=s|tp6A(o5$7v<%_VCmnI}2A!3PYx*lts4W&QVfm!lsrEJv~ zSzzEhO6hnT{9th<2w8i||Ge?aZg>{%io8e_`PBnOR>)GR+N6b|Deim@x>cxt84c5l zOV)d$$%CXh`3HUFA?7paW9<~svM+=i-;&$|@n(ueFWvb;;X6GgLPw1!l7IDq+{pv;+f}F zYcbE(weWFCxMrK7Kk!SYgP~#4K!+hi*fN3-aeAOM2dG}XSasx3c-s_e7I)uu5r+$& zM%=yl7{lr5_@pUOq=pfTjTr~iIHL2r^Ej*-&UwSfTseNG)l}!9ipS%XNh$+TB<^Z# z%BK*JRY9q~+Hz$7eqLi@0NtkhaowNp=Y85mkY%{>)G2<`gTpY8nGJKr?FF)`v?P=F zJ)dt)Zrx&esH%tN7Ge)zzGPb{$pIGB_+2OHz^!BNZ zw#P35JN_BFH>O;E*bEML{ReltM%!VQOuZ_<9Vg$0K>{`QU2A?h7wH`GUWdrMq?G^> zmyW3U^cnD0PE4=e2_Ff2yEhgv zE_fQ-E@@%FM$z+t7{$Ox0*Q61<#LfSC@gn+9QQkKC8Fb+&6wX==TpU~RZ6kgweIl4 z$dR$!tdWr+DBa@~lxZ0^wTWH2Cd40mFMICf(+QBo`bfi@hu|m12-RiyV@$a*KaS(Q z_HRdJlah-HZU^1%WG>QOY9l(r!0@-CY=l~Fpt()C)i1}B%5~RqHmvWtl1%!IeJ`t) zukzsCOe{n5Xo?kKBs%eS8T`rIV5%!g>xFR5@%`6LI;eG(`h(F2b6~|IEc18+UJ;5x zQ%qoRynu6m;#$J@2R{!f$?N(Lf1RN>hyst6IODmhMvLh+CO8r%bes5*T^1)*xtYBq zckpdOhpN!NH#71~d9WETl8SBvFOYAN8RpR+B7eI-+avR&xhwb%yz7`iMmk=RxG?%N z!o&Y6`yJhzP2Xs-Dp=>|)7Rsw36&!WuD6_&L4hkyT2{^ML2}OkKykj5Xd_scPaF$pfj2wptiX!^t1vMdp1H^(ROb< z17}{DI)g_g*Pb~*sAgz$S9W}7nT(hhtKh_6ym&B4cjVpYz=^f9p&gUAlD_$qI0*50 zNTw|N%VkpCv`t>LJU91_`px~V(PZkfhse9dLPXYwr-=Lo!Zl+*y?c~+pJZGaA9wJ! z=^#Fi$90RCS`||Cr0`7nJKxMZ^Jxd>mC1~nRB-U&SqA)?JrGj)MH`G%o@1+?Mo;QN z8xLa-NOeTd$r0_Rk{-ek_cf))7Q8e+0BLyfLMcm$2#2*BzWP>iI#p}wPzg`plX#7< zcg-;0DY0)Iu>gtuvY)+hMn0^Y1rNW=YJgfa4*wt29GG4Cu>IWso$&wjx*h>@ytmoe zgJTr!|Gc`ZTOXx+VGpTa+Ooc<6iVh5MUtgkn=9b&kg8ayz0d#g`5Bskc;N?Fhx#sf0K=gF;Hu4UBivRc{_k+pCpZ=~6vr8PEHl7xRE&M6*aRbolIt{Co|YAqWT1Q=ny{s8;uIM(<{mXOG) z7L4#=mkHAyr3WRyEaBwDtBV!vT)dlwKgfSSm4QN4s?$nVzXA!d66Eh2%ymt|-r;X9 zrJ!(KVmZ~&5x!{n|JXqTT`EcL1{UVg^bGwR^r+@m4~LlhyNa2FFEKw|R}>13=!pQ= z1BlZ9v^)U*_Z0u&vF*XO&KEM4gqKSQ5s=HT8n`pXN>>N)^&c|3$_sPz#xV2$R7(Dz zmFV6K>Wb1>8|TJaUB;!!rJpf!3JSS-Rp^oq5AM+>{;YtS%KdIP#h+MPEJ=uv%Bj-W zNo!rE{r3)?1MUR5DF)T9fi`B8)}<9HGfDRxJY15&t z_`s``r-g6h>vmn&uy(bu(MfP^w)usYsiY2Q(8Xb!-+WXU&r_aN1h;!scamD+kPc0m i8TsEyNZ1djF}8>0Fv%((M$F&KotB!OYL$w0=zjtHiN|FC diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2403.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2403.png" deleted file mode 100644 index 2a6d06d3b1b308d960cb7b9828e162402b58ca03..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8422 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

5j`)Mi~7^lldvHzvETLfp3NcVT*4 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2405.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\210\240\351\231\244\345\240\206\351\241\266\345\205\203\347\264\2405.png" deleted file mode 100644 index 586f6c1ed02482fe56f9a8186e718734246a6a95..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8628 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2401.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2401.png" deleted file mode 100644 index e8268a9754a3b505edf0d45336004d66e90a49c0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11282 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2402.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2402.png" deleted file mode 100644 index d670321d03ea1293c42491473d13eea650b92122..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14126 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2403.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206-\346\217\222\345\205\245\345\205\203\347\264\2403.png" deleted file mode 100644 index 37ef1fc15628b8592c3fbe4e5ab46b7017db6c30..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14172 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\2061.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\2061.png" deleted file mode 100644 index 488741f77ab70cd02b49d9e056ce1ef2695f2396..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14094 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 zau

{GH&(zA04ELdHw~+i}d#UHaGQ2Q88>N6hE z2h;Bo8=7{^*Y6*L!b0_VH&o%Fi+->(^ZXQ@2yDmL=l8f9PZdBB0rM2QeICdN{)QSE zhM7y^?S~@7)iPry{gIkD=3GZa^li8==?X~=%lREFL2H91K7MJ+EjQ|0PWwCG(vvJ) z%4i7V!1JbdHXzT2m1rJ~^ZWZJfxDlR9B%8hi^cCJ95hapX-{29zS-}j(gPhAyiSo^ zw902&1>12o?sw@_UKhGv9&UEgxZjkzkdWE$Bq>FiG&?3Ei<~)U^AcuD8C=h^(sE|n z?=cXDtegsX@ChXMA5;{#Y`T8Xc6kukv4&o{0&8Za@J$s;GcbcD`NJmmMaJ!WRRU*h zizgB2&V2d+(8kT{DA-IgSVRh4*@cL0d1pEfeK7SE(tHRmDsS*$P@4~>Y1#MI(}y8) zQfHdO7GFN&dJaTCwwi3s$T z^wOPgQonLcv7AggP{QlJYn3l#W!3lAD?6VF!*Jhkq0^0shfNeZ7_SGHX;8Ve&e9g+k<)dz?J@|L^i|bA;QuRXVXBwOBL)t z+rehYl~vdW{*M-5q%^k_#s%$Kaa)XSsk2zvBn#8XxoEU+)}H@U zsCdEf3vow#g%tJi-Td=}4wUvEUSSH*mrwtHzl+(mccrXv1NE?99$KL=DumPxw8DFb zbcub7EfwDckOe|gnB5++3mQEcvIK0p0XIA0dp!65hkL-4_F%%H%P#4A?nZiBE4xIE zE6qXoXo*ZJzrUaVPsz*Aw*3s3`E7I@ZKCb96>oyw(j)s4S=dLSofU1(8y=Xv=r}qH zWJrMNO-6CMr~88n`DmqN;m6}2zN>VB8KbI=>BJp+&8ox|Y|O-sbnqj6!NlLFHcKsT zv|oeb7q693wAJqz*#5y+!eY0JEo`^jia2+CqoTq~iG$_1ZI!qK6wo?s5RG#a#Nw;Z zBU=Wy%U|cKHV7AHPd$0yeg`^bHY}=RI_7>~8)SPMLhE(QH99tR6ce?wT1HQeqUL^9 zKRPBZ=wclg0oR+@-aI&F`f0*<_`%a#Tjg%Ci4jHZ(QJxB-910R+Oqww+@)UU7f0r| zRZnV;s$jA_3B>xpOdm%1Go5yKQcqYHJwUXNhtyk=$)CmTPPxSK`V9`#>oo21HRDxo sm(;-kuiuw%EU$D`5&x&j0KoN-j=KIP7lvBz>@TB)sH_N3NZ0TG0p=AZ$N&HU diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\2062.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\2062.png" deleted file mode 100644 index 4b7e63f73ae242594b7aa33cf16a1eef5ddaa7ee..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11686 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2173.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2173.png" deleted file mode 100644 index bd028d955ee2652aedbd113537a443bd9ce1c145..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4870 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2174.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2174.png" deleted file mode 100644 index 4705d9db82eeb5b6ef3fbf7f825ab22950bd915b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4249 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 S^oM`01Wh&FrVys0YMkq_U2E|3Tv5X1X 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 GKK(b$z+sF4 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2176.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\346\216\222\345\272\2176.png" deleted file mode 100644 index 8f20179d7e232e620b279082015daa0032c696b4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2453 zcma);XFS`D7RUca=}1(sXzZs&wNzU*Laj%si?&wnpoEsRDPlzs`_mYG9&M@G;$!8h z5hFy6)(B18m^G512n|{*cFbO{?|pOMoO6C}&*$^~o|9~2Wd=Sibs7Kwu!Z@Z2LQmw zKAvq)3LMvO$}5M*ZPMnxz3JG(!L!u1v|ifmk0N``1k8H=k#i78;XHV^BJWIF#=6 zymAM)*WlE8Wg~4RIek48_cE*0%FZ>bsCEnK-#5NeSl*QMI)C5dzT#yS2}zkY`UE#7 zX(JGOsBbVeFthY3SM`R*IA?c)y*1m~Q&iQOPox+cn|+^J`_5YYE2Ahl@;Sm6O&gx8 zZl=#wf8aU0&6hX+B9t#?m)^BgZ$e(0@hXwol}J_7(JgDmdcw#SYw<&CF|*+B4N zF`vWJza$r#i-;zGm7JPvI)*Z)_uFjJALnfsIqaw~;X5(KYSEQi`}Z)8Gioz0`hLr< znbs7uGCe)WsNSd4oDuxg^Qc~uRs|U4C>;&m)@m88gjKru@!Xk=B{(?+f2f$9?4g)4 zD_dPxzc}`Gf1uXQ~98L${iN4V~%#X4w@MO!B9<7L~$+mgW8 z$|)UqQNOwu$x*1sIg|((M~UT(iA+yv=%1w;Lki}lWv3za&iAI>+(DUg zo&^zK@blqzwF~+IVdNl?#33>6{)a^c9)9NsQAjrw#+PcG2PAkig<$&Bb2h=3uO&45 zEsjMYGmr2$9W`qp>iT@8Kfl9_^6q47hHJ}d8EOfq<;1`>!R7C?f*1PU@77p3#Ca@(wn?vQt zV)lDh?LXpR{9GJ0h<{r8h2>x(`CHrx4>jluVgb|7@#6uAh5r- z;>}}E7H*F62g`J?Si-O7VDpGlWogLM9iE&=Gdnj>?e;zbI3=4Em%Cr8uIe_ED1f0o zct6ubMH=LrxzTiY$Y}FdqTunxiLbh$( zilkwka?(^ysb+u+M}UiDYD`F|1>1sG`Q9{Mg#zD(`6uS3V1VL=p(LsSc9klq)LPKQ zKnUwphn-(EYz6KYgW{6w5U&w`nGI=`mKo@t4;~{XA4QEr=4YGm))LfWaH>lPOqGkDGkJ_# zTa(CY@M%CCyMxv#=fgM_h*oYlx_Iz25!J70qJ@#j600b0cg$VnrKvXNItD#^Bot_y z)uZZx2QR-fcu7B(p>Trg0DPvQg=-7D#(d2sp+8unj5S3Uf9*@Z#hC(q-SPU7 zB3d6=+%T%zuaN7KpFUt)_4#<4=w|hUuWFNn-X5S?>3LfX>b`1Go<0=@&$RX!_~`I6neQ`AlI0VIU4FD!!C?d|euG%3#N)Ypj<`t04A9-@VevT2&7NM3xAn z)qvSMDV6$4-PSt_TAQ7Sa2z2=hJ+}RTnp*f95)ElEFWqofF1YgE!t}h3Ky`Jx-QWE zxH!;)NQ=^X)?$9j-ptJGhi8_rXIdQO1?h5GHpmJ1_1_=CHZfKas$k_zS)b(IM7QW0l1e*4i%yFHn$sj2=BE4{nVNA;Yr%4 z#8**BAB~^#aJK@h!La)?9`!3R{H+t#R0B96L3uD$pWd(Cg9DKX*`a33zK<%R;Q#2- zne>l(w|y0I2VNRAONFDkgUJCt== zsYF&F*3?-mtJ^}r-D|qT-qaa^n0UVI7|WMOz}Mb)%qoP_U`-9rDuS(CqyN&lv|tG1 zeuA366(!bu+i~=uw$uutC3mm$EW`Pz`9~*NH^_(pYdnC`G|Ppwd2nUurRf{Lo)V^{}0MB B?GOL} diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\347\232\204\345\255\230\345\202\250.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\240\206\347\232\204\345\255\230\345\202\250.png" deleted file mode 100644 index d7a4d6a85a502e0949aea9557071ecc172c14c60..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10847 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 diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2063.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2063.png" deleted file mode 100644 index 8d8b3ff271d32f3b8ce70e65186eab257aaad5f7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6379 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 MtgTe1VDs_60HM#Pi~s-t diff --git "a/docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2064.png" "b/docs/cs-basics/data-structure/pictures/\345\240\206/\345\273\272\345\240\2064.png" deleted file mode 100644 index b0265b8d1b1bf1a3fa23364df36b2404bc884b9e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6345 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 pNq|AET(_r8Bu~3mS&I^8Nw2WTzi(f3b#=v* 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 b|Lb@24!%(lla%<~XNIDznoO;fMezRuwXiDs diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2211.png" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2211.png" deleted file mode 100644 index 4792fdfddd0e751f7e0dccdb2fc4f8a19aa229d2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11626 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 b|Lb@24!%(lla%<~XNIDznoO;fMezRuwXiDs diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2212.PNG" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2212.PNG" deleted file mode 100644 index a29fbf3c7751bdec9e592b04fcc4c0e36bd463ca..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11668 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 WE}B)KaK(Li%1MFcLFHolzW)P`cNFdb diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2214.png" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2214.png" deleted file mode 100644 index 6092109de5dc8e5cfc6a876810a0574ba692daea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11158 zcmbt)Wl&sg6XoC*+=2xdB)CHekRX}C-8I480>MLYcZUGM-CYLP;O_1Y2^t_UJ0$P- z?tc4Yt9F+vsN3D=Ieq%vo?BBhgeb~OV4{ah($dY%&Dz=;B_-wa=g)C)a1IX-6%`e|yu2_lFbWC^y1Tp2 z&d$ch#?sT%IXF13uC4|K1{xX~kdcw^?|(ZuIB;=sRa8_+N=okS?dj|5%gM=QWMn)e zqzeiPLO@1$b#*;DyA%)*=5cy0Xzy{tfify$jFq;!aY;RS&bV~x-s%@-*uKjJ)NDMbV4Sy{Mzw+YEUk&25yH8nLvL`2Y}q;cX5MgV}3 zLJB0R>biJ5@wynE695?Z_lo8Cjq$8YpPDT|Q?>%w=$+tBOonZ3wGo&rx!%g$0$a5I z>mQ-76pPotZXoq~C-5eDnzz1n&6uMPz&!d#>p0~(g+~M=SaMiu=+>#K>;G__EH7)0vtC0lgRsApb7e-H<4 zkhx~a{CdAjOEzB!&Kks-3BA8w$iKVG5oJYJLoQTbN&3JyL*ZpO9VV6lSFGmZXrV%Z zjcKV=$R$#Dh$WFaM7Eu+m?u$p_&c$6=NGGnBKAz|YmcLkInr-b!w#@VSACTVCv&u& zTJ(GyeM1Y0rYO@|k#hc=aD^a#L?TpT%@^kPz!1-pj5R6C&Xlb!>t%mU6fTzV zVy1ZO1h0os6;zk}xPHv~Jb>vWj^!_k_C*IGTs^^2(}u>?fhWn~7hAH-us5SP1cMi1-*i7aXOSGJ7t z!oMD`1R*!OzkOSSE^`#=e8?K&2W=3pvHn3=gx>m{k$FV@C-fcgyC8X!OBuj~w%nMf z+V&vPOQOM*|8IPYf7g{zI{vrkB;pjxT1Lk4yhp$nf?`_xtwj3dH@`0G?deMX?bR^y z5PGIx_8*l@Ydkk38hHN_#I*}F*wf)Y{GCjW$)EqWtXKJM7WIEHFtR}gM?(>J#_-Osra_;e__9!)!Y+xbJQG;ldx>IZ*U6xI zpj0NX$|kBS3jTk%vlNlXtb6v`=!aR_)xsIp#W!nY)7gq9-j*{DEj2}KcBHUqM_ACM zW>TFXz`!-Y;oJ}S5|QiYb8A^NQaUAcacQ(s|N09t6q|!wDtQmMR&RlGWPyFKs}rwS zG0)2-Py3o`qL#7TyzZ9I1R+*QnO|M(%<6L4+R#hES<-05Zm*hOm(bO^JWA`cpsNik zjq0C6)Fe=*ygnTRV9#2*P+!Hr^%*i9uqBOW z`O7}{ks9tcITaamNU3lWTSu8U*%U99kZhTUK{Hg0&}BZh_(7bFt`Ve!6aFXs+6!@3 zAhn;$G{p^II<2Hr>z-8vUc&JEnxH>&M>c(G86a}Dq&zHt^)W?x#ncbU`T2tXF=Wao zegh9I%J9d(=1?QX?!V%H!G@Cym6f&+QSMxXsYQf&u{OZGW{HUyMG`DVhyW8)c3xrG z1S;whBPcGV&{3}bEu!6G?Ux#eA`W}FksK(QQ(b~3h@m2$Y!#qb(Uhq-`h{=v!ScOAH$ApBUls}lOesroPFBesf9wK zD-mt6R>oJDyRdQ6ep;)Bxl*y_!OT2{Nhi600eDEvlznC5(aAwsgIp*Jh1W@~f|_#A zL$ev&*F{PYY|eJ_(EDm#oMolWR}90(~}K%pKG}s0)3@f3Hhe8v2v?GA(ALa2?__5S=Vyi zM8feKPL|uxkP@Q&=M}9!Q$^58%PKPzw!G{O)b8=A6<*}|p;`HgKy?+*=v~>Wsm%#r zW2J?Ckgs$KIhmy#c5ao0c`^{4DgS$*_KAr0y&T314Cf%9e_1iOp2o`$IhJVl2 zPtVX3TM?uNeu$M21;?`5)SZiH_wV#Bd?!I?inV4eIVo>)TJ`>iIaYNDr3z(oo@eN_Zu8 z>iy$lnr6H%Qp$*IT~a|YQ{=f4d0z3MCkH-S%rzWXsu10bg(N2Vnd#6+t!AiV;?~Ty zR>!u2e^efWbFqD2EN;l)O3NqeWEM(ZSuEhEVKAps0C!@zr0Su?T7ba=FPU`m@6b%n z=e;6?qncbmr3G0%{ugavSyEgszMS!rzYO}TE*qK^t2{6U-EeUqjg4?R8oZ?9Pt*&n zfu!`1fa5sZW~F&Gexre4kV(6P!R>NzG7nJoSe*JFsQYo3@+b&K%H*6A{g-sed9!QM zi;&X-R5%|YR^CM-BTmb9bH>II5Gpm1Wyp`-_-C?40{I;?A|~L8(LWhnY>3C+QUZv; z{*T}n&NrhC%pnZxOleidAfe;abUO_^rH(&ZT<2E=*UD+Lz5jIlSqX7z(~|FTXB9WIjYlR3dbE3FqN(!jqG{%;!A*1DV>{+8Xab67a}#3tUb z-s&~~IyH$en<2EF+PIHaPBxqqe~NE0IhaxjQ4}PdAcFg@Q}1YWkqy0!pxJ&WUvEFZ z(K0LGvC6Zoj*FR+|H5Ic^`_y6k&DBZmbl@b?~0)W%>0XK4JF3;-es@f3}?JEVjz!0 z;Qlq;PTohc+;%I4YlI|`dgPoCcHD3@cex=J)4|D@qONbj*9C9AcAWdY$~R}k3BnWs zyg0E`XY=I>FgmBAT=^VylA2ENTHU_(we6g>li$6wRxo*-SNtZH^_q3wj|SKwR>>Mp zwb_$%7g=MWZW`$gJ0uC6QMF{-q&=faYuU}~5w%bNOq+u(r?!u6(wdROTcL3Kds8N` zFCn>&yeN}_Xv5GRCnE_yC4u+-E(16imVVv86xXcxK1!Z`?B=kkJtu%6pdALa^;*bY+JPp|bHr78)+BVT!Eg}2VfhC56}DzOi7Rewj6>S(ZAVZ&ASE?bWW z(@Vm)c^)~3M8jJn6|iuL;{7<$X^` zBh91BYZ?2}t}iv%CZYa+x2)dDmDw@)_9+CBL^wR}pH|kdm#`-D?h_^P$PfwJl%xM@ zt^a(Fn>%!k0+h1GQT-(?`ggpA^HT=Nq=yPn>^xQBj|AVplT@3STyjdroxYC}j};bG zG+;(r{3F|VIF(rRD>((el%d~xml}HgA5#XBH3~%ChtKd}S*mUo^ya_W#Dp`QgExap zFpgW?5sjwoypF$CgfD!CmXhU)-k3K?07Edv8f=S{`8EHzRO)v3*-NmI{e%2Xq!ewH zXyN;ep@gp9f12+e)hv6Gv>v-jIb7Y2QsrhaXiCRCy;j~umoeAv#?4^nM87KoR1**; zhHpmw9?e!N%u@f69M+{>Yfa!)dn8UBq%E355zr@8EL=+3OGf9JC4*Dv+dB*z(L5)+ z8fR!L1iR%ZzAF={GA}s#igX{h8D`Qd`7&4=E}M^&mB{l}klt6ipQ@w{$4Kf8$l5HQX`GLs431D9$^pzEvnm-vOi=#Ok^6T8}lf~C$dl12`J|)?0;z-r_8JC;&g+90~ay~-# zMt4c@JWk7-AI$<}u}4;Z%?CC$2ZSI;S zX<~X`T`6T<(n=jcL%fd|GuX0NT^V96J)4o|U=+(7tZIt?VIIch2-C--oHD`rhxgbr zG!Q9fP<9gove^n#7+BKimKUVDtE^fkXY-*h5UTj(3|CaPwY9q$jOwF7IE-p{eXAMy zfQA637^s}$gYB2MadwHDZ@&YdPNh6Bx?&~Md*$=C>)?c`T}7qHxh77LF*l-}madl9H43;pOq?m@SjH};rTWp@@Ecq?talD0#*iswbFimYo&XcJ ze&mbAm8h4v#o6YXxJ9`xqYusyj8}aTDgusA_l34$VC~iREKJMvS3gIXqyDyY`r*X0 z84uzUKOADDwZTnwuhaHv(k6Yf4McNem4AW^V1~Ohkg9{2&~ELkn_3dmR#WBQJ>5B} zzM#e3t+P_$``%TGr*~yafHo)v{YQMCaTete4)_5v^UPilPP2`Y=tdU<;t`r|=si)H zH6d*+L$=!0myt^V`mLGS=^M(%_B21okGnUK-#q0<;0&3)Xj$flz0gxXKWIt+%rtle z!F8)&1}sQybg(5{pf=nROCZg-=P{DMf#qw}q%G3aybGun-26+r$UdMaW=r}*0MF~Q zZS2}rPC^6rO%!f8tG60|3 zEn>^WZsu$^*?@j0t{X5flEyLubz26PQ{s=0!%!&){0x`}4`Uetg-aXXa33y z+qbNp-Ri1@pis5sqPXKb!jI!JCUJWMNUrmt*%XZIL8dX0<(t0*k_~y#^ACD|_U8Ru z9e(cju8$u>r;}H3aKgMw>9p=;l$3+1S49Tx*;awv7H?m0a9Jbyj_6U3rK{}fdjEpXl4}?z(2$u;!p+|LYI%)B;h*x2HbO~(@F^+#pZI`b>81MALCH@% zBT$dJZe+D!Rr6ch@Sx{3!1~Qk@q5_nb8`hhah{54kzDen<)h=S!B4#M60eUnO?>`S zs-ElDQNj9$5+ST1pWHA!cs_JW30ThfAF^PpLFy;X{1kMXUmb!uztlMPF=4?g5m3x3 zpliw+Fsm$R$sNUC5HjKk>gdGq;C0pCJEns8Y>>HF&M^0QEGYK`h%X4}#F)S(@%(XO z;|#dUjM{lUDFnXaA<@zkOmw5UI6Tt+s-fzPAL#=!m4La*wbCKnjEE6<)Ct*Y(rHrE z=JBXS1ZB#bvgo2YAjv%Q1UxfkRMJ0`vMClEf_wNsvz2g*P}q_YRuV*aoO${_Wapkb z^qW)4_JoPc(K>6WOzCN{**k_f>v-bK=y5m9m`_U>x-`}2L*8nT44?lxSlnVMgt)82 zo2yD{yU1;cyO=1xPE+t|H*7Akdi}|KT2k4?=_D%)!gYG+hwa;Z)RFZrN9?qSc7<(R zFQr*#-80EChjY$u6P&|ToC|(92fLUYmzSUH93Q6MeOb3|NkM=~#1BzW+%FGbA)Gss zQg%7P#zLkHCXNU#oJ{2Yq)~o~-sk#C#=YHYFNWi39<@ol*waB5A00^9mzX&{y(N5h zQbMJ?Cs_ftmG#y z*P_t-Hl(hGd*$lju+oe5Q}3rap3`@)-+FtCtEr-WyB$lG$-59;ZL{J?GT$0ue===c z4_Z{M^$_LR*1>S_daM3z`_Q`Zg98PB%dN!tGBeXb2D`D@EZwx&2Bb- zD30v@fUC{u6b~GwrS4$>)+!$|fYYSJ zf|Wq#dDBXv{Biy`Il<%7ML7f?>CvdgakCPXB^Wnl@x;P`V$6Aw$~`Hx{?9RTNuZkM zJJ0+ubpOWjgS;2$}fTz1ijnOrIuB%~B)_P$FVN`mj`UpW()Z`C!ol{EWI! zOjCY|^T7WgE8!E#YE_AVm_$>Ziqu>mDJM)_Cg`L*M4d|?a>%H%&yZoQF?n@G2P<6c z9kd0ia~U96MzK4`%SaroK5JWQk%7^*EQm6TGHXpN9)^H^Fl11+l;xV=lU4aYcO+~s z_ffCTX=+_!+sG06tt&M)O2irP{KBYq8K=zn`?!sSn$bp%uJ(QGs-#3z2xCuj66|Y? z+SokFD5--+JW$go*XYsnzSV1@BxhVBrP}gSMsvD%iEGut-+6L_&#xXUA_h%P9#@So z&H%7^rz|9hv>5_J6>XP1lf%boZ0m!@Eweh_m?wG&we{f9MFP71{u(EIJ~Yzbl-LP{!KrsfT5 zW`^Ynawp=mIbH^ptNWgBWn_rsb9Dlpzc$rzl>10kmd}C{wj!kfo_gtR(j1)&zI-Nj zA7eD9mdnKe4>QE5eZo59Dhw#xD%inQiVbM`-ekO|!ZLlP0`A62ZxdfbGoyU{0my}; zqqyPSp`ZG5mw%k}pX+Ewcy}ghp!H?Cx@+W+mko2Zvdb?A1CTA{U!jVdp|pwL7GLO+ z*Iz{gkWfrMo7Df>j_$r5W9ITxe;l&1jsv;&)ys&&mJzy3-PIy{B_>!~VBpFoLoHqFfq3Lz0dr4f1|bjhllSUfMM+ z09mK=gRgZXCG=T`oeG5fYfF?@pzv|}m>r%dLBH7{d>*8Fl7$6hlGK;fOXN!5FuM=o zn>&Zx<+>F1i}1N`tt3lfaT-S9o-BMs}spmqyXc=Dv8KwJ}%-*lulW zuv;De45vt5OIWd!0T*3c6*D15HHO)NSu1ay8#&X{;h4#9&iHLm7=dG#FA;q~YC_`H z3=kZOB2!C&bVTbt_Uk3}G1d=?A0!M|+QUdJws5PHH(>NZxk`C>SB%}_(p@e-M>qwa z&CH$UV-A2&&xhX5zNl6Z8~42AJi(DmTh-J6+sq}AXI&pXsyLS>6Tb>Mk>i>|>`X@;JWM=;AN2_Y{#+DjBGW?P4_+&vr{-34%YHNy^xw1V*j|A#v30{0oJ};U*_T?~_ zck`nf3erVlJqg-9O3FkO(@@haIe<#tVvJ=BEwW63PVY(H6Qb^S3nhBJUq-s3-#d8J zKPSSgQjx>t)tC6`7;Bks6jM?A;0H2)N3eKCrx{ybwl4P^^@@gJYF4i(e@g396{8Qn znwXy_?;p=3=fr$JBuoaO+D$OXqr-}mBb;3HFY+Xp|J8eSF>EyKm?U)K?J(!Aom2BH zFg!pxpv#tYj5qw5o``y0`}FB#Drs-xQLW5dyTB=VhdKnG=a}fBmR5Njqk5d!yc^&N zd@dUilLKcFS~m}e8R^?Su&xL`_23MBzBrL1o);Ju%U9|S&1s`atZ? z<)`dqA97A5$?po$aCt|4u8_K+??@o8BYQco)bUi(2zCkBb}6kZCV_X^V4sZWy~t3N z3|5%8pgT`@Mwab8V!aY)qgu+R#LpKhC?{GG;>kxog_{wm>B!=ZK1^16n{yQZD%U@+ zh2B?Eh&l1q_STMKo${kwOfxg8JH!GkxKBWQB#W7ri_t4;vtA1i#3-sVjD_?BgOeaV zG(Ty=d~11mZ+32m!$L4FRj4^D8005XNvFc)eeEp95hHD5!{l=~viwwoOlY zXb=r%;t9)8eAlf~eAIICxeev`sqsyr$!d1`Id?O9TS7d%nPJ^Knv}{(c6wCWhe-)i zpYM4~ac~;!l;u?^%V4X>uOXz6Jy1}Gab6zT$&n3hNn2erRTfgjmxX@5GF^;rJbp0$ucepc344~z>o$QH7t@4qdoe4Tv4J=behd&GtjC4b5j zw}Y%|p8mV02m@Wm;w9>x2bbAZy(`ZSK?F=rT8~+8=RxY1zO!TOeG$nrmiN@Wg((~h zxY{i75J^TgA?3Z31FnyOn&uNWp@w3e9_^%%%#V2kuf1ksciF)w>#kJ7z!W}ShomrT z5uiVO5Duqk7`1UwKp+bfFuZT5(Xj19#au-^uT`A+_t=p1Xo(Qn-KG<+cE_#Y5xM}i zIlkLHBt4Oy=BrM36&k-L|2hW+8LYHUTe;nQ1Tafo9Eb0vV85DJ4)al|20|XDxLw<; z=kmhh;cD6;g(JqR_z1KSRNo5D#{$_nMC>fhu>}GHE|lEfrI>zf4pOVaIpKAsGK3^H0aF_IzJ3#mTg|fbUl8pN^K)?59=GG_WZMJpV2~6a) ze6Li;$Tom|1Rnv)NeLuL5P;S}Ww7c)9idVPvl089-)TqSTPM{$$zXhZ`Nr3s2V}K&3BV zlK*pF?UAIQC=G{=UWmfna{!UzwlB^_xcbHUp0sU?#~7f}`^6sl1KUv3ul1j>jO#@j z+z+VA-e-h!`1XY+zl3^U2CS{_6yk$?1)MlAsa`y2pwAbr-hW(~Gi1eh3pk{>=o`p3 z+~=#PXgHBcRCM>HjIf#~h$A|Md+m(yu^YuD)&pOoR8pkO^BZZ5H*tll60OsRHYr7o z4Dw3j3Spu!!N=Db501`Zy)KmGo6c@DqUjj|`bFxNX2Q$~`7GrcMa$$FZJ&Y{YN#ZKe4oelH0a)?y@iF+-OI(W7Ntpe9Hs1!JB14P^fcfv>~|55|aY>gsALw z8$~|xrG~s2b>uTAe)hBLZ(Pev13NTc9zM?YTnxgM{T#COjr>I=@22>l;IZz*7amh9 zP^7a7Xr>&$UL4O{L!9Si(bOu}$JxaAao!F_h9?TcT4?x`#UL*x;L1S`uVNhAp_ROb z5)dvfuj9JOcH4yehVqWt;56dAa^~^!9*f1ROF^T86%(tTk+4zi5NEovu);kySleB2 zL7P&xUQud9*==h~8SX1~rmYFy6X_Q)?eE>CE(X^j*-*AGaL*ww(*=b2HOApz+ zukCS1_da`UHaJ~FZyMvI+WRcO3#X#Fut1L<=02r5kQ|7Pw}_>ugPzbRx@WTQjNNhUG7Br~4? z(c)d;Bx|QwDc;fMw({mWl?8V^Ta)+hxvz`<<&f0-b0OlNTWQdnYVH%m4{BD5#-A45 zGxW_Cdsjz^!QwY-c*pXP`87*Dx1+D?^EW)DCV_-8d~+`_kstT z;0JQ^xh03m<`ZHR(o&szw(B2X#|T%L+uS2+CMJBuGd_R%Il0&htk^PzceQ<)4y;(J zLHw~?EZ6@1VDJcEF=#BT0xX`shL(w3@&Wv|)fv9<-Hh&@%v^p9z*4D<$PXAaC9l)$ zeU}#XNJ$)YC|ql;CsJ0-K9ch;;?d0j@xT7Z>70b#+qJwP361KjfmSgwjzWVfJJmO- zCf-&lfY0z?*+=-`?P`{xTP`?%2bDy84`Q6r&uNJl*l1MoHuZg8t90J>Up^}UHgshx z@J0BC$_Fq|zi%V?8=u1ioAx`asPQFY#rh5nwpb|&@>z@%90$Q2adrYtruN z?*s)6I{<|Na-a8K763fr(_9kbJoR3XNg=4G6`-p1v#(id8An5{CHuKqr?4SR4+P+ z{75WB-LM-Mu(*YEC%27Mg~tZjHj-%WRP~}#j@04UZ}JjzhBMci)lk3VP@*)|(7g#9 zsDv1eC66IgV~9XvC$B0~|~-Un*1d ziirHcI4=e2NleVHlwE9^$N0H6?;Tcmm>c-dzq0|#Vmm_ew}4zGF+2Iko)m0NfUR~?enh|Miaekt>dj{_5W!2s7% zEz@?BZ)_XK7`~olm#(Gh)i2RP0Q?!zdS@rmdLd;)ux_kF;k;~u@1Whsq$!JR3kifV zKp5oYOzukX2o^un8(yQPIB*dvxD~!3yW+3l=MsP;%+Xf)W~nng7j7@PFdPasNT?c&o;4h z-4T0IK#tFMr^*+(&dzt&1jfdt6hb*}L3@tJ;9%ewX#E~C3r(A}An z#+30Ya}ql#woI$O5cWDWnzWd0%zZGX4d=ht_}}Qa1vZxCQ-t{7wGt_U^l#yRUaYgW WE}B)KaK(Li%1MFcLFHolzW)P`cNFdb diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2215.PNG" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2215.PNG" deleted file mode 100644 index 15e457f412e267436ef6766b277cfa40d819dfc4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13184 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 A3jhEB diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2215.png" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2215.png" deleted file mode 100644 index 15e457f412e267436ef6766b277cfa40d819dfc4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13184 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 A3jhEB diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2216.PNG" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2216.PNG" deleted file mode 100644 index 539579a9da4e643f6cfcda46264c035350755100..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10965 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

p1DIQcmigY!8wKtjgfowJGX=Q9_92~Vl{yb9W zQ}O8ZUT1;E6L%hB`EwB^)}ak{-4my|A84rd+Nc=sCQ{3CaY&q3E_s*?*0FZJR1@S@ zyJr}*pFD9{5zHhmoHNBxn1;n6Z|y#%)R)rnxHwZMa)`C&eQ8dT!dblbP*zpc*0I476=8l>==NsI6>)o{M zNfuC496rSDN-p|P=xMC9XrIfyymJ#|Lk6-9gBsjA6c~Z;Mk}0nyE;35ZN9_3J>^nzeaTpA)71X;Nr+`1vAG zFy;;pZ6N^-! zT26!gFJhUGe8nFk zOOT`Xqp&5*@7Ghpko6YjTg1V^s{lf+o}LuJ;Wrl_=@nX4_xK0HOIooee|6ucWl#XN z--#ClchGe{Dp|E2qEhgigiW@T_Q>ECEhHOUtd@VW4E_|c`BozF4b+%4;h6+Il|0|vU$o3lz^ z>jI#|soeFP&o!NSL&=gD7yInKKv zOA)R}zoT$Sa=jhEV(#?O#au74E6gp>&!w-4K~tid4$ttWqh(Uu$w52$AFHw%NTT#p z<~N?7^MsGvA{#{MtmgB-i}CjTe!OiZg{3$^weMd>4mNfoaXZnOFP^Gy`SR+76E0h( z94WeJx$53k+EOX0wW5e)eOHokE@qV9E|$MaTNdS%b<`i81mH}1!p*6N{7&qxkrrJv|DA&n;;R&HpL_G{qrNk5L!pPy>>i%(%zWuZP1@)U z2@ee|MMeF`3aLGH0)kA0YILieq?B4R@mCcM-9isrsKt|W8~*eJ14JU2I_ge=dCM1g2# zW>K%Mk3}t0-~#tA&Lgw4g?4LyqfQZz zs6`S5*AF{qXhBAZ6sYy7^*)wCF3dwG8ug)*-oD^R%s>=l4{N2RaUR_>c2(*!Gat6C zd%nPf&^dGN`G)82?P{t#Gzv7bD0FcR3?Vm7Wp777Rl%TFF4b?@c}t3aR(6k#tNsC^ zG@RacTl${)ok=ddA}HPoa7ZpYKv@ODodba9i;!BBu=@I_+}66**W;k#I@x@HO>*x9 zN;Qa=?hju*M}cHwel^^Lb95Y}G@wKjcAhipW^P)?Q8(?)3zP!+u$?fXtiHc!Dy?&T zE3kt?3#rfR+OBUA0!i2Hcu|J(g^@9){{)&ZZBj^|kAB3_6bG8;= z3$mfvRJOZ&5tvp3$R>cLjVfn@HK01`n}*a%#9?Vlm|qv%{5i+(HH~UoQVueMH?WhP zsfSm;*MYp1_Aov<8{MWnBNu{v+Y;B7z6O9N=8Qp4_JHfxEHy7tF7YOqV diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2216.png" "b/docs/cs-basics/data-structure/pictures/\347\272\242\351\273\221\346\240\221/\347\272\242\351\273\221\346\240\2216.png" deleted file mode 100644 index 539579a9da4e643f6cfcda46264c035350755100..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10965 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

p1DIQcmigY!8wKtjgfowJGX=Q9_92~Vl{yb9W zQ}O8ZUT1;E6L%hB`EwB^)}ak{-4my|A84rd+Nc=sCQ{3CaY&q3E_s*?*0FZJR1@S@ zyJr}*pFD9{5zHhmoHNBxn1;n6Z|y#%)R)rnxHwZMa)`C&eQ8dT!dblbP*zpc*0I476=8l>==NsI6>)o{M zNfuC496rSDN-p|P=xMC9XrIfyymJ#|Lk6-9gBsjA6c~Z;Mk}0nyE;35ZN9_3J>^nzeaTpA)71X;Nr+`1vAG zFy;;pZ6N^-! zT26!gFJhUGe8nFk zOOT`Xqp&5*@7Ghpko6YjTg1V^s{lf+o}LuJ;Wrl_=@nX4_xK0HOIooee|6ucWl#XN z--#ClchGe{Dp|E2qEhgigiW@T_Q>ECEhHOUtd@VW4E_|c`BozF4b+%4;h6+Il|0|vU$o3lz^ z>jI#|soeFP&o!NSL&=gD7yInKKv zOA)R}zoT$Sa=jhEV(#?O#au74E6gp>&!w-4K~tid4$ttWqh(Uu$w52$AFHw%NTT#p z<~N?7^MsGvA{#{MtmgB-i}CjTe!OiZg{3$^weMd>4mNfoaXZnOFP^Gy`SR+76E0h( z94WeJx$53k+EOX0wW5e)eOHokE@qV9E|$MaTNdS%b<`i81mH}1!p*6N{7&qxkrrJv|DA&n;;R&HpL_G{qrNk5L!pPy>>i%(%zWuZP1@)U z2@ee|MMeF`3aLGH0)kA0YILieq?B4R@mCcM-9isrsKt|W8~*eJ14JU2I_ge=dCM1g2# zW>K%Mk3}t0-~#tA&Lgw4g?4LyqfQZz zs6`S5*AF{qXhBAZ6sYy7^*)wCF3dwG8ug)*-oD^R%s>=l4{N2RaUR_>c2(*!Gat6C zd%nPf&^dGN`G)82?P{t#Gzv7bD0FcR3?Vm7Wp777Rl%TFF4b?@c}t3aR(6k#tNsC^ zG@RacTl${)ok=ddA}HPoa7ZpYKv@ODodba9i;!BBu=@I_+}66**W;k#I@x@HO>*x9 zN;Qa=?hju*M}cHwel^^Lb95Y}G@wKjcAhipW^P)?Q8(?)3zP!+u$?fXtiHc!Dy?&T zE3kt?3#rfR+OBUA0!i2Hcu|J(g^@9){{)&ZZBj^|kAB3_6bG8;= z3$mfvRJOZ&5tvp3$R>cLjVfn@HK01`n}*a%#9?Vlm|qv%{5i+(HH~UoQVueMH?WhP zsfSm;*MYp1_Aov<8{MWnBNu{v+Y;B7z6O9N=8Qp4_JHfxEHy7tF7YOqV diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\215\225\351\223\276\350\241\2502.png" "b/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\215\225\351\223\276\350\241\2502.png" deleted file mode 100644 index 1fe9f712584aca6e65c50d0fcad4864704b48be9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7550 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 diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\217\214\345\220\221\351\223\276\350\241\250.png" "b/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\217\214\345\220\221\351\223\276\350\241\250.png" deleted file mode 100644 index bf1fe71bff796ce102cf0b4f9a0a47031b811f23..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9295 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

GCB?y|Z`mG(hr1;$ST>H1f6se0 zwXl9gA+uV<8S}rnb)7s(pv6$INH*Lc`gWOT6B*n?CcM#D;tO;c`bYnM?0J9sipX)o z)ZG^b;}l25ztWj+-l_N8=4}y`*dEM(6FMoVYnjW))+z8c66VB-1D0T6p&-&>q#ih= zYN3*{NAZQeUI&fVj&$;tBf4UieHq6 zj04Q8`m+{NthB!33*1JR2XtbtpIFihbs z|179dh4e{Z4h;wC77bE%8c9>9GZL~j)Iuvhx;E<1B*P#>r)0`xSJivG+%T2{rXD#z z4YWdtVKuIi{`hIG#_#CK_>bPo?_Ct zEh3^Z=8mwg;hUrV!Cnc<$a_10;@_NDi{xh321zz^j-^kX&e;oZ zNIeG>%4&A@moiPx*h~hL1IAB7rKSH(CrQxxqzP~%H?N``o1hz5VhcGFpHvERb{jC0 z#mR=7Om*Y-aA6=OXJGFuajG=(d*0aC@`W82?$)c`8GJK$Pq&lN=O=gU z50c~h5lJZFf%=Tsep` zw}6EoXt-8;A%_o1WIOCGydf$=qY2(_q(I%Q$q*FP+h!ttO;+pYIoC zaRcbjg!?>chL(U`1&56Hb_hsej%%(4CR+23a})d(RI3hdGhG0q{S#6M=*M$huTr_Va0J}$ ieZFr4#S}d)i3R~SIjO`XtNzyqTJ^1_Vy!$h^nU=(8s>8V diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\276\252\347\216\257\351\230\237\345\210\227-\345\240\206\346\273\241.png" "b/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\345\276\252\347\216\257\351\230\237\345\210\227-\345\240\206\346\273\241.png" deleted file mode 100644 index 23cf43107dce669edb6e3c421e80354064b44dbf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5642 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/xGWQ25xVTU3hBQFslJleEE/oDQW1TYogGmjIiMEM5Q0jT6JY+izhg1QSnbNaiuCm70mIIQdw4sPcNf6JwrYOrdOdKey/wJRuC561mw3fxOBorKcSboGAdnVTMZCMWaUEJY/RfsZxAK8Ape83dMbb8uBURizYxq8vk42//y9/DZPbY8eovTLD8d6kF62AG/khOVg2aFAYLdGDL4kwBflHWdZMbw1izAvafwRpEmO+wrtIe/KWyGMZwQTmjU3VquV7vvcnjJKvsPam8Be2pbN38gxQMrg/s3JaSVkPNYgiSCjB15FNtAdibIMM82W5V1FWhlT6xphpRHIQAlL3xWW/EHCeQK0+jC0MA6mIkZ5KSYxbAJ7Lo4w6ET0IIo1lKwekAobhRgwtG267wNO9vCVIN7xMEmFi5RsqA9lq3ooDzhyW34YoCFkHT8ZjeWsz2fW+GS2RYjpuI/WONyak5tya94tt3wMGYRDan6rGDBai1JXR1rdHUdvhAAnBRxq1RJRIX0naCf9/VQRlXscNb6su42vm2lHmwZzrLhpO7pU3JhXiBv7M24GaDCMkeKm4+hCcVP0c9G4cT7jZmj5tncYZ+vNkVuVD+uNe4W4mQzHDSWbOBBHvrnKaR84Jt7kVGg2gStwHDoTtvPGaEdC9/8AqqU1UXVvjWrR2ZEa52OQpshvItlBTM3+8TdCyF6kI0LZmoQkBnhRWT1/Q7cZY8IRB5Ee/hL0PRpuUX7l5Qf1UXWswjLfS4bz0qFe+gop4shAKo3HCqqu5oLzHlTmLZW39FOcEc89IRhtRxfK2O0BW+rAsPR3ql9Gp7XuDV6ySdedBcDXO3sv5GXmryuKNAGMwlisGx5tIiY9oR7IB3gqX0QoCLKF0KdWTT1bkZjJO17dGunmz25lx64cOT0h3Y6Y8dRI7xJCkp+HD1Mz7ouP027rTswObQDPzhb1VKE+DuWJEVOCe8uMYKoDQn70raHVv9UbeyuunpQQ2lulqySEI24w73+T2fmpoEdGrrzL7Lm5W9jKVFUmE2XhKlNN8Wyx4M4QewGe4y5zRWnDDe0M7juXffuNhVzjSzOvqvs9N2YVX5biTRWXU6ouCWMk+qSsuva6HWWnXVZ9MFUfm0Nvdlpq5RrDNIvf2D58w2m2HF34RzXtiNukn5dYrc3GubR2HF2a1r77LBsL3QzQtkGv/e9GfOfiCVl9kLo45TUwXLHqLX8K5d/MS5qAuNeNoPwhzTgXXjQr2fd4WZiKN1fcmbKYKHxDOLGUxZPizRR3+hIDhGcYRUteGURCbuNlmtS65oDkvTdHxM3Z1JpWMZwPjPMCmBUIWGLW01kGBZ+4k1k4CE457/z/Z8TWm2WJz69gC57Fl1dnwcGtOSKFeTC3jpkpy++shONQSIl89kkkRCXf1NY0QzQi3CNiYh25oojBEmIP+N/DzHf7UM4b9wlR3orQANKeFk8gQlj08AwoiEgcFMOQwKiS6t/LoThqzqeP4vAb31Yac6My/CaioGHx8p1Mw/aHVC9jpLvf1l3LBXflvFh9G5crVvWFobH4Dw== \ No newline at end of file diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\346\240\210\345\256\236\347\216\260\346\265\217\350\247\210\345\231\250\345\200\222\351\200\200\345\222\214\345\211\215\350\277\233.png" "b/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\346\240\210\345\256\236\347\216\260\346\265\217\350\247\210\345\231\250\345\200\222\351\200\200\345\222\214\345\211\215\350\277\233.png" deleted file mode 100644 index 84e117a51f4973d93947a7a24ee53c0db9b87436..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10045 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 A2mk;8 diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\351\230\237\345\210\227.png" "b/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\351\230\237\345\210\227.png" deleted file mode 100644 index fd8e334d1131a84105e2c8992f05a03621755c00..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2434 zcmah|dpHyN8($Q1X^AK!_lgd4sZQ)1ms!@r6pL*|Ew|*bWn*)RNR*S6-pH^=^f1Gheo&2#G5*CNywMn?Tx>i(FWM*crt*v!*bb!I& zH*elZBoYpX!{u`0;^N?N_{_{qVq&6DD3nU2K|w*Gp`j%uC313dOeQlmH5CX1qS5HO zx;jlwO&X2HX0vfPTx4XVgM)*Cfk7>99SQ&_3?N{RD9WfX*YTc=zVaa}GMW z=@e#yJuK_SuUt9K14XBLFx>Fm?lJ)ce{|&=H`ZEbIkf>F{WAQ4?MvBRAncubyvI8+ z?de zTk`c-AV(?rxHYW-9C_ZiY*@C^CdIOjFc|%z-?JpggH^2f>(%#es`kCH#`IGG?JQg0 zyVE#Y?!%D5%ExUpv;B1sdh9R?W>Fioa@d9JkuE?Afd_>)TR| zhiaU?s?MA4Xn#uoQgZpB9#D#=2QEGYeu@g-r&I@y39A2mTp5Nl_C()#qR4gjec4p{ zLi~g3)~OP{c;O@VPd1uw=#4z6$1b1P-c-f$;(t0-R8(J^-c&{(9v%G%;swwCI1@@| z*ivtY^^PUfRB%~m+%?ACHkJUne1@h!rkc>BJVjMN1uBqXkF1;;3}rI+x9g}@uy%`X zI|L*X_%>P3F&Vm#LMGW5UhQLRmT0AEcaX@4uM5OR9uRd^9E*qoT1SPim5R`Qmj#p5 zyI9YR=YWhsaAXP?PvY+t2_l19E_KgmH~AGz%ptY$1b!=X`6~61Zt}S6%*uP-9jDe( zTk3SqB$7Akw7y7`Kb(>?2qy8r=Z>?W)ltkmrFgb3%~b9Z0ug__bW2)FOVI9S^K#5)Cbsi~k=tce&b*k+cQ?KmM20 z-)E<&Hb|C?6tF+9^l6m0ek_K!+~?hdloL~&e9hwu%fLG`_ZPBt3jVt%_;yq4 zB#6QPTj``CAwJ+AC&ks{8Arn2I;gJ#(|nwvw-ccnitFF;m<6ivtlCIvQFoct0pxO| z&s<<(2)Fuas{etRcz@a;Dx8)t(I_u63dG2E|BBnu{O+TRZ*pL24~dVAJu;}X2ii|0 zpH_LS(YS2?D3p3rKPQS%IYKFVG8d5B(%>oYd&+EKwv^-|U@NH+b79yit!1_qf4z~O z%}^tgn(m2S+i7|9TqDBUZ!;8UJfaMTA68L}{g0f$oik+`f3nA#Y@qkq?= zc~(dJCI=8ZX9e1gH}}kn4xhf?)z7LbVsnMiaytkX(tL*CTKIrX{cuQAqD61(DMgkzv~x3qFVjO%o* zd1cYlu#vdh(2|<6v>1`(ndl8y?H5~KR3KrfPtCn@InnSpsmNh_wxdO+>47=-#_0jL zfNh-){le|+aW`uY>%QLGu1D;(Ynvc+77rGbm!ej~>sa)P6`eckGl#_;u`#b-9jjF> z@~adR!G6K+o??d0oLvKiaWeVFZts}&Pl8dg8y#(;mfk{qmzL3a_URbgyw#W7ho3A77^JkL(&Eogl(f;L%6%e?e5ib5hJ9`~-|l z?l^4bKW|C>NrEt zoMs#j&e%DXxMDx2G_ew`SGiX?UIn#A{w=43YEMC++nS=k-hcgII?Igno~N_#U>4bY zA88tCwXNRi+1F>yivy}QEN^0`6%MMeZdYut!PCsYM)i?deSHJfam?iBz5ET2-C;k~ Vb(e~|erU_}h?7WIHS|*Ae*lQ=!j1p{ diff --git "a/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\351\241\272\345\272\217\351\230\237\345\210\227\345\201\207\346\272\242\345\207\272.png" "b/docs/cs-basics/data-structure/pictures/\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/\351\241\272\345\272\217\351\230\237\345\210\227\345\201\207\346\272\242\345\207\272.png" deleted file mode 100644 index 9a324873490ed3f221cc3c8066742330ff9013ab..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4067 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 diff --git a/docs/cs-basics/data-structure/red-black-tree.md b/docs/cs-basics/data-structure/red-black-tree.md index effd473e9a2..5c53b79d450 100644 --- a/docs/cs-basics/data-structure/red-black-tree.md +++ b/docs/cs-basics/data-structure/red-black-tree.md @@ -63,39 +63,34 @@ public class Node { ### 1. 左倾染色 -![幻灯片1](./pictures/红黑树/红黑树1.png) +![红黑树左倾染色示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/red-black-tree-1.png) - 染色时根据当前节点的爷爷节点,找到当前节点的叔叔节点。 - 再把父节点染黑、叔叔节点染黑,爷爷节点染红。但爷爷节点染红是临时的,当平衡树高操作后会把根节点染黑。 ### 2. 右倾染色 -![幻灯片2](./pictures/红黑树/红黑树2.png) +![红黑树右倾染色示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/red-black-tree-2.png) ### 3. 左旋调衡 #### 3.1 一次左旋 -![幻灯片3](./pictures/红黑树/红黑树3.png) +![红黑树一次左旋调衡示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/red-black-tree-3.png) #### 3.2 右旋 + 左旋 -![幻灯片4](./pictures/红黑树/红黑树4.png) +![红黑树右旋加左旋调衡示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/red-black-tree-4.png) ### 4. 右旋调衡 #### 4.1 一次右旋 -![幻灯片5](./pictures/红黑树/红黑树5.png) +![红黑树一次右旋调衡示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/red-black-tree-5.png) #### 4.2 左旋 + 右旋 -![幻灯片6](./pictures/红黑树/红黑树6.png) - -## 文章推荐 - -- [《红黑树深入剖析及 Java 实现》 - 美团点评技术团队](https://zhuanlan.zhihu.com/p/24367771) -- [漫画:什么是红黑树? - 程序员小灰](https://juejin.im/post/5a27c6946fb9a04509096248#comment)(也介绍到了二叉查找树,非常推荐) +![红黑树左旋加右旋调衡示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/red-black-tree-6.png) ## 面试复盘重点 diff --git a/docs/cs-basics/data-structure/skip-list.md b/docs/cs-basics/data-structure/skip-list.md index e574f35bfd4..574cb354b9b 100644 --- a/docs/cs-basics/data-structure/skip-list.md +++ b/docs/cs-basics/data-structure/skip-list.md @@ -14,6 +14,53 @@ head: Redis 的有序集合 ZSet 底层就使用了跳表和哈希表的组合,所以跳表在后端面试里经常和 Redis 一起出现。 +文章内容概览: + +1. 什么是跳表? +2. 跳表为什么能把查询从 `O(n)` 降到平均 `O(logn)`? +3. 跳表如何查找、插入和删除? +4. 跳表和红黑树应该怎么对比? +5. Redis ZSet 为什么会用到跳表? + +![跳表在有序链表上建立多级索引以加速查找](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/skip-list.png) + +## 什么是跳表? + +跳表(Skip List)是一种基于有序链表的数据结构。它的底层仍然是一条完整的有序链表,所有元素都会出现在最底层;在底层链表之上,跳表再建立若干层更稀疏的索引。 + +可以把它想成一本书的目录: + +- 最底层链表像正文页码,信息最完整,但从第一页翻到最后一页很慢。 +- 上层索引像目录,信息更少,但能快速跳到接近目标的位置。 +- 查询时先从最高层索引往右跳,跳不动了就下降一层,直到最底层。 + +跳表和普通链表最大的区别就在这里:普通链表每次只能向后走一步;跳表可以在高层索引中一次跳过多个节点。 + +## 跳表的节点长什么样? + +普通链表节点通常只有一个 `next` 指针,而跳表节点会有多个前进指针。一个节点如果出现在第 3 层,就意味着它在第 0、1、2 层都有对应指针。 + +抽象来看,跳表节点可以理解成这样: + +```java +class SkipListNode { + int value; + SkipListNode[] forward; +} +``` + +这里的 `forward[i]` 表示当前节点在第 `i` 层指向的下一个节点。真实工程实现里还可能保存 score、member、backward 指针、span 等信息,用来支持排名、反向遍历和范围查询。 + +## 层数是怎么来的? + +跳表并不通过旋转、变色来维持平衡,它依赖随机层数。 + +插入一个新节点时,通常会用随机函数决定它能升到多少层。可以把这个过程想成抛硬币:节点一定会出现在最底层;如果第一次抛到正面,就升一层;再抛到正面,再升一层;直到抛到反面或达到最大层数。 + +这样做的结果是:越高层的节点越少,越低层的节点越密。理想情况下,第 1 层大约保留一半节点,第 2 层再保留一半,第 3 层继续减少。虽然不是严格平衡,但从概率上看,高度会维持在 `O(logn)` 级别。 + +这也是跳表名字里“跳”的来源:高层索引允许查询过程跳过一段又一段元素。 + ## 面试考察重点 - 能说清跳表为什么比普通链表查询快。 @@ -32,6 +79,17 @@ Redis 的有序集合 ZSet 底层就使用了跳表和哈希表的组合,所 这个过程有点像在有序数组里二分,但跳表底层仍然是链表结构。 +更准确地说,跳表每一层都是有序链表。查询时始终遵循一个原则:能往右走就往右走,不能往右走就往下走。 + +假设要查找 `26`: + +1. 从最高层头节点开始。 +2. 如果右侧节点值小于 `26`,说明目标还在右边,可以继续右移。 +3. 如果右侧节点值大于 `26`,说明再往右就越过目标了,于是下降一层。 +4. 重复这个过程,最后在最底层确认目标是否存在。 + +如果目标不存在,跳表也能找到它应该插入的位置:最底层中小于目标值的最后一个节点,就是插入位置的前驱节点。 + ## 插入和删除 插入一个节点时,需要先找到每一层中它的前驱节点,然后把新节点接进去。新节点能提升到多少层,通常由随机函数决定。 @@ -40,6 +98,12 @@ Redis 的有序集合 ZSet 底层就使用了跳表和哈希表的组合,所 跳表不靠旋转维持平衡,而是靠随机层数让索引高度保持在合理范围内。这也是它实现起来比红黑树更容易的地方。 +实际写插入代码时,经常会维护一个 `update` 数组:`update[i]` 表示第 `i` 层中新节点应该插入在哪个节点后面。查找插入位置的过程中顺手把这些前驱节点记录下来,拿到随机层数后,就能逐层修改指针。 + +删除也是类似思路:先找到每一层的前驱节点,如果这一层的下一个节点正好是目标节点,就把前驱节点的 `forward` 指向目标节点的下一个节点。 + +因此,跳表的插入和删除并不是只改底层链表,还要同步维护目标节点出现过的那些索引层。 + ## 复杂度 | 操作 | 平均复杂度 | 说明 | @@ -51,6 +115,10 @@ Redis 的有序集合 ZSet 底层就使用了跳表和哈希表的组合,所 空间复杂度是 `O(n)` 级别,但会比普通链表多一些索引指针。 +这里的 `O(logn)` 是平均意义上的复杂度,依赖随机层数带来的概率平衡。跳表不像红黑树那样提供严格的最坏情况平衡约束,但在随机函数正常、参数设置合理的情况下,性能通常很稳定。 + +范围查询是跳表很舒服的场景:先用 `O(logn)` 定位到范围起点,再沿着最底层链表顺序向后遍历 `k` 个结果即可。 + ## 跳表和红黑树怎么选? | 对比点 | 跳表 | 红黑树 | @@ -72,6 +140,15 @@ ZSet 需要支持: 哈希表适合按 member 查 score,跳表适合按 score 排序和范围查询。两者组合后,ZSet 能同时支持快速查找和有序遍历。 +更具体一点: + +- 通过哈希表,可以根据 member 直接找到对应 score。 +- 通过跳表,可以按 score 从小到大维护顺序。 +- 做 `ZRANGE`、`ZRANGEBYSCORE` 这类范围查询时,跳表可以先定位起点,再沿链表连续返回结果。 +- 如果跳表节点维护 span 信息,还可以支持排名相关操作。 + +需要注意,Redis 会根据数据规模和配置使用不同的内部编码来节省内存。面试里说“ZSet 使用哈希表 + 跳表”通常是在讨论它面向较大有序集合时的核心结构。 + ## 易错点 - 跳表不是数组,也不是二叉树,它的底层是链表。 @@ -87,4 +164,11 @@ ZSet 需要支持: - 跳表的层数怎么决定? - 跳表范围查询复杂度是多少? +## 参考资料 + +- [Skip Lists: A Probabilistic Alternative to Balanced Trees](https://dl.acm.org/doi/10.1145/78973.78977) +- [William Pugh:A Skip List Cookbook](https://drum.lib.umd.edu/bitstreams/17176ef8-8330-4a6c-8b75-4cd18c570bec/download) +- [Redis Docs:Sorted Sets](https://redis.io/docs/latest/develop/data-types/sorted-sets/) +- [Redis 源码:t_zset.c](https://github.com/redis/redis/blob/unstable/src/t_zset.c) + diff --git a/docs/cs-basics/data-structure/trie.md b/docs/cs-basics/data-structure/trie.md index 69c503644a3..bd2e617aefa 100644 --- a/docs/cs-basics/data-structure/trie.md +++ b/docs/cs-basics/data-structure/trie.md @@ -14,6 +14,42 @@ Trie,也叫前缀树或字典树,适合处理大量字符串的前缀匹配 它的核心思路很直接:把字符串按字符拆开,共享相同前缀。比如 `app`、`apple`、`apply` 会共用 `a -> p -> p` 这条路径。 +文章内容概览: + +1. 什么是 Trie? +2. Trie 为什么适合前缀匹配? +3. Trie 节点怎么设计? +4. Trie 的插入、查询和前缀查询怎么写? +5. Trie 和哈希表应该怎么选? + +![Trie 树按字符路径组织字符串集合的结构示意图](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/trie.png) + +## 什么是 Trie? + +Trie 是一种专门面向字符串集合的数据结构。和二叉搜索树不同,Trie 的节点通常不靠“大小关系”组织,而是靠“字符路径”组织。 + +可以这样理解: + +- 根节点不代表任何字符,只是所有字符串的入口。 +- 从根节点出发,每向下一层走一步,就匹配字符串中的一个字符。 +- 从根节点到某个节点经过的字符连起来,就是一个前缀。 +- 如果某个节点被标记为单词结尾,说明从根到这个节点形成的字符串是一个完整单词。 + +举个例子,插入 `app`、`apple`、`apply` 之后,它们会共享 `a -> p -> p` 这段路径。`app` 对应的最后一个 `p` 节点需要标记为单词结尾,否则 Trie 只能知道 `app` 是某些单词的前缀,不能知道它本身也是一个完整单词。 + +这就是 `isWord` 变量存在的意义。没有它,就无法区分“这个路径只是前缀”还是“这个路径已经构成一个词”。 + +## Trie 为什么适合前缀匹配? + +哈希表很适合判断一个完整字符串是否存在,比如查询 `apple` 在不在集合里。但如果问题变成“找出所有以 `app` 开头的词”,哈希表就不那么顺手了:除非额外维护前缀索引,否则需要扫描大量 key。 + +Trie 的优势在于,前缀天然对应树上的一条路径。查询 `app` 前缀时,只需要从根节点依次走 `a`、`p`、`p`: + +- 如果中途某个字符路径不存在,说明没有任何单词以 `app` 为前缀。 +- 如果能走到最后一个 `p`,说明这个节点下面的所有单词都以 `app` 开头。 + +所以,Trie 的前缀查询复杂度主要和前缀长度有关,而不是和词典中有多少个单词直接相关。这个特点在搜索提示、路由最长前缀匹配、词典过滤这类场景里很有用。 + ## 面试考察重点 - 能说清 Trie 为什么适合前缀查询。 @@ -24,6 +60,11 @@ Trie,也叫前缀树或字典树,适合处理大量字符串的前缀匹配 ## 节点结构 +Trie 节点通常包含两类信息: + +1. 指向子节点的引用,用来继续匹配下一个字符。 +2. 是否为完整单词结尾的标记。 + 如果只处理小写英文字母,可以用长度为 26 的数组: ```java @@ -35,8 +76,19 @@ class TrieNode { 如果字符集不固定,可以用 `Map`,空间更灵活,但每次访问有哈希表成本。 +这两种写法没有绝对好坏: + +| 节点实现方式 | 优点 | 缺点 | +| ---------------------------------------- | -------------------------- | ------------------------ | +| `TrieNode[] children = new TrieNode[26]` | 访问快,适合固定小字符集 | 空节点多时比较浪费空间 | +| `Map` | 只存实际出现的字符,更灵活 | 有额外对象和哈希访问成本 | + +面试手写代码时,如果题目明确只有小写英文字母,用数组最清楚;如果字符集包含大小写、中文、路径片段或任意字符,用 `Map` 更稳妥。 + ## 基础实现 +下面这个模板假设字符串只包含小写英文字母: + ```java class Trie { private final TrieNode root = new TrieNode(); @@ -76,6 +128,16 @@ class Trie { } ``` +插入和查询的逻辑其实是同一条主线:从根节点开始,按字符一层一层往下走。插入时如果路径不存在就创建节点;查询时如果路径不存在就返回 `false`。区别只在最后一步:`search()` 要检查 `isWord`,`startsWith()` 只要能走完整个前缀即可。 + +## 删除操作怎么理解? + +Trie 的删除比插入和查询更容易写错,因为删除一个单词时不能简单地把整条路径都删掉。 + +比如 Trie 里同时有 `app` 和 `apple`,删除 `app` 时,只能取消 `app` 最后一个 `p` 节点上的 `isWord` 标记,不能把 `a -> p -> p` 这条路径删掉,否则 `apple` 也会被破坏。 + +真正删除节点时,需要从单词末尾往回看:如果某个节点没有子节点,并且也不是其他单词的结尾,才可以被删除。面试中如果没有明确要求删除,一般先把插入、完整查询、前缀查询写稳。 + ## 复杂度 设字符串长度为 `L`: @@ -86,6 +148,8 @@ class Trie { 空间复杂度取决于节点数量。最坏情况下,如果字符串几乎没有公共前缀,空间开销会接近所有字符数量之和。 +如果还要枚举某个前缀下的所有单词,复杂度就不只是 `O(L)` 了。定位前缀节点需要 `O(L)`,后面还要遍历这个节点下面的子树,额外成本和返回结果数量、子树规模有关。 + ## Trie 和哈希表怎么选? | 场景 | Trie | 哈希表 | @@ -97,6 +161,8 @@ class Trie { 如果只是判断一个词是否存在,哈希表通常更简单。如果要频繁查前缀,Trie 更合适。 +还有一个容易忽略的差异:哈希表的完整匹配通常更省空间、更通用;Trie 则把公共前缀显式存成路径,因此能自然支持前缀查询、按前缀枚举、最长前缀匹配。二者解决的问题重心不同,不是谁完全替代谁。 + ## 工程场景 - 搜索框自动补全:根据用户输入前缀找到候选词。 @@ -104,6 +170,14 @@ class Trie { - IP 路由匹配:最长前缀匹配可以借鉴 Trie 思路。 - 词典校验:快速判断单词或前缀是否存在。 +实际工程中还会看到一些 Trie 的变体: + +- **压缩 Trie / Radix Tree**:把只有一个子节点的连续路径压缩成一段字符串,减少节点数量。 +- **Ternary Search Trie(三向单词查找树)**:每个节点通过小于、等于、大于三个方向组织字符,在空间和查询灵活性之间做折中。 +- **AC 自动机**:在 Trie 的基础上增加失败指针,用来做多模式字符串匹配。 + +这些变体不需要一开始就全背下来,但要知道 Trie 的基础思想是它们的共同起点:用路径表示字符串,用共享路径复用公共前缀。 + ## 易错点 - `isWord` 不能省,否则无法区分 `app` 和 `apple`。 @@ -118,4 +192,10 @@ class Trie { - [212. 单词搜索 II](https://leetcode.cn/problems/word-search-ii/) - [648. 单词替换](https://leetcode.cn/problems/replace-words/) +## 参考资料 + +- [Algorithms, 4th Edition:Tries](https://algs4.cs.princeton.edu/52trie/) +- [Algorithms, 4th Edition:TrieST API](https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/TrieST.html) +- [Stanford CS166:Tries and Suffix Trees](https://web.stanford.edu/class/archive/cs/cs166/cs166.1216/lectures/16/Slides16.pdf) + diff --git a/docs/cs-basics/data-structure/union-find.md b/docs/cs-basics/data-structure/union-find.md index 1dcef1d45b9..4c775e955d7 100644 --- a/docs/cs-basics/data-structure/union-find.md +++ b/docs/cs-basics/data-structure/union-find.md @@ -14,6 +14,60 @@ head: 面试里它的代码不长,但 `find` 写不好会直接影响复杂度。 +文章内容概览: + +1. 什么是并查集? +2. 并查集如何用数组表示集合? +3. `find`、`union`、`connected` 分别做什么? +4. 路径压缩和按大小合并为什么能提速? +5. 并查集适合哪些连通性问题? + +![并查集用父节点指针表示连通分量的森林结构](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/union-find.png) + +## 什么是并查集? + +并查集(Disjoint Set Union,DSU,也叫 Union Find)维护的是一组互不相交的集合。它最擅长回答两类问题: + +1. **查询**:两个元素现在是不是属于同一个集合? +2. **合并**:把两个元素所在的集合合并成一个集合。 + +它不关心集合内部的完整结构,也不关心两个点之间具体经过哪些边。比如在社交关系里,并查集可以快速告诉你 A 和 B 是否属于同一个关系网络;但它不会告诉你 A 到 B 的最短路径是什么。 + +这也是并查集和 BFS/DFS 的区别:BFS/DFS 更像是每次沿着图现场搜索;并查集则是把连通关系在合并过程中维护起来,后续查询直接看两个元素的代表节点是否一致。 + +## 并查集如何表示集合? + +并查集通常用一个 `parent` 数组表示若干棵树组成的森林: + +- `parent[x]` 表示元素 `x` 的父节点。 +- 如果 `parent[x] == x`,说明 `x` 是所在集合的根节点。 +- 一个集合只需要用根节点作为代表。 + +初始化时,每个元素都是一个单独的集合,所以每个元素的父节点都是自己: + +```text +parent[0] = 0 +parent[1] = 1 +parent[2] = 2 +... +``` + +执行 `union(0, 1)` 后,可以让 `1` 的根节点挂到 `0` 的根节点下面。此时 `0` 和 `1` 就属于同一个集合。继续执行 `union(1, 2)` 时,虽然传入的是 `1` 和 `2`,但真正合并的是 `1` 的根节点和 `2` 的根节点。 + +所以,并查集里的关键不是“当前节点的父节点是谁”,而是“沿着父节点一直往上走,最终根节点是谁”。`find(x)` 做的就是这件事。 + +## 三个核心操作 + +并查集常见操作可以概括为三个: + +| 操作 | 作用 | +| ----------------- | ----------------------------------------- | +| `find(x)` | 找到 `x` 所在集合的代表节点,也就是根节点 | +| `union(a, b)` | 合并 `a` 和 `b` 所在的两个集合 | +| `connected(a, b)` | 判断 `a` 和 `b` 的代表节点是否相同 | + +如果两个元素的根节点相同,说明它们已经属于同一个集合;如果根节点不同,`union` 就把其中一个根节点挂到另一个根节点下面。 + ## 面试考察重点 - 能写 `find` 和 `union`。 @@ -22,6 +76,20 @@ head: - 能处理图中判环、朋友圈、省份数量、等式关系。 - 能说明并查集适合动态合并,不适合频繁删除。 +## 从 Quick Find 到 Quick Union + +理解并查集时,可以先看两个极端版本: + +- **Quick Find**:数组里直接存每个元素所属集合编号。查询两个元素是否同组很快,但合并两个集合时,需要扫描整个数组修改集合编号。 +- **Quick Union**:数组里存父节点,通过根节点代表集合。合并时只改一个根节点的父指针,但如果树很高,`find` 会变慢。 + +面试和刷题里常用的是 Quick Union 的优化版本:**路径压缩 + 按大小/秩合并**。 + +- **路径压缩**:每次 `find(x)` 时,把沿途节点直接挂到根节点下面,后续再查这些节点会更快。 +- **按大小合并**:合并两个集合时,把小树挂到大树下面,尽量避免树长得太高。 + +这两个优化配合起来,能把并查集的多次操作压到非常接近常数时间。 + ## 基础模板 ```java @@ -76,9 +144,16 @@ class UnionFind { `parent[x]` 表示 `x` 的父节点。根节点的父节点是自己。路径压缩会让查找路径上的节点直接挂到根节点下面,后续查询更快。 +这份模板里有两个细节值得单独看: + +1. `find()` 中的 `parent[x] = find(parent[x])` 是路径压缩。递归返回根节点后,顺手把 `x` 直接连到根节点。 +2. `union()` 中通过 `size` 决定谁挂到谁下面,这是按大小合并。这样可以减少树的高度增长。 + +`count` 表示当前还有多少个连通分量。每次 `union()` 真正合并了两个原本不连通的集合,`count` 才减 1;如果两个元素本来就连通,不能重复减少。 + ## 复杂度 -使用路径压缩和按大小合并后,并查集单次操作的均摊复杂度可以看作接近 `O(1)`。面试里一般说“近似常数时间”即可。 +使用路径压缩和按大小合并后,并查集单次操作的均摊复杂度是 `O(α(n))`,其中 `α(n)` 是反阿克曼函数,增长极慢。实际面试里一般说“近似常数时间”即可。 空间复杂度是 `O(n)`,主要来自 `parent` 和 `size` 数组。 @@ -92,6 +167,10 @@ class UnionFind { | 判断无向图是否有环 | 如果一条边两端已连通,再加边就成环 | | 等式方程 | 先合并相等关系,再检查不等关系是否冲突 | +并查集特别适合“关系不断合并、查询是否同组”的问题,例如省份数量、冗余连接、账户合并、最小生成树中的 Kruskal 算法等。 + +不过,并查集不擅长处理删除关系。因为一旦两个集合合并,内部哪些边让它们连通的信息通常已经被压缩掉了。删除一条边后,集合是否仍然连通并不能靠简单修改 `parent` 数组得到。 + ## 易错点 - `find` 里要返回根节点,不是返回父节点。 @@ -108,4 +187,10 @@ class UnionFind { - [1319. 连通网络的操作次数](https://leetcode.cn/problems/number-of-operations-to-make-network-connected/) - [200. 岛屿数量](https://leetcode.cn/problems/number-of-islands/) +## 参考资料 + +- [Algorithms, 4th Edition:Union-Find](https://algs4.cs.princeton.edu/15uf/) +- [Algorithms, 4th Edition:WeightedQuickUnionPathCompressionUF](https://algs4.cs.princeton.edu/15uf/WeightedQuickUnionPathCompressionUF.java.html) +- [CP-Algorithms:Disjoint Set Union](https://cp-algorithms.com/data_structures/disjoint_set_union.html) + diff --git a/docs/cs-basics/network/arp.md b/docs/cs-basics/network/arp.md index d48a0d1a128..822768341c5 100644 --- a/docs/cs-basics/network/arp.md +++ b/docs/cs-basics/network/arp.md @@ -72,7 +72,7 @@ ARP 的工作原理将分两种场景讨论: 5. 主机 A 终将收到主机 B 的响应分组,提取出该分组中的 IP 地址和 MAC 地址后,构造映射信息,加入到自己的 ARP 表中。 -![](./images/arp/arp_same_lan.png) +![同一局域网内通过 ARP 获取目标主机 MAC 地址](./images/arp/arp_same_lan.png) 在整个过程中,有几点需要补充说明的是: @@ -106,6 +106,6 @@ ARP 的工作原理将分两种场景讨论: 7. 路由器接口将对 IP 数据报重新封装成链路层帧,目标 MAC 地址为主机 B 的 MAC 地址,单播发送,直到目的地。 -![](./images/arp/arp_different_lan.png) +![跨局域网通信时路由器通过 ARP 获取下一跳 MAC 地址](./images/arp/arp_different_lan.png) diff --git a/docs/cs-basics/network/can-ping-but-tcp-may-not-connect.md b/docs/cs-basics/network/can-ping-but-tcp-may-not-connect.md index e0ee2a70bd5..fac70b94cf8 100644 --- a/docs/cs-basics/network/can-ping-but-tcp-may-not-connect.md +++ b/docs/cs-basics/network/can-ping-but-tcp-may-not-connect.md @@ -20,7 +20,7 @@ head: ICMP 工作在网络层,TCP 工作在传输层,它们在协议栈里根本不在同一层: -![TCP/IP 四层模型](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) +![ICMP 和 TCP 位于 TCP/IP 协议栈的不同层次](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) ## Ping 通,只能说明 ICMP 有回应 diff --git a/docs/cs-basics/network/can-tcp-and-udp-use-the-same-port.md b/docs/cs-basics/network/can-tcp-and-udp-use-the-same-port.md index 3ddfd82bbed..b04b97cf26c 100644 --- a/docs/cs-basics/network/can-tcp-and-udp-use-the-same-port.md +++ b/docs/cs-basics/network/can-tcp-and-udp-use-the-same-port.md @@ -99,7 +99,7 @@ TCP 和 UDP 之间不冲突,不代表端口可以随便重复绑定。 ### DNS 为什么同时用 TCP/UDP 53? -![实际应用示例](https://oss.javaguide.cn/github/javaguide/cs-basics/network/can-tcp-and-udp-use-the-same-port-practical-application-example.png) +![DNS 和 HTTP/3 同时使用 TCP 与 UDP 端口的实际案例](https://oss.javaguide.cn/github/javaguide/cs-basics/network/can-tcp-and-udp-use-the-same-port-practical-application-example.png) DNS 是最经典的例子。IANA 注册表里,`domain` 服务同时注册了 `TCP/53` 和 `UDP/53`,实际 DNS 服务也经常同时监听这两个端口。 diff --git a/docs/cs-basics/network/computer-network-xiexiren-summary.md b/docs/cs-basics/network/computer-network-xiexiren-summary.md index 4fe3b930f2c..5e57166251d 100644 --- a/docs/cs-basics/network/computer-network-xiexiren-summary.md +++ b/docs/cs-basics/network/computer-network-xiexiren-summary.md @@ -21,7 +21,7 @@ head: 3. 链路层、网络层、运输层、应用层各自解决什么问题? 4. 复习《计算机网络》这本书时,哪些概念最容易混淆? -![](https://oss.javaguide.cn/p3-juejin/fb5d8645cd55484ab0177f25a13e97db~tplv-k3u1fbpfcp-zoom-1.png) +![《计算机网络》教材知识点总结概览](https://oss.javaguide.cn/p3-juejin/fb5d8645cd55484ab0177f25a13e97db~tplv-k3u1fbpfcp-zoom-1.png) 相关问题:[如何评价谢希仁的计算机网络(第七版)? - 知乎](https://www.zhihu.com/question/327872966) 。 @@ -60,7 +60,7 @@ head: 11. **分组(packet)**:因特网中传送的数据单元。由首部 header 和数据段组成。分组又称为包,首部可称为包头。 12. **存储转发(store and forward)**:路由器收到一个分组,先检查分组是否正确,并过滤掉冲突包错误。确定包正确后,取出目的地址,通过查找表找到想要发送的输出端口地址,然后将该包发送出去。 - ![](https://oss.javaguide.cn/p3-juejin/addb6b2211444a4da9e0ffc129dd444f~tplv-k3u1fbpfcp-zoom-1.gif) + ![路由器存储转发分组的过程](https://oss.javaguide.cn/p3-juejin/addb6b2211444a4da9e0ffc129dd444f~tplv-k3u1fbpfcp-zoom-1.gif) 13. **带宽(bandwidth)**:在计算机网络中,表示在单位时间内从网络中的某一点到另一点所能通过的“最高数据率”。常用来表示网络的通信线路所能传送数据的能力。单位是“比特每秒”,记为 b/s。 14. **吞吐量(throughput)**:表示在单位时间内通过某个网络(或信道、接口)的数据量。吞吐量更经常地用于对现实世界中的网络的一种测量,以便知道实际上到底有多少数据量能够通过网络。吞吐量受网络的带宽或网络的额定速率的限制。 @@ -78,7 +78,7 @@ head: 9. 网络协议即协议,是为进行网络中的数据交换而建立的规则。计算机网络的各层以及其协议集合,称为网络的体系结构。 10. **五层体系结构由应用层,运输层,网络层(网际层),数据链路层,物理层组成。运输层最主要的协议是 TCP 和 UDP 协议,网络层最重要的协议是 IP 协议。** -![](https://oss.javaguide.cn/p3-juejin/acec0fa44041449b8088872dcd7c0b3a~tplv-k3u1fbpfcp-zoom-1.gif) +![计算机网络五层体系结构概览](https://oss.javaguide.cn/p3-juejin/acec0fa44041449b8088872dcd7c0b3a~tplv-k3u1fbpfcp-zoom-1.gif) 下面的内容会介绍计算机网络的五层体系结构:**物理层+数据链路层+网络层(网际层)+运输层+应用层**。 @@ -95,11 +95,11 @@ head: 5. **半双工(half duplex)**:通信的双方都可以发送信息,但不能双方同时发送(当然也就不能同时接收)。 6. **全双工(full duplex)**:通信的双方可以同时发送和接收信息。 - ![](https://oss.javaguide.cn/p3-juejin/b1f02095b7c34eafb3c255ee81f58c2a~tplv-k3u1fbpfcp-zoom-1.png) + ![单工、半双工和全双工通信方式对比](https://oss.javaguide.cn/p3-juejin/b1f02095b7c34eafb3c255ee81f58c2a~tplv-k3u1fbpfcp-zoom-1.png) 7. **失真**:失去真实性,主要是指接受到的信号和发送的信号不同,有磨损和衰减。影响失真程度的因素:1.码元传输速率 2.信号传输距离 3.噪声干扰 4.传输媒体质量 - ![](https://oss.javaguide.cn/p3-juejin/f939342f543046459ffabdc476f7bca4~tplv-k3u1fbpfcp-zoom-1.png) + ![信号传输失真示意图](https://oss.javaguide.cn/p3-juejin/f939342f543046459ffabdc476f7bca4~tplv-k3u1fbpfcp-zoom-1.png) 8. **奈氏准则**:在任何信道中,码元的传输的效率是有上限的,传输速率超过此上限,就会出现严重的码间串扰问题,使接收端对码元的判决(即识别)成为不可能。 9. **香农定理**:在带宽受限且有噪声的信道中,为了不产生误差,信息的数据传输速率有上限值。 @@ -162,7 +162,7 @@ head: 5. **MTU(Maximum Transfer Uint)**:最大传送单元。帧的数据部分的长度上限。 6. **误码率 BER(Bit Error Rate)**:在一段时间内,传输错误的比特占所传输比特总数的比率。 7. **PPP(Point-to-Point Protocol)**:点对点协议。即用户计算机和 ISP 进行通信时所使用的数据链路层协议。以下是 PPP 帧的示意图: - ![PPP](https://oss.javaguide.cn/p3-juejin/6b0310d3103c4149a725a28aaf001899~tplv-k3u1fbpfcp-zoom-1.jpeg) + ![PPP 点对点协议帧格式](https://oss.javaguide.cn/p3-juejin/6b0310d3103c4149a725a28aaf001899~tplv-k3u1fbpfcp-zoom-1.jpeg) 8. **MAC 地址(Media Access Control 或者 Medium Access Control)**:意译为媒体访问控制,或称为物理地址、硬件地址,用来定义网络设备的位置。在 OSI 模型中,第三层网络层负责 IP 地址,第二层数据链路层则负责 MAC 地址。因此一个主机会有一个 MAC 地址,而每个网络位置会有一个专属于它的 IP 地址 。地址是识别某个系统的重要标识符,“名字指出我们所要寻找的资源,地址指出资源所在的地方,路由告诉我们如何到达该处。” ![ARP (Address Resolution Protocol) explained](https://oss.javaguide.cn/p3-juejin/057b83e7ec5b4c149e56255a3be89141~tplv-k3u1fbpfcp-zoom-1.png) @@ -281,7 +281,7 @@ head: 1. **域名系统(DNS)**:域名系统(DNS,Domain Name System)将人类可读的域名 (例如,www.baidu.com) 转换为机器可读的 IP 地址 (例如,220.181.38.148)。我们可以将其理解为专为互联网设计的电话薄。 - ![](https://oss.javaguide.cn/p3-juejin/e7da4b07947f4c0094d46dc96a067df0~tplv-k3u1fbpfcp-zoom-1.png) + ![DNS 将域名解析为 IP 地址的过程](https://oss.javaguide.cn/p3-juejin/e7da4b07947f4c0094d46dc96a067df0~tplv-k3u1fbpfcp-zoom-1.png)

https://www.seobility.net/en/wiki/HTTP_headers

@@ -301,7 +301,7 @@ head: HTTP 协议的本质就是一种浏览器与服务器之间约定好的通信格式。HTTP 的原理如下图所示: - ![](https://oss.javaguide.cn/p3-juejin/8e3efca026654874bde8be88c96e1783~tplv-k3u1fbpfcp-zoom-1.jpeg) + ![HTTP 客户端和服务器请求响应过程](https://oss.javaguide.cn/p3-juejin/8e3efca026654874bde8be88c96e1783~tplv-k3u1fbpfcp-zoom-1.jpeg) 9. **代理服务器(Proxy Server)**:代理服务器(Proxy Server)是一种网络实体,它又称为万维网高速缓存。 代理服务器把最近的一些请求和响应暂存在本地磁盘中。当新请求到达时,若代理服务器发现这个请求与暂时存放的请求相同,就返回暂存的响应,而不需要按 URL 的地址再次去互联网访问该资源。代理服务器可在客户端或服务器工作,也可以在中间系统工作。 10. **简单邮件传输协议(SMTP)**:SMTP(Simple Mail Transfer Protocol)即简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则,由它来控制信件的中转方式。 SMTP 协议属于 TCP/IP 协议簇,它帮助每台计算机在发送或中转信件时找到下一个目的地。 通过 SMTP 协议所指定的服务器,就可以把 E-mail 寄到收信人的服务器上了,整个过程只要几分钟。SMTP 服务器则是遵循 SMTP 协议的发送邮件服务器,用来发送或中转发出的电子邮件。 diff --git a/docs/cs-basics/network/dns.md b/docs/cs-basics/network/dns.md index 1f60f52e1e9..8ffb5832bad 100644 --- a/docs/cs-basics/network/dns.md +++ b/docs/cs-basics/network/dns.md @@ -21,7 +21,7 @@ DNS 要解决的是**域名和 IP 地址的映射问题**。它看起来只是 3. 递归查询和迭代查询有什么区别? 4. DNS 为什么通常基于 UDP,什么情况下会改用 TCP? -![DNS:域名系统](https://oss.javaguide.cn/github/javaguide/cs-basics/network/dns-overview.png) +![DNS 将域名解析为 IP 地址的系统概览](https://oss.javaguide.cn/github/javaguide/cs-basics/network/dns-overview.png) 在实际使用中,有一种情况下,浏览器是可以不必动用 DNS 就可以获知域名和 IP 地址的映射的。浏览器在本地会维护一个 `hosts` 列表,一般来说浏览器要先查看要访问的域名是否在 `hosts` 列表中,如果有的话,直接提取对应的 IP 地址记录,就好了。如果本地 `hosts` 列表内没有域名-IP 对应记录的话,那么 DNS 就闪亮登场了。 @@ -50,7 +50,7 @@ DNS 服务器自底向上可以依次分为以下几个层级(所有 DNS 服 截止到 2023 年底,全球根服务器物理实例总数已超过 1700 台。根据 **[Root-Servers.org](https://root-servers.org/)** 的最新实时监测数据,到 **2026 年,全球根服务器物理实例已突破 1900+ 台**,并正向 2000 台大关迈进。 -![Root-Servers.org](https://oss.javaguide.cn/github/javaguide/cs-basics/network/root-servers-org.png) +![Root-Servers.org 展示全球根服务器实例分布](https://oss.javaguide.cn/github/javaguide/cs-basics/network/root-servers-org.png) ## DNS 工作流程 @@ -61,7 +61,7 @@ DNS 服务器自底向上可以依次分为以下几个层级(所有 DNS 服 下图是实践中常采用的方式,从请求主机到本地 DNS 服务器的查询是递归的,其余的查询时迭代的。 -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/DNS-process.png) +![DNS 递归查询与迭代查询结合的解析流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/DNS-process.png) 现在,主机 `cis.poly.edu` 想知道 `gaia.cs.umass.edu` 的 IP 地址。假设主机 `cis.poly.edu` 的本地 DNS 服务器为 `dns.poly.edu`,并且 `gaia.cs.umass.edu` 的权威 DNS 服务器为 `dns.cs.umass.edu`。 @@ -76,7 +76,7 @@ DNS 服务器自底向上可以依次分为以下几个层级(所有 DNS 服 除了迭代式查询,还有一种递归式查询如下图,具体过程和上述类似,只是顺序有所不同。 -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/DNS-process2.png) +![DNS 递归查询解析域名的流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/DNS-process2.png) 另外,DNS 的缓存位于本地 DNS 服务器。由于全世界的根服务器甚少,只有 600 多台,分为 13 组,且顶级域的数量也在一个可数的范围内,因此本地 DNS 通常已经缓存了很多 TLD DNS 服务器,所以在实际查找过程中,无需访问根服务器。根服务器通常是被跳过的,不请求的。这样可以提高 DNS 查询的效率和速度,减少对根服务器和 TLD 服务器的负担。 @@ -84,7 +84,7 @@ DNS 服务器自底向上可以依次分为以下几个层级(所有 DNS 服 DNS 的报文格式如下图所示: -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/DNS-packet.png) +![DNS 查询报文和回答报文的字段格式](https://oss.javaguide.cn/github/javaguide/cs-basics/network/DNS-packet.png) DNS 报文分为查询和回答报文,两种形式的报文结构相同。 @@ -100,13 +100,13 @@ DNS 报文分为查询和回答报文,两种形式的报文结构相同。 DNS 服务器在响应查询时,需要查询自己的数据库,数据库中的条目被称为 **资源记录(Resource Record,RR)**。RR 提供了主机名到 IP 地址的映射。RR 是一个包含了 `Name`、`Value`、`Type`、`TTL` 四个字段的四元组。 -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/20210506174303797.png) +![DNS 资源记录的四元组字段](https://oss.javaguide.cn/github/javaguide/cs-basics/network/20210506174303797.png) `TTL` 是该记录的生存时间,它决定了资源记录应当从缓存中删除的时间。 `Name` 和 `Value` 字段的取值取决于 `Type`: -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/20210506170307897.png) +![不同 DNS 资源记录类型的 Name 和 Value 含义](https://oss.javaguide.cn/github/javaguide/cs-basics/network/20210506170307897.png) - 如果 `Type=A`,则 `Name` 是主机名信息,`Value` 是该主机名对应的 IP 地址。这样的 RR 记录了一条主机名到 IP 地址的映射。 - 如果 `Type=AAAA`(与 `A` 记录非常相似),唯一的区别是 A 记录使用的是 IPv4,而 `AAAA` 记录使用的是 IPv6。 diff --git a/docs/cs-basics/network/http-status-codes.md b/docs/cs-basics/network/http-status-codes.md index 935c4c7d0b4..0e3917b6d4a 100644 --- a/docs/cs-basics/network/http-status-codes.md +++ b/docs/cs-basics/network/http-status-codes.md @@ -36,7 +36,7 @@ HTTP 状态码是服务端返回给客户端的处理结果摘要。看到一个 🐛 修正(参见:[issue#2458](https://github.com/Snailclimb/JavaGuide/issues/2458)):201 Created 状态码更准确点来说是创建一个或多个新的资源,可以参考:。 -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/rfc9110-201-created.png) +![RFC 9110 中 201 Created 状态码的定义](https://oss.javaguide.cn/github/javaguide/cs-basics/network/rfc9110-201-created.png) 这里格外提一下 204 状态码,平时学习/工作中见到的次数并不多。 diff --git a/docs/cs-basics/network/http-vs-https.md b/docs/cs-basics/network/http-vs-https.md index 3ab2334610b..f3664173826 100644 --- a/docs/cs-basics/network/http-vs-https.md +++ b/docs/cs-basics/network/http-vs-https.md @@ -79,7 +79,7 @@ SSL/TLS 的核心要素是**非对称加密**。非对称加密采用两个密 > > 这样,通信信息就不会被其他人截获了,这依赖于私钥的保密性。 -![](./images/http-vs-https/public-key-cryptography.png) +![非对称加密中公钥加密和私钥解密的过程](./images/http-vs-https/public-key-cryptography.png) 非对称加密的公钥和私钥需要采用一种复杂的数学机制生成(密码学认为,为了较高的安全性,尽量不要自己创造加密方案)。公私钥对的生成算法依赖于单向陷门函数。 @@ -99,7 +99,7 @@ SSL/TLS 的核心要素是**非对称加密**。非对称加密采用两个密 > 对称加密:通信双方共享唯一密钥 k,加解密算法已知,加密方利用密钥 k 加密,解密方利用密钥 k 解密,保密性依赖于密钥 k 的保密性。 -![](./images/http-vs-https/symmetric-encryption.png) +![对称加密中双方使用共享密钥加密通信](./images/http-vs-https/symmetric-encryption.png) 对称加密的密钥生成代价比公私钥对的生成代价低得多。那么有的人会问:为什么 SSL/TLS 还需要使用非对称加密呢?因为对称加密的保密性完全依赖于密钥的保密性。在双方通信之前,需要商量一个用于对称加密的密钥。网络通信的信道是不安全的,传输报文对任何人是可见的,密钥的交换肯定不能直接在网络信道中传输。因此,使用非对称加密对对称加密的密钥进行加密,保护该密钥不在网络信道中被窃听。这样,通信双方只需要一次非对称加密,交换对称加密的密钥,在之后的信息通信中,使用绝对安全的密钥对信息进行对称加密,即可保证传输消息的保密性。 @@ -117,7 +117,7 @@ SSL/TLS 介绍到这里,了解信息安全的朋友又会想到一个安全隐 > > 同样的,S 公钥即使做加密,也难以避免这种信任性问题,C 被 AS 拐跑了! -![](./images/http-vs-https/attack1.png) +![中间人替换服务器公钥导致客户端误信攻击者公钥](./images/http-vs-https/attack1.png) 为了公钥传输的信赖性问题,第三方机构应运而生——证书颁发机构(CA,Certificate Authority)。CA 默认是受信任的第三方。CA 会给各个服务器颁发证书,证书存储在服务器上,并附有 CA 的**电子签名**(见下节)。 @@ -135,7 +135,7 @@ SSL/TLS 介绍到这里,了解信息安全的朋友又会想到一个安全隐 > > 客户端对证书数据(包含服务器的公钥)做相同的散列处理,得到摘要,并将该摘要与之前从签名中解码出的摘要做对比,如果相同,则身份验证成功;否则验证失败。 -![](./images/http-vs-https/digital-signature.png) +![CA 通过数字签名证明证书未被篡改](./images/http-vs-https/digital-signature.png) 总结来说,带有证书的公钥传输机制如下: @@ -145,11 +145,11 @@ SSL/TLS 介绍到这里,了解信息安全的朋友又会想到一个安全隐 4. C 获得 S 的证书,信任 CA 并知晓 CA 公钥,使用 CA 公钥对 S 证书上的签名解密,同时对消息进行散列处理,得到摘要。比较摘要,验证 S 证书的真实性。 5. 如果 C 验证 S 证书是真实的,则信任 S 的公钥(在 S 证书中)。 -![](./images/http-vs-https/public-key-transmission.png) +![HTTPS 通过 CA 证书可信传递服务器公钥](./images/http-vs-https/public-key-transmission.png) 对于数字签名,我这里讲的比较简单,如果你没有搞清楚的话,强烈推荐你看看[数字签名及数字证书原理](https://www.bilibili.com/video/BV18N411X7ty/)这个视频,这是我看过最清晰的讲解。 -![](https://oss.javaguide.cn/github/javaguide/image-20220321121814946.png) +![数字签名及数字证书原理视频讲解截图](https://oss.javaguide.cn/github/javaguide/image-20220321121814946.png) ## 总结 diff --git a/docs/cs-basics/network/http-vs-rpc.md b/docs/cs-basics/network/http-vs-rpc.md index 2e9cbc83d43..1bd17f4e80d 100644 --- a/docs/cs-basics/network/http-vs-rpc.md +++ b/docs/cs-basics/network/http-vs-rpc.md @@ -32,7 +32,7 @@ HTTP 接口不是已经能调了吗? RPC 全称是 Remote Procedure Call,翻译过来就是远程过程调用。它想解决的问题很朴素:**让你调用远程服务时,尽量像调用本地方法一样。** -![RPC 概览](https://oss.javaguide.cn/github/javaguide/distributed-system/rpc/rpc-overview.png) +![RPC 通过本地代理隐藏远程调用细节](https://oss.javaguide.cn/github/javaguide/distributed-system/rpc/rpc-overview.png) 比如本地代码里调用用户服务: @@ -60,7 +60,7 @@ User user = userService.getUser(1001); 具体到实现上,RPC 可以有很多种。Dubbo 是 RPC 框架,Thrift 是 RPC 框架,gRPC 也是 RPC 框架。gRPC 官方文档里也说得很直接:客户端可以像调用本地对象一样,调用另一台机器上服务端应用的方法;服务端定义可远程调用的方法以及参数和返回类型。  -![Dubbo3](https://oss.javaguide.cn/github/javaguide/distributed-system/rpc/image-20220716111545343.png) +![Dubbo3 使用 Triple 协议同时支持 HTTP/1、HTTP/2 和 HTTP/3](https://oss.javaguide.cn/github/javaguide/distributed-system/rpc/image-20220716111545343.png) 这就解释了一个很容易绕晕的点:**gRPC 是 RPC,但它基于 HTTP/2。** diff --git a/docs/cs-basics/network/http1.0-vs-http1.1.md b/docs/cs-basics/network/http1.0-vs-http1.1.md index a16a1eae27a..20a3bc307ea 100644 --- a/docs/cs-basics/network/http1.0-vs-http1.1.md +++ b/docs/cs-basics/network/http1.0-vs-http1.1.md @@ -41,9 +41,9 @@ HTTP/1.0 提供的缓存机制非常简单。服务器端使用 `Expires` 标签 如果服务器判断 `If-Modified-Since` 时间后,资源被修改过,则返回给客户端一个 `200 OK` 的响应体,并附带全新的资源内容,表示“你要的我已经改过的,给你一份新的”。 -![HTTP1.0cache1](./images/http-vs-https/HTTP1.0cache1.png) +![HTTP/1.0 使用 Expires 和 Last-Modified 进行缓存校验](./images/http-vs-https/HTTP1.0cache1.png) -![HTTP1.0cache2](./images/http-vs-https/HTTP1.0cache2.png) +![HTTP/1.0 缓存命中时返回 304 Not Modified](./images/http-vs-https/HTTP1.0cache2.png) ### HTTP/1.1 @@ -150,9 +150,9 @@ Content-Range: bytes 1000-1099/2000 HTTP/1.1 中新加入了状态码 `100`。该状态码的使用场景为,存在某些较大的文件请求,服务器可能不愿意响应这种请求,此时状态码 `100` 可以作为指示请求是否会被正常响应,过程如下图: -![HTTP1.1continue1](./images/http-vs-https/HTTP1.1continue1.png) +![HTTP/1.1 使用 100 Continue 预确认大请求是否可发送](./images/http-vs-https/HTTP1.1continue1.png) -![HTTP1.1continue2](./images/http-vs-https/HTTP1.1continue2.png) +![客户端收到 100 Continue 后继续发送请求体](./images/http-vs-https/HTTP1.1continue2.png) 然而在 HTTP/1.0 中,并没有 `100 (Continue)` 状态码,要想触发这一机制,可以发送一个 `Expect` 头部,其中包含一个 `100-continue` 的值。 diff --git a/docs/cs-basics/network/https-rsa-vs-ecdhe.md b/docs/cs-basics/network/https-rsa-vs-ecdhe.md index 8d129b18ac2..1db5dcc883a 100644 --- a/docs/cs-basics/network/https-rsa-vs-ecdhe.md +++ b/docs/cs-basics/network/https-rsa-vs-ecdhe.md @@ -222,7 +222,7 @@ Server Random 这也是很多人看到密码套件名字后最容易误会的地方。 -![TLS 1.2 ECDHE_RSA 握手流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/https-rsa-ecdhe-tls-1-2-ecdhe-rsa-handshake-process.png) +![TLS 1.2 使用 ECDHE RSA 完成握手和密钥协商](https://oss.javaguide.cn/github/javaguide/cs-basics/network/https-rsa-ecdhe-tls-1-2-ecdhe-rsa-handshake-process.png) ### 密码套件名怎么读 diff --git a/docs/cs-basics/network/maximum-number-of-tcp-connections-per-host.md b/docs/cs-basics/network/maximum-number-of-tcp-connections-per-host.md index 20d8c61d6a7..183450d9ca4 100644 --- a/docs/cs-basics/network/maximum-number-of-tcp-connections-per-host.md +++ b/docs/cs-basics/network/maximum-number-of-tcp-connections-per-host.md @@ -113,7 +113,7 @@ NAT 做的事情是把内网地址转换成公网地址。比如内网机器 `19 ## TIME_WAIT 会怎样影响连接数? -![TIME_WAIT 对连接数的影响](https://oss.javaguide.cn/github/javaguide/ai/context-engineering/how-time-wait-affects-number-of-connections.png) +![TIME_WAIT 状态占用本地端口并影响可建立连接数](https://oss.javaguide.cn/github/javaguide/ai/context-engineering/how-time-wait-affects-number-of-connections.png) 典型情况下,**主动关闭连接的一方会进入 `TIME_WAIT`**——因为它需要在发送最后一个 ACK 后等待一段时间,防止最后 ACK 丢失以及旧报文影响后续连接。(同时关闭场景下,双方都会进入 TIME_WAIT,不过日常碰到的绝大多数是前者。) @@ -143,7 +143,7 @@ NAT 做的事情是把内网地址转换成公网地址。比如内网机器 `19 排查这类问题,优先修连接复用。确认连接池、keep-alive、超时和关闭策略都没问题之后,再考虑扩大临时端口范围,或者增加源 IP。不要一上来就改内核参数。 -![TIME_WAIT 与 CLOSE_WAIT 排查流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-time-wait-close-wait-troubleshooting-flowchart.png) +![TIME_WAIT 与 CLOSE_WAIT 问题的排查流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-time-wait-close-wait-troubleshooting-flowchart.png) 排查时可以用 `ss -ant` 统计各 TCP 状态数量,`ss -ant state time-wait | awk 'NR>1 {print $5}' | sort | uniq -c | sort -nr | head` 查看 TIME_WAIT 集中在哪些目标,`ss -ltn` 查看监听 socket 的 accept queue 堆积情况。看到 TIME_WAIT 集中在某个远端服务,检查短连接和连接池;看到 CLOSE_WAIT 集中在某个本地进程,优先查应用代码有没有正确关闭连接。 diff --git a/docs/cs-basics/network/nat.md b/docs/cs-basics/network/nat.md index 657a4e39d5b..adfabc04345 100644 --- a/docs/cs-basics/network/nat.md +++ b/docs/cs-basics/network/nat.md @@ -31,7 +31,7 @@ SOHO 子网的“代理人”,也就是和外界的窗口,通常由路由器 ## 细节 -![NAT 协议](https://oss.javaguide.cn/github/javaguide/cs-basics/network/nat-demo.png) +![NAT 将内网私有地址转换为公网地址的过程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/nat-demo.png) 假设当前场景如上图。中间是一个路由器,它的右侧组织了一个 LAN,网络号为 `10.0.0/24`。LAN 侧接口的 IP 地址为 `10.0.0.4`,并且该子网内有至少三台主机,分别是 `10.0.0.1`、`10.0.0.2` 和 `10.0.0.3`。路由器的左侧连接的是 WAN,WAN 侧接口的 IP 地址为 `138.76.29.7`。 diff --git a/docs/cs-basics/network/network-attack-means.md b/docs/cs-basics/network/network-attack-means.md index 0f5546229c6..31da1e35d87 100644 --- a/docs/cs-basics/network/network-attack-means.md +++ b/docs/cs-basics/network/network-attack-means.md @@ -35,7 +35,7 @@ IP 欺骗、SYN Flood、DDoS、ARP 欺骗、DNS 劫持这些攻击,表面上 **IP 头部格式**: -![](https://oss.javaguide.cn/p3-juejin/843fd07074874ee0b695eca659411b42~tplv-k3u1fbpfcp-zoom-1.png) +![IP 数据包头部字段格式](https://oss.javaguide.cn/p3-juejin/843fd07074874ee0b695eca659411b42~tplv-k3u1fbpfcp-zoom-1.png) ### IP 欺骗技术是什么? @@ -47,7 +47,7 @@ IP 欺骗技术就是伪造某台主机的 IP 地址的技术。通过 IP 地址 这时,如果合法用户 **1.1.1.1** 再发送合法数据,服务器就已经没有这样的连接了,该用户就必须从新开始建立连接。攻击时,伪造大量的 IP 地址,向目标发送 RST 数据,使服务器不对合法用户服务。虽然 IP 地址欺骗攻击有着相当难度,但我们应该清醒地意识到,这种攻击非常广泛,入侵往往从这种攻击开始。 -![IP 欺骗 DDoS 攻击](https://oss.javaguide.cn/p3-juejin/7547a145adf9404aa3a05f01f5ca2e32~tplv-k3u1fbpfcp-zoom-1.png) +![攻击者伪造源 IP 发送 RST 数据段中断合法连接](https://oss.javaguide.cn/p3-juejin/7547a145adf9404aa3a05f01f5ca2e32~tplv-k3u1fbpfcp-zoom-1.png) ### 如何缓解 IP 欺骗? @@ -62,13 +62,13 @@ SYN Flood 是互联网上最原始、最经典的 DDoS(Distributed Denial of S SYN Flood 利用了 TCP 协议的三次握手机制,攻击者通常利用工具或者控制僵尸主机向服务器发送海量的变源 IP 地址或变源端口的 TCP SYN 报文,服务器响应了这些报文后就会生成大量的半连接,当系统资源被耗尽后,服务器将无法提供正常的服务。 增加服务器性能、提供更多的连接能力对于 SYN Flood 的海量报文来说杯水车薪。防御 SYN Flood 的关键在于判断哪些连接请求来自于真实源,屏蔽非真实源的请求以保障正常的业务请求能得到服务。 -![](https://oss.javaguide.cn/p3-juejin/2b3d2d4dc8f24890b5957df1c7d6feb8~tplv-k3u1fbpfcp-zoom-1.png) +![SYN Flood 攻击通过大量半连接耗尽服务器资源](https://oss.javaguide.cn/p3-juejin/2b3d2d4dc8f24890b5957df1c7d6feb8~tplv-k3u1fbpfcp-zoom-1.png) ### TCP SYN Flood 攻击原理是什么? **TCP SYN Flood** 攻击利用的是 **TCP** 的三次握手(**SYN -> SYN/ACK -> ACK**),假设连接发起方是 A,连接接受方是 B,即 B 在某个端口(**Port**)上监听 A 发出的连接请求,过程如下图所示,左边是 A,右边是 B。 -![](https://oss.javaguide.cn/p3-juejin/a39355a1ea404323a11ca6644e009183~tplv-k3u1fbpfcp-zoom-1.png) +![TCP 三次握手建立连接的正常流程](https://oss.javaguide.cn/p3-juejin/a39355a1ea404323a11ca6644e009183~tplv-k3u1fbpfcp-zoom-1.png) A 首先发送 **SYN**(Synchronization)消息给 B,要求 B 做好接收数据的准备;B 收到后反馈 **SYN-ACK**(Synchronization-Acknowledgement) 消息给 A,这个消息的目的有两个: @@ -85,7 +85,7 @@ A 首先发送 **SYN**(Synchronization)消息给 B,要求 B 做好接收 假设 B 通过某 **TCP** 端口提供服务,B 在收到 A 的 **SYN** 消息时,积极的反馈了 **SYN-ACK** 消息,使连接进入**半开状态**,因为 B 不确定自己发给 A 的 **SYN-ACK** 消息或 A 反馈的 ACK 消息是否会丢在半路,所以会给每个待完成的半开连接都设一个**Timer**,如果超过时间还没有收到 A 的 **ACK** 消息,则重新发送一次 **SYN-ACK** 消息给 A,直到重试超过一定次数时才会放弃。 -![图片](https://oss.javaguide.cn/p3-juejin/7ff1daddcec44d61994f254e664987b4~tplv-k3u1fbpfcp-zoom-1.png) +![SYN Flood 中大量半开连接占用服务器资源](https://oss.javaguide.cn/p3-juejin/7ff1daddcec44d61994f254e664987b4~tplv-k3u1fbpfcp-zoom-1.png) B 为帮助 A 能顺利连接,需要**分配内核资源**维护半开连接,那么当 B 面临海量的连接 A 时,如上图所示,**SYN Flood** 攻击就形成了。攻击方 A 可以控制肉鸡向 B 发送大量 SYN 消息但不响应 ACK 消息,或者干脆伪造 SYN 消息中的 **Source IP**,使 B 反馈的 **SYN-ACK** 消息石沉大海,导致 B 被大量注定不能完成的半开连接占据,直到资源耗尽,停止响应正常的连接请求。 @@ -132,7 +132,7 @@ B 为帮助 A 能顺利连接,需要**分配内核资源**维护半开连接 由于目标服务器利用资源检查并响应每个接收到的 **UDP** 数据包的结果,当接收到大量 **UDP** 数据包时,目标的资源可能会迅速耗尽,导致对正常流量的拒绝服务。 -![](https://oss.javaguide.cn/p3-juejin/23dbbc8243a84ed181e088e38bffb37a~tplv-k3u1fbpfcp-zoom-1.png) +![UDP Flood 通过大量 UDP 数据包消耗服务器资源](https://oss.javaguide.cn/p3-juejin/23dbbc8243a84ed181e088e38bffb37a~tplv-k3u1fbpfcp-zoom-1.png) ### 如何缓解 UDP Flood? @@ -144,7 +144,7 @@ B 为帮助 A 能顺利连接,需要**分配内核资源**维护半开连接 HTTP Flood 是一种大规模的 DDoS(Distributed Denial of Service,分布式拒绝服务)攻击,旨在利用 HTTP 请求使目标服务器不堪重负。目标因请求而达到饱和,且无法响应正常流量后,将出现拒绝服务,拒绝来自实际用户的其他请求。 -![HTTP 洪水攻击](https://oss.javaguide.cn/p3-juejin/aa64869551d94c8d89fa80eaf4395bfa~tplv-k3u1fbpfcp-zoom-1.png) +![HTTP Flood 通过大量应用层请求压垮目标服务器](https://oss.javaguide.cn/p3-juejin/aa64869551d94c8d89fa80eaf4395bfa~tplv-k3u1fbpfcp-zoom-1.png) ### HTTP Flood 的攻击原理是什么? @@ -171,7 +171,7 @@ HTTP 洪水攻击有两种: ### DNS Flood 的攻击原理是什么? -![](https://oss.javaguide.cn/p3-juejin/97ea11a212924900b10d159226783887~tplv-k3u1fbpfcp-zoom-1.png) +![DNS Flood 使用大量 DNS 查询淹没 DNS 服务器](https://oss.javaguide.cn/p3-juejin/97ea11a212924900b10d159226783887~tplv-k3u1fbpfcp-zoom-1.png) 域名系统的功能是将易于记忆的名称(例如 example.com)转换成难以记住的网站服务器地址(例如 192.168.0.1),因此成功攻击 DNS 基础设施将导致大多数人无法使用互联网。DNS Flood 攻击是一种相对较新的基于 DNS 的攻击,这种攻击是在高带宽[物联网(IoT)](https://www.cloudflare.com/learning/ddos/glossary/internet-of-things-iot/)[僵尸网络](https://www.cloudflare.com/learning/ddos/what-is-a-ddos-botnet/)(如 [Mirai](https://www.cloudflare.com/learning/ddos/glossary/mirai-botnet/))兴起后激增的。DNS Flood 攻击使用 IP 摄像头、DVR 盒和其他 IoT 设备的高带宽连接直接淹没主要提供商的 DNS 服务器。来自 IoT 设备的大量请求淹没 DNS 提供商的服务,阻止合法用户访问提供商的 DNS 服务器。 @@ -224,13 +224,13 @@ nc 127.0.0.1 8000 该命令会尝试与上面的服务建立连接,在其中一个窗口输入一些字符,就会通过 TCP 连接发送给另一个窗口并打印出来。 -![](https://oss.javaguide.cn/p3-juejin/df0508cbf26446708cf98f8ad514dbea~tplv-k3u1fbpfcp-zoom-1.gif) +![使用 nc 建立本地 TCP 连接并传输数据](https://oss.javaguide.cn/p3-juejin/df0508cbf26446708cf98f8ad514dbea~tplv-k3u1fbpfcp-zoom-1.gif) > 嗅探流量 编写一个攻击程序,使用 Python 网络库 `scapy` 来读取两个终端窗口之间交换的数据,并将其打印到终端上。代码比较长,下面为一部份,完整代码后台回复 TCP 攻击,代码的核心是调用 `scapy` 的嗅探方法: -![](https://oss.javaguide.cn/p3-juejin/27feb834aa9d4b629fd938611ac9972e~tplv-k3u1fbpfcp-zoom-1.png) +![使用 Scapy 嗅探本地 TCP 连接数据包的代码](https://oss.javaguide.cn/p3-juejin/27feb834aa9d4b629fd938611ac9972e~tplv-k3u1fbpfcp-zoom-1.png) 这段代码告诉 `scapy` 在 `lo0` 网络接口上嗅探数据包,并记录所有 TCP 连接的详细信息。 @@ -266,7 +266,7 @@ nc 127.0.0.1 8000 中间人攻击英文名叫 Man-in-the-Middle Attack,简称「MITM 攻击」。指攻击者与通讯的两端分别创建独立的联系,并交换其所收到的数据,使通讯的两端认为他们正在通过一个私密的连接与对方直接对话,但事实上整个会话都被攻击者完全控制。我们画一张图: -![图片](https://oss.javaguide.cn/p3-juejin/d69b74e63981472b852797f2fa08976f~tplv-k3u1fbpfcp-zoom-1.png) +![中间人攻击拦截并篡改通信双方消息](https://oss.javaguide.cn/p3-juejin/d69b74e63981472b852797f2fa08976f~tplv-k3u1fbpfcp-zoom-1.png) 从这张图可以看到,中间人其实就是攻击者。通过这种原理,有很多实现的用途,比如说,你在手机上浏览不健康网站的时候,手机就会提示你,此网站可能含有病毒,是否继续访问还是做其他的操作等等。 @@ -306,7 +306,7 @@ nc 127.0.0.1 8000 同样的,举个例子。Sum 和 Mike 两个人签合同。Sum 首先用 **SHA** 算法计算合同的摘要,然后用自己私钥将摘要加密,得到数字签名。Sum 将合同原文、签名,以及公钥三者都交给 Mike -![](https://oss.javaguide.cn/p3-juejin/e4b7d6fca78b45c8840c12411b717f2f~tplv-k3u1fbpfcp-zoom-1.png) +![数字签名用私钥加密摘要并用公钥验签](https://oss.javaguide.cn/p3-juejin/e4b7d6fca78b45c8840c12411b717f2f~tplv-k3u1fbpfcp-zoom-1.png) 如果 Sum 想要证明合同是 Mike 的,那么就要使用 Mike 的公钥,将这个签名解密得到摘要 x,然后 Mike 计算原文的 sha 摘要 Y,随后对比 x 和 y,如果两者相等,就认为数据没有被篡改 @@ -322,7 +322,7 @@ nc 127.0.0.1 8000 对称加密,顾名思义,加密方与解密方使用同一钥匙(秘钥)。具体一些就是,发送方通过使用相应的加密算法和秘钥,对将要发送的信息进行加密;对于接收方而言,使用解密算法和相同的秘钥解锁信息,从而有能力阅读信息。 -![图片](https://oss.javaguide.cn/p3-juejin/ef81cb5e2f0a4d3d9ac5a44ecf97e3cc~tplv-k3u1fbpfcp-zoom-1.png) +![对称加密中通信双方使用同一密钥加解密](https://oss.javaguide.cn/p3-juejin/ef81cb5e2f0a4d3d9ac5a44ecf97e3cc~tplv-k3u1fbpfcp-zoom-1.png) #### 常见的对称加密算法有哪些? @@ -330,7 +330,7 @@ nc 127.0.0.1 8000 DES 使用的密钥表面上是 64 位的,然而只有其中的 56 位被实际用于算法,其余 8 位可以被用于奇偶校验,并在算法中被丢弃。因此,**DES** 的有效密钥长度为 56 位,通常称 **DES** 的密钥长度为 56 位。假设秘钥为 56 位,采用暴力破 Jie 的方式,其秘钥个数为 2 的 56 次方,那么每纳秒执行一次解密所需要的时间差不多 1 年的样子。当然,没人这么干。**DES** 现在已经不是一种安全的加密方法,主要因为它使用的 56 位密钥过短。 -![](https://oss.javaguide.cn/p3-juejin/9eb3a2bf6cf14132a890bc3447480eeb~tplv-k3u1fbpfcp-zoom-1.jpeg) +![DES 对称加密算法示意图](https://oss.javaguide.cn/p3-juejin/9eb3a2bf6cf14132a890bc3447480eeb~tplv-k3u1fbpfcp-zoom-1.jpeg) **IDEA** @@ -346,13 +346,13 @@ DES 使用的密钥表面上是 64 位的,然而只有其中的 56 位被实 **总结**: -![](https://oss.javaguide.cn/p3-juejin/578961e3175540e081e1432c409b075a~tplv-k3u1fbpfcp-zoom-1.png) +![常见对称加密算法对比总结](https://oss.javaguide.cn/p3-juejin/578961e3175540e081e1432c409b075a~tplv-k3u1fbpfcp-zoom-1.png) #### 常见的非对称加密算法有哪些? 在对称加密中,发送方与接收方使用相同的秘钥。那么在非对称加密中则是发送方与接收方使用的不同的秘钥。其主要解决的问题是防止在秘钥协商的过程中发生泄漏。比如在对称加密中,小蓝将需要发送的消息加密,然后告诉你密码是 123balala,ok,对于其他人而言,很容易就能劫持到密码是 123balala。那么在非对称的情况下,小蓝告诉所有人密码是 123balala,对于中间人而言,拿到也没用,因为没有私钥。所以,非对称密钥其实主要解决了密钥分发的难题。如下图 -![](https://oss.javaguide.cn/p3-juejin/153cf04a0ecc43c38003f3a1ab198cc0~tplv-k3u1fbpfcp-zoom-1.png) +![非对称加密使用公钥和私钥完成加解密](https://oss.javaguide.cn/p3-juejin/153cf04a0ecc43c38003f3a1ab198cc0~tplv-k3u1fbpfcp-zoom-1.png) 其实我们经常都在使用非对称加密,比如使用多台服务器搭建大数据平台 Hadoop,为了方便多台机器设置免密登录,是不是就会涉及到秘钥分发。再比如搭建 Docker 集群也会使用相关非对称加密算法。 @@ -364,7 +364,7 @@ DES 使用的密钥表面上是 64 位的,然而只有其中的 56 位被实 总结: -![](https://oss.javaguide.cn/p3-juejin/28b96fb797904d4b818ee237cdc7614c~tplv-k3u1fbpfcp-zoom-1.png) +![常见非对称加密算法对比总结](https://oss.javaguide.cn/p3-juejin/28b96fb797904d4b818ee237cdc7614c~tplv-k3u1fbpfcp-zoom-1.png) #### 常见的散列算法有哪些? @@ -384,7 +384,7 @@ MD5 可以用来生成一个 128 位的消息摘要,它是目前应用比较 **总结**: -![图片](https://oss.javaguide.cn/p3-juejin/79c3c2f72d2f44c7abf2d73a49024495~tplv-k3u1fbpfcp-zoom-1.png) +![常见散列算法对比总结](https://oss.javaguide.cn/p3-juejin/79c3c2f72d2f44c7abf2d73a49024495~tplv-k3u1fbpfcp-zoom-1.png) **大部分情况下使用对称加密,具有比较不错的安全性。如果需要分布式进行秘钥分发,考虑非对称。如果不需要可逆计算则使用散列算法。** @@ -396,7 +396,7 @@ MD5 可以用来生成一个 128 位的消息摘要,它是目前应用比较 证书之所以会有信用,是因为证书的签发方拥有信用。所以如果 Sum 想让 Mike 承认自己的公钥,Sum 不会直接将公钥给 Mike,而是提供由第三方机构签发的含有公钥的证书。如果 Mike 也信任这个机构,法律都认可,那信任关系成立。 -![](https://oss.javaguide.cn/p3-juejin/b1a3dbf87e3e41ff894f39512a10f66d~tplv-k3u1fbpfcp-zoom-1.png) +![第三方机构签发证书并完成验签的过程](https://oss.javaguide.cn/p3-juejin/b1a3dbf87e3e41ff894f39512a10f66d~tplv-k3u1fbpfcp-zoom-1.png) 如上图所示,Sum 将自己的申请提交给机构,产生证书的原文。机构用自己的私钥签名 Sum 的申请原文(先根据原文内容计算摘要,再用私钥加密),得到带有签名信息的证书。Mike 拿到带签名信息的证书,通过第三方机构的公钥进行解密,获得 Sum 证书的摘要、证书的原文。有了 Sum 证书的摘要和原文,Mike 就可以进行验签。验签通过,Mike 就可以确认 Sum 的证书的确是第三方机构签发的。 @@ -404,7 +404,7 @@ MD5 可以用来生成一个 128 位的消息摘要,它是目前应用比较 为了让这个信任条更加稳固,就需要环环相扣,打造更长的信任链,避免单点信任风险。 -![](https://oss.javaguide.cn/p3-juejin/1481f0409da94ba6bb0fee69bf0996f8~tplv-k3u1fbpfcp-zoom-1.png) +![根证书到终端证书的信任链](https://oss.javaguide.cn/p3-juejin/1481f0409da94ba6bb0fee69bf0996f8~tplv-k3u1fbpfcp-zoom-1.png) 上图中,由信誉最好的根证书机构提供根证书,然后根证书机构去签发二级机构的证书;二级机构去签发三级机构的证书;最后有由三级机构去签发 Sum 证书。 @@ -420,7 +420,7 @@ MD5 可以用来生成一个 128 位的消息摘要,它是目前应用比较 既然知道了中间人攻击的原理也知道了他的危险,现在我们看看如何避免。相信我们都遇到过下面这种状况: -![](https://oss.javaguide.cn/p3-juejin/0dde4b76be6240699312d822a3fe1ed3~tplv-k3u1fbpfcp-zoom-1.png) +![浏览器提示证书不受信任的安全警告](https://oss.javaguide.cn/p3-juejin/0dde4b76be6240699312d822a3fe1ed3~tplv-k3u1fbpfcp-zoom-1.png) 出现这个界面的很多情况下,都是遇到了中间人攻击的现象,需要对安全证书进行及时地监测。而且大名鼎鼎的 github 网站,也曾遭遇过中间人攻击: diff --git a/docs/cs-basics/network/osi-and-tcp-ip-model.md b/docs/cs-basics/network/osi-and-tcp-ip-model.md index 1456e3b9575..65fdf89cfeb 100644 --- a/docs/cs-basics/network/osi-and-tcp-ip-model.md +++ b/docs/cs-basics/network/osi-and-tcp-ip-model.md @@ -25,7 +25,7 @@ head: **OSI 七层模型** 是国际标准化组织提出一个网络分层模型,其大体结构以及每一层提供的功能如下图所示: -![OSI 七层模型](https://oss.javaguide.cn/github/javaguide/cs-basics/network/osi-7-model.png) +![OSI 七层模型各层功能划分](https://oss.javaguide.cn/github/javaguide/cs-basics/network/osi-7-model.png) 每一层都专注做一件事情,并且每一层都需要使用下一层提供的功能比如传输层需要使用网络层提供的路由和寻址功能,这样传输层才知道把数据传输到哪里去。 @@ -48,7 +48,7 @@ OSI 七层模型虽然失败了,但是却提供了很多不错的理论基础 最后再分享一个关于 OSI 七层模型非常不错的总结图片! -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/osi-model-detail.png) +![OSI 七层模型和 TCP/IP 四层模型的层级对应关系](https://oss.javaguide.cn/github/javaguide/cs-basics/network/osi-model-detail.png) ## TCP/IP 四层模型 @@ -61,13 +61,13 @@ OSI 七层模型虽然失败了,但是却提供了很多不错的理论基础 需要注意的是,我们并不能将 TCP/IP 四层模型 和 OSI 七层模型完全精确地匹配起来,不过可以简单将两者对应起来,如下图所示: -![TCP/IP 四层模型](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) +![TCP/IP 四层模型各层功能划分](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) ### 应用层(Application layer) **应用层位于传输层之上,主要提供两个终端设备上的应用程序之间信息交换的服务,它定义了信息交换的格式,消息会交给下一层传输层来传输。** 我们把应用层交互的数据单元称为报文。 -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/network-five-layer-sample-diagram.png) +![网络五层模型在一次数据传输中的协作过程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/network-five-layer-sample-diagram.png) 应用层协议定义了网络通信规则,对于不同的网络应用需要不同的应用层协议。在互联网中应用层协议很多,如支持 Web 应用的 HTTP 协议,支持电子邮件的 SMTP 协议等等。 diff --git a/docs/cs-basics/network/other-network-questions.md b/docs/cs-basics/network/other-network-questions.md index b5fbf2fdc94..84ff5365491 100644 --- a/docs/cs-basics/network/other-network-questions.md +++ b/docs/cs-basics/network/other-network-questions.md @@ -24,7 +24,7 @@ head: **OSI 七层模型** 是国际标准化组织提出的一个网络分层模型,其大体结构以及每一层提供的功能如下图所示: -![OSI 七层模型](https://oss.javaguide.cn/github/javaguide/cs-basics/network/osi-7-model.png) +![OSI 七层模型各层功能划分](https://oss.javaguide.cn/github/javaguide/cs-basics/network/osi-7-model.png) 每一层都专注做一件事情,并且每一层都需要使用下一层提供的功能比如传输层需要使用网络层提供的路由和寻址功能,这样传输层才知道把数据传输到哪里去。 @@ -45,7 +45,7 @@ head: 需要注意的是,我们并不能将 TCP/IP 四层模型 和 OSI 七层模型完全精确地匹配起来,不过可以简单将两者对应起来,如下图所示: -![TCP/IP 四层模型](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) +![TCP/IP 四层模型与 OSI 模型的对应关系](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) 关于每一层作用的详细介绍,请看 [OSI 和 TCP/IP 网络分层模型详解(基础)](https://javaguide.cn/cs-basics/network/osi-and-tcp-ip-model.html) 这篇文章。 @@ -113,7 +113,7 @@ head: 先来看一张图(来源于《图解 HTTP》): - +从输入 URL 到页面展示的完整流程 上图有一个错误需要注意:是 OSPF 不是 OPSF。 OSPF(Open Shortest Path First,ospf)开放最短路径优先协议, 是由 Internet 工程任务组开发的路由选择协议 @@ -242,7 +242,7 @@ HTTP 能调服务,RPC 也能调服务。真正的区别在于,你是想把 HTTP/2.0 多路复用效果图(图源: [HTTP/2 For Web Developers](https://blog.cloudflare.com/http-2-for-web-developers/)): -![HTTP/2 Multiplexing](https://oss.javaguide.cn/github/javaguide/cs-basics/network/http2.0-multiplexing.png) +![HTTP/2 在单个 TCP 连接上多路复用多个请求和响应](https://oss.javaguide.cn/github/javaguide/cs-basics/network/http2.0-multiplexing.png) 可以看到,HTTP/2 的多路复用机制允许多个请求和响应共享一个 TCP 连接,从而避免了 HTTP/1.1 在应对并发请求时需要建立多个并行连接的情况,减少了重复连接建立和维护的额外开销。而在 HTTP/1.1 中,尽管支持持久连接,但为了缓解队头阻塞问题,浏览器通常会为同一域名建立多个并行连接。 @@ -260,7 +260,7 @@ HTTP/2.0 多路复用效果图(图源: [HTTP/2 For Web Developers](https://b HTTP/1.0、HTTP/2.0 和 HTTP/3.0 的协议栈比较: -![http-3-implementation](https://oss.javaguide.cn/github/javaguide/cs-basics/network/http-3-implementation.png) +![HTTP/1、HTTP/2 和 HTTP/3 协议栈对比](https://oss.javaguide.cn/github/javaguide/cs-basics/network/http-3-implementation.png) 下图是一个更详细的 HTTP/2.0 和 HTTP/3.0 对比图: @@ -304,7 +304,7 @@ HTTP 协议本身是 **无状态的 (stateless)** 。这意味着服务器默认 **方案一:Session (会话) 配合 Cookie (主流方式):** -![](https://oss.javaguide.cn/github/javaguide/system-design/security/session-cookie-authentication-process.png) +![Session 配合 Cookie 保存用户登录状态的流程](https://oss.javaguide.cn/github/javaguide/system-design/security/session-cookie-authentication-process.png) 这可以说是最经典也是最常用的方法了。基本流程是这样的: @@ -392,7 +392,7 @@ WebSocket 协议在 2008 年诞生,2011 年成为国际标准,几乎所有 WebSocket 协议本质上是应用层的协议,用于弥补 HTTP 协议在持久通信能力上的不足。客户端和服务器仅需一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输。 -![Websocket 示意图](https://oss.javaguide.cn/github/javaguide/system-design/web-real-time-message-push/1460000042192394.png) +![WebSocket 建立持久连接实现双向通信](https://oss.javaguide.cn/github/javaguide/system-design/web-real-time-message-push/1460000042192394.png) 下面是 WebSocket 的常见应用场景: @@ -458,7 +458,7 @@ WebSocket 的工作过程可以分为以下几个步骤: - **使用限制**:需要服务器和客户端都支持 WebSocket 协议。对连接管理有一定要求(如心跳保活、断线重连等)。 - **实现麻烦**:实现起来比短轮询和长轮询要更麻烦一些。 -![Websocket 示意图](https://oss.javaguide.cn/github/javaguide/system-design/web-real-time-message-push/1460000042192394.png) +![WebSocket 与短轮询和长轮询的通信方式对比](https://oss.javaguide.cn/github/javaguide/system-design/web-real-time-message-push/1460000042192394.png) ### ⭐️SSE 与 WebSocket 有什么区别? @@ -486,7 +486,7 @@ SSE (Server-Sent Events) 和 WebSocket 都是用来实现服务器向浏览器 ![DeepSeek 响应标头](https://oss.javaguide.cn/github/javaguide/cs-basics/network/deepseek-sse.png) -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/deepseek-sse-eventstream.png) +![DeepSeek SSE 响应使用 text/event-stream 持续传输事件](https://oss.javaguide.cn/github/javaguide/cs-basics/network/deepseek-sse-eventstream.png) 可以看到,响应头里包含了 `text/event-stream`,说明使用的确实是 SSE。并且,响应数据也确实是持续分块传输。 @@ -565,7 +565,7 @@ Ping 使用 ICMP(网络层),TCP 连接使用 TCP(传输层),两者 DNS(Domain Name System)域名管理系统,是当用户使用浏览器访问网址之后,使用的第一个重要协议。DNS 要解决的是**域名和 IP 地址的映射问题**。 -![DNS:域名系统](https://oss.javaguide.cn/github/javaguide/cs-basics/network/dns-overview.png) +![DNS 将域名解析为 IP 地址的系统概览](https://oss.javaguide.cn/github/javaguide/cs-basics/network/dns-overview.png) 在一台电脑上,可能存在浏览器 DNS 缓存,操作系统 DNS 缓存,路由器 DNS 缓存。如果以上缓存都查询不到,那么 DNS 就闪亮登场了。 diff --git a/docs/cs-basics/network/other-network-questions2.md b/docs/cs-basics/network/other-network-questions2.md index 6cd96a8e309..be066ec1681 100644 --- a/docs/cs-basics/network/other-network-questions2.md +++ b/docs/cs-basics/network/other-network-questions2.md @@ -85,7 +85,7 @@ HTTP/3.0 之前是基于 TCP 协议的,而 HTTP/3.0 将弃用 TCP,改用 ** - **HTTP/1.x 和 HTTP/2.0**:这两个版本的 HTTP 协议都明确建立在 TCP 之上。TCP 提供了可靠的、面向连接的传输,确保数据按序、无差错地到达,这对于网页内容的正确展示非常重要。发送 HTTP 请求前,需要先通过 TCP 的三次握手建立连接。 - **HTTP/3.0**:这是一个重大的改变。HTTP/3 弃用了 TCP,转而使用 QUIC 协议,而 QUIC 是构建在 UDP 之上的。 -![http-3-implementation](https://oss.javaguide.cn/github/javaguide/cs-basics/network/http-3-implementation.png) +![HTTP/1、HTTP/2 和 HTTP/3 协议栈对比](https://oss.javaguide.cn/github/javaguide/cs-basics/network/http-3-implementation.png) **为什么 HTTP/3 要做这个改变呢?主要有两大原因:** @@ -231,7 +231,7 @@ TCP Keepalive 是"被动回收"——它必须先发探测包去问"你还在吗 经典例子:DNS 同时使用 `UDP/53`(日常查询)和 `TCP/53`(响应过大、区域传送);HTTP/3 常见部署是 `UDP/443`(QUIC),可以和传统 HTTPS 的 `TCP/443` 同时存在。 -![实际应用示例](https://oss.javaguide.cn/github/javaguide/cs-basics/network/can-tcp-and-udp-use-the-same-port-practical-application-example.png) +![DNS 和 HTTP/3 同时使用 TCP 与 UDP 端口的实际案例](https://oss.javaguide.cn/github/javaguide/cs-basics/network/can-tcp-and-udp-use-the-same-port-practical-application-example.png) 详细介绍:[TCP 和 UDP 可以使用同一个端口吗?](./can-tcp-and-udp-use-the-same-port.md) @@ -283,11 +283,11 @@ IP 地址过滤是一种简单的网络安全措施,实际应用中一般会 **IPv4(Internet Protocol version 4)** 是目前广泛使用的 IP 地址版本,其格式是四组由点分隔的数字,例如:123.89.46.72。IPv4 使用 32 位地址作为其 Internet 地址,这意味着共有约 42 亿( 2^32)个可用 IP 地址。 -![IPv4](https://oss.javaguide.cn/github/javaguide/cs-basics/network/Figure-1-IPv4Addressformatwithdotteddecimalnotation-29c824f6a451d48d8c27759799f0c995.png) +![IPv4 地址使用点分十进制格式表示 32 位地址](https://oss.javaguide.cn/github/javaguide/cs-basics/network/Figure-1-IPv4Addressformatwithdotteddecimalnotation-29c824f6a451d48d8c27759799f0c995.png) 这么少当然不够用啦!为了解决 IP 地址耗尽的问题,最根本的办法是采用具有更大地址空间的新版本 IP 协议 - **IPv6(Internet Protocol version 6)**。IPv6 地址使用更复杂的格式,该格式使用由单或双冒号分隔的一组数字和字母,例如:2001:0db8:85a3:0000:0000:8a2e:0370:7334 。IPv6 使用 128 位互联网地址,这意味着越有 2^128(3 开头的 39 位数字,恐怖如斯) 个可用 IP 地址。 -![IPv6](https://oss.javaguide.cn/github/javaguide/cs-basics/network/Figure-2-IPv6Addressformatwithhexadecimalnotation-7da3a419bd81627a9b2cef3b0efb4940.png) +![IPv6 地址使用十六进制冒号分隔格式表示 128 位地址](https://oss.javaguide.cn/github/javaguide/cs-basics/network/Figure-2-IPv6Addressformatwithhexadecimalnotation-7da3a419bd81627a9b2cef3b0efb4940.png) 除了更大的地址空间之外,IPv6 的优势还包括: diff --git a/docs/cs-basics/network/tcp-keepalive-vs-http-keepalive.md b/docs/cs-basics/network/tcp-keepalive-vs-http-keepalive.md index 061f7dd6c51..2cc78d767a7 100644 --- a/docs/cs-basics/network/tcp-keepalive-vs-http-keepalive.md +++ b/docs/cs-basics/network/tcp-keepalive-vs-http-keepalive.md @@ -17,7 +17,7 @@ head: - **HTTP Keep-Alive** 是应用层的机制,解决的问题是:一个 TCP 连接能不能被多个 HTTP 请求复用,别每次请求都重新握手。 - **TCP Keepalive** 是传输层的机制,解决的问题是:一条 TCP 连接长时间没有数据往来,怎么判断对端还在不在,要不要把连接占用的资源回收掉。 -![TCP/IP 四层模型](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) +![TCP/IP 四层模型中 HTTP 与 TCP 所在层次](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-ip-4-model.png) 一个管"连接要不要复用",一个管"连接还活不活着"。协议层不同,目的也不同,只是名字撞了。 diff --git a/docs/cs-basics/network/tcp-time-wait.md b/docs/cs-basics/network/tcp-time-wait.md index a2caf125c7f..01f1e71513a 100644 --- a/docs/cs-basics/network/tcp-time-wait.md +++ b/docs/cs-basics/network/tcp-time-wait.md @@ -132,7 +132,7 @@ Cannot assign requested address ## 排查时别只盯着数量,要先看谁在主动关闭 -![TIME_WAIT 与 CLOSE_WAIT 排查流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-time-wait-close-wait-troubleshooting-flowchart.png) +![TIME_WAIT 与 CLOSE_WAIT 问题的排查流程](https://oss.javaguide.cn/github/javaguide/cs-basics/network/tcp-time-wait-close-wait-troubleshooting-flowchart.png) 看到大量 `TIME_WAIT` 或 `CLOSE_WAIT`,可以先用下面几条命令定位方向: diff --git a/docs/cs-basics/network/the-whole-process-of-accessing-web-pages.md b/docs/cs-basics/network/the-whole-process-of-accessing-web-pages.md index 69cdea6342a..2abca3f174d 100644 --- a/docs/cs-basics/network/the-whole-process-of-accessing-web-pages.md +++ b/docs/cs-basics/network/the-whole-process-of-accessing-web-pages.md @@ -26,7 +26,7 @@ head: 总的来说,网络通信模型可以用下图来表示。访问网页的过程,就是数据从应用层逐层向下封装,经物理网络传输到对端,再逐层向上解封装的过程。 -![](https://oss.javaguide.cn/github/javaguide/cs-basics/network/five-layers.png) +![五层网络模型在网页访问过程中的协作](https://oss.javaguide.cn/github/javaguide/cs-basics/network/five-layers.png) 开始之前,先简单过一遍完整流程: diff --git a/docs/cs-basics/operating-system/linux-intro.md b/docs/cs-basics/operating-system/linux-intro.md index 535a9f25e3e..15f2c1f3cf8 100644 --- a/docs/cs-basics/operating-system/linux-intro.md +++ b/docs/cs-basics/operating-system/linux-intro.md @@ -23,7 +23,7 @@ head: - **Linux 本质是指 Linux 内核**:严格来讲,Linux 这个词本身只表示 Linux 内核,单独的 Linux 内核并不能成为一个可以正常工作的操作系统。所以,就有了各种 Linux 发行版。 - **Linux 之父(林纳斯·本纳第克特·托瓦兹 Linus Benedict Torvalds)**:一个编程领域的传奇式人物,真大佬!我辈崇拜敬仰之楷模。他是 **Linux 内核** 的最早作者,随后发起了这个开源项目,担任 Linux 内核的首要架构师。他还发起了 Git 这个开源项目,并为主要的开发者。 -![Linux 之父](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/linux-father.png) +![Linux 创始人 Linus Torvalds](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/linux-father.png) ### Linux 诞生 @@ -33,11 +33,11 @@ head: 1991 年,Linus Torvalds 开源了 Linux 内核。Linux 以一只可爱的企鹅作为标志,象征着敢作敢为、热爱生活。 -![OPINION: Make the switch to a Linux operating system | Opinion ...](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/Linux-Logo.png) +![Linux 操作系统 Logo](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/Linux-Logo.png) ### 常见的 Linux 发行版本 -![Linux 操作系统](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/linux.png) +![Linux 操作系统桌面与命令行界面](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/linux.png) Linus Torvalds 开源的只是 Linux 内核,我们上面也提到了操作系统内核的作用。一些组织或厂商将 Linux 内核与各种软件和文档包装起来,并提供系统安装界面和系统配置、设定与管理工具,就构成了 Linux 的发行版本。 diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md index 7850eef4a2e..cab55ba25d7 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md @@ -40,7 +40,7 @@ head: 下图清晰说明了应用程序、内核、CPU 这三者的关系。 -![Kernel_Layout](https://oss.javaguide.cn/2020-8/Kernel_Layout.png) +![应用程序、内核和 CPU 的关系](https://oss.javaguide.cn/2020-8/Kernel_Layout.png) ### 操作系统主要有哪些功能? @@ -61,7 +61,7 @@ head: _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Windows 用于玩游戏,一台 Mac 用于平时日常开发和学习使用。_ -![windows](./images/windows.png) +![Windows 桌面操作系统界面](./images/windows.png) #### Unix @@ -69,7 +69,7 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 目前这款操作系统已经逐渐逐渐退出操作系统的舞台。 -![unix](./images/unix.png) +![Unix 操作系统标识](./images/unix.png) #### Linux @@ -79,13 +79,13 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win > > **很多人更倾向使用 "GNU/Linux" 一词来表达人们通常所说的 "Linux"。** -![Linux 操作系统](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/linux.png) +![Linux 操作系统桌面与命令行界面](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/linux/linux.png) #### Mac OS 苹果自家的操作系统,编程体验和 Linux 相当,但是界面、软件生态以及用户体验各方面都要比 Linux 操作系统更好。 -![macos](./images/macos.png) +![macOS 桌面操作系统界面](./images/macos.png) ### 用户态和内核态 @@ -131,7 +131,7 @@ _玩玩电脑游戏还是必须要有 Windows 的,所以我现在是一台 Win 也就是说在我们运行的用户程序中,凡是与系统态级别的资源有关的操作(如文件管理、进程控制、内存管理等),都必须通过系统调用方式向操作系统提出服务请求,并由操作系统代为完成。 -![系统调用](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/system-call.png) +![用户程序通过系统调用请求内核服务](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/system-call.png) 这些系统调用按功能大致可分为如下几类: diff --git a/docs/cs-basics/operating-system/shell-intro.md b/docs/cs-basics/operating-system/shell-intro.md index 53485d3aecd..9f6aa7dfa58 100644 --- a/docs/cs-basics/operating-system/shell-intro.md +++ b/docs/cs-basics/operating-system/shell-intro.md @@ -196,7 +196,7 @@ echo $greeting_2 $greeting_3 输出结果: -![输出结果](https://oss.javaguide.cn/github/javaguide/cs-basics/shell/51148933.jpg) +![Shell 字符串拼接命令输出结果](https://oss.javaguide.cn/github/javaguide/cs-basics/shell/51148933.jpg) **获取字符串长度:** From 8ffec91463797f385686c5be3241ceee5553efb3 Mon Sep 17 00:00:00 2001 From: AzurTian Date: Fri, 12 Jun 2026 08:57:01 -0700 Subject: [PATCH 014/116] =?UTF-8?q?fix(docs):=20=E4=BF=AE=E6=AD=A3?= =?UTF-8?q?=E7=B1=BB=E5=8A=A0=E8=BD=BD=E5=99=A8=E6=96=87=E6=A1=A3=E4=B8=AD?= =?UTF-8?q?=E7=9A=84=E9=94=99=E5=88=AB=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修正 classloader 文档中的重复用词。 --- docs/java/jvm/classloader.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/java/jvm/classloader.md b/docs/java/jvm/classloader.md index 8e034414485..cab40ae33b9 100644 --- a/docs/java/jvm/classloader.md +++ b/docs/java/jvm/classloader.md @@ -164,7 +164,7 @@ public class PrintClassLoaderTree { ### 自定义类加载器 -我们前面也说说了,除了 `BootstrapClassLoader` 其他类加载器均由 Java 实现且全部继承自`java.lang.ClassLoader`。如果我们要自定义自己的类加载器,很明显需要继承 `ClassLoader`抽象类。 +我们前面也说了,除了 `BootstrapClassLoader` 其他类加载器均由 Java 实现且全部继承自`java.lang.ClassLoader`。如果我们要自定义自己的类加载器,很明显需要继承 `ClassLoader`抽象类。 `ClassLoader` 类有两个关键的方法: From 8880d573e85e1e5d642ef2fe17e7922a21993414 Mon Sep 17 00:00:00 2001 From: "Takoyaki:)" <177020753+zys3198@users.noreply.github.com> Date: Fri, 12 Jun 2026 23:59:08 +0800 Subject: [PATCH 015/116] =?UTF-8?q?docs(ai-coding):=20=E6=96=B0=E5=A2=9E?= =?UTF-8?q?=20Claude=20Desktop=20+=20CC=20Switch=20=E6=8E=A5=E5=85=A5?= =?UTF-8?q?=E7=AC=AC=E4=B8=89=E6=96=B9=E6=A8=A1=E5=9E=8B=E5=AE=9E=E6=88=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 新增 Claude Desktop 接入第三方模型实战文章,并补充 README 与侧边栏入口。 --- docs/.vuepress/sidebar/ai-coding.ts | 4 + docs/ai-coding/README.md | 1 + .../cases/claude-desktop-cc-switch.md | 347 ++++++++++++++++++ 3 files changed, 352 insertions(+) create mode 100644 docs/ai-coding/cases/claude-desktop-cc-switch.md diff --git a/docs/.vuepress/sidebar/ai-coding.ts b/docs/.vuepress/sidebar/ai-coding.ts index a061bbf94ef..ad7f07973d9 100644 --- a/docs/.vuepress/sidebar/ai-coding.ts +++ b/docs/.vuepress/sidebar/ai-coding.ts @@ -72,6 +72,10 @@ export const aiCoding = arraySidebar([ text: "MiniMax M3 + Claude Code 实战", link: "cases/cc-m3", }, + { + text: "Claude Desktop 接入第三方模型实战", + link: "cases/claude-desktop-cc-switch", + }, { text: "IDEA + CC GUI 插件实战", link: "project/cc-guide", diff --git a/docs/ai-coding/README.md b/docs/ai-coding/README.md index 1a84a00b2a7..a6ab013e35a 100644 --- a/docs/ai-coding/README.md +++ b/docs/ai-coding/README.md @@ -90,6 +90,7 @@ AI 生成的代码,一定要过测试、审查和可回滚的提交管理。 - [Claude Code 接入第三方模型实战](./cases/cc-glm5.1.md):通过 GLM-5.1 做 JVM 智能诊断助手和慢查询治理。 - [DeepSeek V4 + Claude Code 实战](./cases/deepseek-v4-claude-code.md):实测代码审计、Flyway 集成、多模型协同这些更贴近项目的任务。 - [MiniMax M3 + Claude Code 实战](./cases/cc-m3.md):用线上 Redis SCAN 故障排查、SCAN 游标算法跨语言复刻、监控面板搭建三个案例实测 M3。 +- [Claude Desktop 接入第三方模型实战](./cases/claude-desktop-cc-switch.md):用 CC Switch 让 Claude Desktop 接入 DeepSeek,拆解本地代理网关的配置接管、模型映射、协议转换与故障转移原理。 - [IDEA + CC GUI 插件实战](./project/cc-guide.md):想在 IDEA 里用 GUI 管 Claude Code 和 Codex,可以看这个开源插件案例。 ## 高频问题 diff --git a/docs/ai-coding/cases/claude-desktop-cc-switch.md b/docs/ai-coding/cases/claude-desktop-cc-switch.md new file mode 100644 index 00000000000..addc2d5e087 --- /dev/null +++ b/docs/ai-coding/cases/claude-desktop-cc-switch.md @@ -0,0 +1,347 @@ +--- +title: Claude Desktop 接入第三方模型实战:CC Switch 配置与本地代理原理 +description: 通过 CC Switch 让 Claude Desktop 接入 DeepSeek 等第三方模型,拆解本地代理网关的配置接管、模型映射、协议转换与故障转移原理,并提炼可复用到 AI 应用工程实践的设计思路。 +category: AI 编程实战 +head: + - - meta + - name: keywords + content: Claude Desktop,CC Switch,第三方模型,DeepSeek,AI 编程,本地代理网关,模型映射,协议转换,断路器,故障转移,Anthropic Messages API +--- + +你好,我是小 G。前面我们聊过了如何用 [CC Switch 让 Codex 和 Claude Code CLI 接入第三方模型](https://mp.weixin.qq.com/s/We44s9R6ojgewtEwoeUweg),今天我们聊聊如何让 Claude Desktop 也接入第三方模型。 + +这篇文章会从配置实操开始,然后拆解 CC Switch 的本地代理网关设计,最后聊聊 CC Switch 的设计思路怎么用到 AI 应用开发工程实践中。 + +## 安装 CC Switch + +在 [GitHub Releases](https://github.com/farion1231/cc-switch/releases) 下载适合你的电脑系统的安装包。 + +![ccswitch下载页面](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-download-page.png) + +> **说明一下**:本文的 Claude Desktop 配置流程依赖 3P profile 文件写入,而这个机制在 Linux 上不可用(Linux 版 Claude Desktop 不走 3P profile,通过环境变量配置)。Linux 用户可以参考 CC Switch 用户手册中的环境变量配置方式。后续的配置演示以 Windows 为准。 + +装好之后打开,左边栏会看到一排应用图标——Claude Code、Claude Desktop、Codex、Gemini CLI、OpenCode 等。它管了七款 AI 编程工具。这里我们选择 **Claude Desktop**,注意它和 **Claude Code** 是两个不同入口。 + +![ccswitch主页](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-home-page.png) + +## 安装 Claude Desktop + +在 [Claude 官网](https://code.claude.com/docs/zh-CN/desktop) 下载。Claude Desktop 的下载和服务可用性会受地区限制,如果页面提示当前地区不支持,需要换一个可用的网络环境再试。点击下载后,成功则会得到一个 Claude Setup,直接打开即可,后续会自动下载安装。 + +![成功下载](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/download-success.png) + +![claude安装中](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/claude-installing.png) + +如果当前网络环境不可用,会弹出地区不支持的提示。 + +![下载失败页面](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/download-failure-page.png) + +下载并安装完成后,不需要先完成官方账号登录,直接打开 CC Switch 开始配置即可。 + +## 以 DeepSeek 为例:配置全流程 + +### 添加 DeepSeek Provider + +在主页点左边栏的 **Claude Desktop**,然后点右上角的 **+** 按钮添加 Provider。CC Switch 内置了 50 多个 Provider 预设,DeepSeek 也在里面。 + +![ccswitch主页(标注)](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-home-page-annotated.png) + +![配置供应商](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/configure-provider.png) + +选 **DeepSeek** 预设后,填入 API Key 和模型即可。如果上游模型确实支持 1M 上下文,再勾选 **1M**;它的含义是向 Claude Desktop 声明该模型支持 1M 上下文,并不是强制把模型能力变成 1M。endpoint、模型名、认证方式等字段,预设里已经填好了。填完点添加,Provider 卡片出现在列表中。 + +这里重点说一下,“需要模型映射”这个一定要开。DeepSeek 的 endpoint 后缀是 `/anthropic`,说明 DeepSeek 已经实现了 Anthropic Messages API 兼容;但它的真实模型名是 `deepseek-v4-pro`、`deepseek-v4-flash` 这类非 Claude 角色 ID,而 Claude Desktop 只接受 `claude-sonnet-*`、`claude-opus-*`、`claude-haiku-*` 这三类角色路由,所以不能走直连模式,必须走模型映射。 + +如果你的 Provider 不在预设列表里(比如自定义中转站),选“自定义 Provider”手动填入 endpoint、模型列表和 API Key 即可,后面流程一样。 + +### 开启本地路由 + +模型映射模式依赖 CC Switch 在本地 `127.0.0.1:15721` 启动的代理网关。需要先打开这个开关。 + +回到主页面,点击左上角的设置,进入路由设置,打开本地路由,并勾选“在主页面显示本地路由开关”。回到 Claude Desktop 面板后,再打开 Claude Desktop 的本地路由开关。 + +![设置路由](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/routing-settings.png) + +打开后 CC Switch 会做这几件事: + +1. 在 `127.0.0.1:15721` 上启动一个 HTTP 代理服务 +2. 把 Claude Desktop 的 3P profile 里的 endpoint 改写为 `http://127.0.0.1:15721/claude-desktop` +3. 把真实的 API Key 从配置文件中移除,换成占位符 `PROXY_MANAGED` +4. 真实凭据存在自己的 SQLite 数据库里,转发时代入 + +### 切换并重启 + +回到 Provider 卡片,启用 DeepSeek。然后 **完全退出 Claude Desktop 再重新打开**,因为 Claude Desktop 不支持热切换,必须冷重启。 + +重启后,如果你在模型菜单里看到了 DeepSeek V4 Pro 或 DeepSeek V4 Flash,说明生效了。选一个模型,正常发消息就行。 + +![claude进入](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/claude-model-menu.png) + +这里我用到了一个非官方汉化包,因为 Claude Desktop 目前没有中文语言。非官方补丁有兼容性和安全风险,介意的话可以跳过这一步:[Claude Desktop 汉化包](https://yunyingmenghai.feishu.cn/wiki/VBDAwkAjEiXhBXkBX5jcLxXEnwh)。 + +### 常见坑 + +**切完没变化?** + +确认完全退出了 Claude Desktop(macOS 上 `Cmd+Q` 而非点叉,Windows 上检查系统托盘是不是没退出)。 + +**模型列表不显示?** + +检查模型映射表里菜单显示名是否为空、至少一行实际请求模型是否已填。 + +**请求报错?** + +先确认 CC Switch 在后台运行、本地路由开关是开着的。然后检查 API Key 是否正确,endpoint 是否能通。 + +**想切回官方 Claude?** + +在 Provider 列表里找到 Claude Desktop Official 预设,点启用,重启 Claude Desktop 即可恢复登录模式。 + +**配置文件在哪?** + +排查问题时可能有用的路径:CC Switch 数据库在 `~/.cc-switch/cc-switch.db`(SQLite)。Claude Desktop 的 3P profile 相关文件在 macOS 的 `~/Library/Application Support/Claude-3p/` 或 Windows 的 `%LOCALAPPDATA%\Claude-3p\` 下;同时还会涉及 Claude Desktop 原有配置文件,比如 macOS 的 `~/Library/Application Support/Claude/claude_desktop_config.json` 和 Windows 的 `%LOCALAPPDATA%\Claude\claude_desktop_config.json`。 + +## 背后在跑什么:CC Switch 的本地代理网关原理 + +上面走完配置流程,需要注意一件事:模型映射模式要求 CC Switch 一直开着,关了就失效了。 + +这是因为 Claude Desktop 实际连接的地址是 `127.0.0.1:15721`,**是 CC Switch 本地路由服务,不是 DeepSeek 的服务器**。 + +这就是 CC Switch 的核心设计:一个运行在本机的反向代理网关。它做的事分四层:接管配置 → 提供 Claude Desktop 可识别的本地入口 → 请求翻译 → 响应回传。 + +### 架构全景 + +![cc-switch-architecture-arch.drawio](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-architecture-arch.drawio.svg) + +这个网关充当的是本地协议适配层。DeepSeek 和 Claude Desktop 期望的模型路由、参数结构不完全一样,要想稳定通信,就需要在中间做一次转换。启用本地路由后,Claude Desktop 实际连接的是本机的 CC Switch;CC Switch 把请求翻译成上游 Provider 能懂的格式,带上你的 API Key 发过去,再把响应翻译回 Claude Desktop 能处理的格式。 + +明白了 CC Switch 的核心作用,接下来我们逐层拆开来看看到底是怎么回事。 + +### 接管配置 + +CC Switch 工作模式的关键点是**接管**。不开本地路由时,CC Switch 只是个静态配置工具,它把你的 Provider 配置写到 Claude Desktop 的 3P profile 文件里,Claude Desktop 自己去连上游。这个叫**直连模式(Direct Mode)**,配置文件写完后 CC Switch 关掉也不影响使用。 + +可一旦开了本地路由,CC Switch 就进入了**接管模式**。它会做三件事: + +1. **备份配置**:把 Claude Desktop 当前的配置文件存到 SQLite 的 `live_backup` 表里 +2. **注入代理地址**:把 3P profile 里的 endpoint 改成 `http://127.0.0.1:15721/claude-desktop` +3. **移除真实凭据**:把原始 API Key 从文件中拿掉,替换成 `PROXY_MANAGED` 占位符。真实 Key 从 CC Switch 自己的 SQLite 数据库里取 + +![cc-switch-config-takeover-flow.drawio](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-config-takeover-flow.drawio.svg) + +通过本地路由接管之后,Claude Desktop 的所有 API 请求都会先经过 CC Switch 的代理网关。 + +> **说明一下**:接管是可逆的。在 CC Switch 里切回 Claude Desktop 官方模式(也就是从预设列表中选择“Claude Desktop Official”,点启用后重启 Claude Desktop),它会删除 CC Switch 管理的 3P profile,并恢复官方登录模式。 + +CC Switch 设计了一条「最小侵入」原则:接管期间配置文件的备份存在 SQLite 数据库中,可以随时恢复。但需要注意——如果你在接管模式下卸载了 CC Switch,Claude Desktop 的配置文件仍然指向已被删除的本地代理地址 `127.0.0.1:15721`,会导致无法连接。恢复步骤是:重新安装 CC Switch → 切回官方模式 → 重启 Claude Desktop。 + +### 进入第三方推理配置模式 + +Claude Desktop 客户端启动时,如果检测到有效的 3P profile 配置,就会进入第三方推理配置模式,不再要求先走官方账号登录流程。 + +CC Switch 正是利用了这一点。它写入的 3P profile 携带着必要信息:Provider endpoint、认证方式、API Key。Claude Desktop 读到之后,会把这个 profile 作为当前推理服务配置来使用。这也就是为什么前面我说不需要先完成官方账号登录的原因。 + +这个过程不是修改 Claude Desktop 内部认证逻辑,而是使用 Claude Desktop 支持的 3P profile 机制。可以类比企业软件里的 SSO 或托管配置:应用启动时先读取本地托管配置,有可用配置就按配置连接第三方推理服务,没有才回到官方登录流程。 + +### 请求翻译 + +这是整个网关最核心的部分。当一个请求到达 `127.0.0.1:15721`,处理管线是这样的: + +![请求翻译](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-pipeline-flow.drawio.svg) + +**模型映射** + +举个例子,Claude Desktop 发送的请求里,`model` 字段可能是 `claude-sonnet-4-6`。但实际上你用的是 DeepSeek,上游 Provider 并不认识这个 Claude 角色路由。 + +接下来 CC Switch 会在转发前,根据你配的映射表做替换。比如在 CC Switch 里可以把 Sonnet 角色映射到 `deepseek-v4-pro`,把 Haiku 角色映射到 `deepseek-v4-flash`。DeepSeek 官方文档也提供了一套默认思路:`claude-opus*` 映射到 `deepseek-v4-pro`,`claude-sonnet*` / `claude-haiku*` 映射到 `deepseek-v4-flash`。实际怎么配,取决于你想让 Claude Desktop 菜单里的不同角色对应哪个上游模型。 + +这个映射不是简单的字符串替换。Claude Desktop 同时发了三个模型分组(Sonnet / Opus / Haiku),每个分组可能有多个模型 ID 候选,CC Switch 需要匹配正确的角色再替换。具体逻辑是优先精确匹配,没命中再回退到角色组默认。 + +管线中的 **Optimizer(优化器)** 在模型映射之前介入:对支持 prompt caching 的 Provider,自动注入 `cache_control` 头来降低重复请求的成本;同时调整 thinking budget 参数,确保预算在目标模型的有效范围内。但是如果 Provider 不支持缓存或不需要调整,直接跳过。 + +**格式转换** + +如果你的 Provider 原生支持 Anthropic Messages API(比如 DeepSeek 的 `/anthropic` endpoint),格式转换层直接透传,几乎零开销。 + +但如果 Provider 只提供 OpenAI Chat Completions API(比如很多国内的中转站),CC Switch 就需要做完整的协议转换。下面是 Anthropic Messages API 和 OpenAI Chat Completions API 之间的主要映射关系: + +| Anthropic Messages API | OpenAI Chat Completions API | +| ------------------------------------- | ------------------------------------- | +| `model` (string) | `model` (string) | +| `messages[].role: "user"/"assistant"` | `messages[].role: "user"/"assistant"` | +| `system` (string/array) | `messages[].role: "system"` | +| `max_tokens` (required) | `max_tokens` (optional) | +| `stop_sequences` | `stop` | +| `temperature` | `temperature` | +| `top_p` / `top_k` | `top_p` | +| `tools[]` (自定义 schema) | `tools[]` (JSON Schema) | +| `thinking` (extended thinking) | `reasoning_effort` (OpenAI o-series) | + +还有个重点:Thinking 功能的转换。 + +Anthropic 的 extended thinking 允许你指定 `budget_tokens`(思考预算),而 OpenAI 推理模型会使用 `reasoning_effort` / `reasoning.effort` 这类枚举值(不同接口和模型支持范围会有差异,例如 `low` / `medium` / `high` / `xhigh`)。CC Switch 的转换逻辑可以按预算区间映射到不同 effort: + +| Anthropic Thinking 配置 | OpenAI reasoning_effort | +| ----------------------------------- | ----------------------- | +| `thinking.type: "adaptive"` | `xhigh` | +| `thinking.budget_tokens` < 4000 | `low` | +| `thinking.budget_tokens` 4000–15999 | `medium` | +| `thinking.budget_tokens` ≥ 16000 | `high` | + +响应时也是类似的反向映射,从 OpenAI 响应中提取 thinking token 或 reasoning 信息,还原成 Claude Desktop 能处理的格式。做对了用户无感,做错了就可能丢信息。CC Switch 还内置了 **Rectifier(修复器)** 来纠正上游不兼容的参数,比如某些 Provider 会在 thinking 响应中返回无效的 `signature` 字段,直接去掉避免错误。 + +> 除了 Anthropic 和 OpenAI 之间的相互转换,CC Switch 还支持 Gemini Native API 格式的转换。三条转换通道覆盖了市面上绝大多数模型 API。但并不是所有 Provider 都能完美转换——比如一些自建服务的 streaming 实现不全,可能出现 chunk 丢失。这个是协议转换层固有限制,不是 CC Switch 的 bug。 + +### 容错机制 + +CC Switch 支持为一个应用配多个 Provider,并且有自动故障转移。 + +**Provider Router** 维护了一个按优先级排序的 Provider 列表。当请求到达时,它从 P1(最高优先级)开始尝试。如果 P1 失败,自动跳到 P2。 + +**断路器(Circuit Breaker)** 负责判断什么时候该跳过某个 Provider。每个 Provider 独立维护一个断路器实例,有三个状态: + +| 状态 | 含义 | 行为 | +| ------------ | ---------------- | -------------------- | +| Healthy | 正常 | 请求正常通过 | +| Degraded | 部分失败 | 仍可用,但降低优先级 | +| Open(熔断) | 连续失败超过阈值 | 跳过,不尝试 | + +断路器会配置一个触发阈值(默认连续失败 N 次后熔断)。一旦熔断,Router 就不再给这个 Provider 分配请求,直到手动恢复或超时自动重试。 + +这套机制的意义在于:**你不会因为某个模型临时不可用而完全无法工作**。比如你用 DeepSeek 作为主力,同时配一个 OpenAI 兼容的备用 Provider,如果 DeepSeek 挂了,请求自动切到备用,你甚至可能感知不到。 + +### 为什么 Claude Code 支持热切换而 Claude Desktop 不行 + +这里有一个很容易被忽略的设计差异。 + +Claude Code 是 CLI 工具,每次启动时读取配置文件。CC Switch 用接管模式把配置里的 endpoint 指向 `127.0.0.1:15721` 之后,Claude Code 的请求始终发往这个本地地址。你在 CC Switch 里切换 Provider,只改变了代理网关内部的路由表。对 Claude Code 来说,它看到的 endpoint 地址没变。所以 Claude Code 支持热切换,不需要重启。 + +Claude Desktop 也是连到 `127.0.0.1:15721`,但它在启动时会做一次模型列表拉取(调用 `/v1/models`),并缓存模型菜单。切换 Provider 意味着映射表变了,模型名可能也变了,如果不重启 Claude Desktop 就不会重新拉取模型列表,菜单显示的还是旧数据。所以必须冷重启。 + +这其实体现了 CC Switch 的设计取舍:它没有试图去改 Claude Desktop 的内部行为,而是把自己放在 Claude Desktop 能识别的边界内工作。它控制的是 Claude Desktop 能看到的 endpoint 和模型列表,至于 Claude Desktop 怎么缓存、什么时候刷新,那是客户端自己的行为。这样边界清晰,也更容易维护。 + +## 这些设计思路怎么用到 AI 应用开发里 + +拆完 CC Switch 的原理,你会发现有些思路其实可以搬到自己的 AI 应用工程实践中。 + +### 代理网关模式:解耦模型调用与应用逻辑 + +想象一下,你写了半年的 AI 应用,代码里硬编码了 `openai.chat.completions.create(model="gpt-4o")`。某天老板说我们要换 DeepSeek,省钱,你开始改代码。又过两个月,换 Claude 吧,效果好,你又改一遍。 + +你可以借鉴 CC Switch 的做法:**在所有 AI 客户端和上游 API 之间插入一层自己的网关,客户端永远只跟网关对话,网关来决定把请求发给谁**: + +![代理网关模式](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-gateway-pattern-arch.drawio.svg) + +网关负责三件事: + +1. **路由决策**:根据请求上下文(任务类型、优先级、预算)选择合适的模型。简单总结用 Haiku/Flash 级别模型,复杂推理用 Opus/Pro 级别。 +2. **协议适配**:你的应用只说一种 API 格式(比如 Anthropic Messages),网关负责翻译成各 Provider 的原生格式。换模型不需要改应用代码。 +3. **统一鉴权**:所有 API Key 存在网关侧,应用不需要知道任何 Key。权限管控和安全轮换也集中处理。 + +对内部工具或小规模应用来说,一个轻量网关加上 Provider 配置表就能先跑起来: + +```yaml +# 网关的 provider 配置 +providers: + - id: deepseek-v4 + endpoint: https://api.deepseek.com/anthropic + auth: bearer + models: [deepseek-v4-pro, deepseek-v4-flash] + priority: 1 + - id: claude-sonnet + endpoint: https://api.anthropic.com + auth: x-api-key + models: [claude-sonnet-4-6] + priority: 2 +``` + +当你需要加一个新模型时,可以先从新增一条 YAML 配置开始,重启网关后让应用继续访问同一个内部 endpoint。真正上生产时,还要补上配置校验、灰度发布、审计日志和回滚策略。 + +### 配置管理:SSOT + 原子写入 + 双向同步 + +**SSOT(单一数据源)** + +CC Switch 把 Provider 等配置集中存在 SQLite 数据库 `~/.cc-switch/cc-switch.db` 里,再按目标工具写出对应配置。这样可以避免“这个 JSON 文件里一套配置、那个 TOML 文件里又有一套”的状态分叉。查询、备份、恢复和同步,主要盯住这一处数据源即可。 + +你自己的项目也可以看情况用这个思路:不要散落 `config.yaml` + `.env` + 环境变量 + 数据库配置表四套源头。选一个作为 SSOT,其他地方都从这里派生。 + +**原子写入** + +写配置文件时不是直接覆盖,而是先写到临时文件,确认写入成功后再 `rename` 替换原文件: + +```text +写入步骤:原文件 → 临时文件 → rename 覆盖 → 删除临时文件 +``` + +这样可以防止写入过程中进程崩溃或者磁盘满了导致配置文件损坏。配置损坏对 AI 应用来说是隐蔽的灾难——应用可能默默回退到默认配置,但是你完全不知道。 + +**配置同步** + +CC Switch 的管理界面和实际运行配置文件之间需要保持同步:你在界面里改 Provider,要写进 AI 工具的配置文件;如果外部配置被手动改过,管理界面也要能重新读取或至少提示用户重新同步,避免界面状态和运行状态不一致。 + +迁移到自己的应用里时,更稳的做法是:配置变更后发事件通知所有订阅者,而不是依赖定时轮询。比如: + +```text +ConfigStore 变更 → emit("provider:updated") → ProxyRouter 重载路由表 + → UI 刷新 Provider 列表 + → UsageTracker 更新模型定价 +``` + +### 故障转移:不止是换一个 + +很多 AI 应用做故障转移,就是 `try A except call B`。能用,但不够。 + +CC Switch 的断路器思路可以抽象成连续失败计数和自动恢复逻辑。如果你的应用里同时接了多个模型 API,这类模式可以直接借鉴: + +```python +class ModelCircuitBreaker: + def __init__(self, failure_threshold: int = 5): + self.failure_count = 0 + self.failure_threshold = failure_threshold + self.state = "healthy" + + def call(self, provider, request): + if self.state == "open": + raise CircuitOpenError() + try: + result = provider.call(request) + self.failure_count = 0 + return result + except Exception: + self.failure_count += 1 + if self.failure_count >= self.failure_threshold: + self.state = "open" + raise +``` + +熔断之后不要永远不用。加一个半开(Half-Open)状态:等 N 秒后允许一条探测请求通过,成功了就恢复,失败了继续熔断。三条状态的状态机通常是这样的: + +![cc-switch-circuit-breaker-state.drawio](https://oss.javaguide.cn/github/javaguide/ai/claude-desktop/cc-switch-circuit-breaker-state.drawio.svg) + +### 局限:这套方案也有不完美的地方 + +CC Switch 的方案很实用,但有几个固有局限你得知道。 + +**单点故障**。网关跑在本机,如果 CC Switch 进程崩了,所有依赖代理的 AI 工具全部断开——Claude Desktop 连的是 `127.0.0.1:15721`,这个地址没有进程在监听时,请求就是 connection refused。生产环境里你不会把网关和业务应用放在同一个进程,但本机工具类场景下这是合理的取舍。 + +**协议转换有损**。Anthropic Messages API 和 OpenAI Chat Completions API 并不是一一对应的关系。两边的 tool call/content block 结构、流式增量格式、thinking/reasoning 字段和部分扩展参数都不完全一样。转换层只能尽力映射,部分高级特性可能会丢失或降级。 + +**模型能力差异不可见**。网关能帮你切换模型,但不能帮你抹平模型之间的能力差异。不同模型的上下文长度、工具调用稳定性、代码生成风格、推理预算和价格都不同。换了 Provider 之后,你的 prompt 策略、超时、重试和评测集很可能也要跟着调整。这个不是网关层能完全解决的问题。 + +--- + +CC Switch 做了一件说起来简单但做好不容易的事:**在客户端和 API 之间加了一层,让客户端尽量无感地切换模型**。接管配置、模型映射、格式转换、断路器这些设计,不是凭空造出来的,而是对着真实问题一步步补出来的。把它拆开看,做 AI 应用工程时很多基础问题都可以用类似思路解决。 + +## 参考资料 + +- [CC Switch GitHub](https://github.com/farion1231/cc-switch) +- [CC Switch 官方文档 - Claude Desktop Providers](https://www.ccswitch.io/zh/docs?section=providers&item=claude-desktop) +- [CC Switch 用户手册 - Claude Desktop 配置](https://github.com/farion1231/cc-switch/blob/main/docs/user-manual/zh/2-providers/2.6-claude-desktop.md) +- [Anthropic Docs - Cowork on 3P Installation and setup](https://claude.com/docs/cowork/3p/installation) +- [Anthropic Docs - Cowork on 3P Overview](https://claude.com/docs/cowork/3p/overview) +- [DeepSeek API Docs - Integrate with Claude Code](https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code) +- [DeepWiki - CC Switch Proxy Architecture](https://deepwiki.com/farion1231/cc-switch/5-local-proxy-service) +- [DeepWiki - CC Switch Request Processing Pipeline](https://deepwiki.com/farion1231/cc-switch/5.3-request-processing-pipeline) +- [CC Switch Issue #2337: DeepSeek 1M 上下文后缀问题](https://github.com/farion1231/cc-switch/issues/2337) + + From fab4257319cf516fd239b0e7196f0d315b2fff56 Mon Sep 17 00:00:00 2001 From: Guide Date: Sat, 13 Jun 2026 00:04:47 +0800 Subject: [PATCH 016/116] =?UTF-8?q?chore:=20=E7=A7=BB=E9=99=A4=20Docsify?= =?UTF-8?q?=20=E6=97=A7=E5=85=A5=E5=8F=A3=20=E2=80=94=20VuePress=20?= =?UTF-8?q?=E7=AB=99=E7=82=B9=E6=B8=85=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 删除根目录旧 index.html 和 Docsify service worker - 清理 Docsify CDN、插件和离线缓存入口残留 - 已验证 pnpm docs:build 构建通过 --- index.html | 92 ------------------------------------------------------ sw.js | 83 ------------------------------------------------ 2 files changed, 175 deletions(-) delete mode 100755 index.html delete mode 100644 sw.js diff --git a/index.html b/index.html deleted file mode 100755 index 95ccb1581bd..00000000000 --- a/index.html +++ /dev/null @@ -1,92 +0,0 @@ - - - - - JavaGuide - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - diff --git a/sw.js b/sw.js deleted file mode 100644 index 0dbd266dfd9..00000000000 --- a/sw.js +++ /dev/null @@ -1,83 +0,0 @@ -/* =========================================================== - * docsify sw.js - * =========================================================== - * Copyright 2016 @huxpro - * Licensed under Apache 2.0 - * Register service worker. - * ========================================================== */ - -const RUNTIME = 'docsify' -const HOSTNAME_WHITELIST = [ - self.location.hostname, - 'fonts.gstatic.com', - 'fonts.googleapis.com', - 'unpkg.com' -] - -// The Util Function to hack URLs of intercepted requests -const getFixedUrl = (req) => { - var now = Date.now() - var url = new URL(req.url) - - // 1. fixed http URL - // Just keep syncing with location.protocol - // fetch(httpURL) belongs to active mixed content. - // And fetch(httpRequest) is not supported yet. - url.protocol = self.location.protocol - - // 2. add query for caching-busting. - // GitHub Pages served with Cache-Control: max-age=600 - // max-age on mutable content is error-prone, with SW life of bugs can even extend. - // Until cache mode of Fetch API landed, we have to workaround cache-busting with query string. - // Cache-Control-Bug: https://bugs.chromium.org/p/chromium/issues/detail?id=453190 - if (url.hostname === self.location.hostname) { - url.search += (url.search ? '&' : '?') + 'cache-bust=' + now - } - return url.href -} - -/** - * @Lifecycle Activate - * New one activated when old isnt being used. - * - * waitUntil(): activating ====> activated - */ -self.addEventListener('activate', event => { - event.waitUntil(self.clients.claim()) -}) - -/** - * @Functional Fetch - * All network requests are being intercepted here. - * - * void respondWith(Promise r) - */ -self.addEventListener('fetch', event => { - // Skip some of cross-origin requests, like those for Google Analytics. - if (HOSTNAME_WHITELIST.indexOf(new URL(event.request.url).hostname) > -1) { - // Stale-while-revalidate - // similar to HTTP's stale-while-revalidate: https://www.mnot.net/blog/2007/12/12/stale - // Upgrade from Jake's to Surma's: https://gist.github.com/surma/eb441223daaedf880801ad80006389f1 - const cached = caches.match(event.request) - const fixedUrl = getFixedUrl(event.request) - const fetched = fetch(fixedUrl, { cache: 'no-store' }) - const fetchedCopy = fetched.then(resp => resp.clone()) - - // Call respondWith() with whatever we get first. - // If the fetch fails (e.g disconnected), wait for the cache. - // If there’s nothing in cache, wait for the fetch. - // If neither yields a response, return offline pages. - event.respondWith( - Promise.race([fetched.catch(_ => cached), cached]) - .then(resp => resp || fetched) - .catch(_ => { /* eat any errors */ }) - ) - - // Update the cache with the version we fetched (only for ok status) - event.waitUntil( - Promise.all([fetchedCopy, caches.open(RUNTIME)]) - .then(([response, cache]) => response.ok && cache.put(event.request, response)) - .catch(_ => { /* eat any errors */ }) - ) - } -}) \ No newline at end of file From 6de7ca227547b281f525895c5c40ff53febe3b76 Mon Sep 17 00:00:00 2001 From: Guide Date: Sat, 13 Jun 2026 11:49:13 +0800 Subject: [PATCH 017/116] docs: improve data structure navigation --- docs/.vuepress/sidebar/cs-basics.ts | 56 ++++++++++++++++++++----- docs/cs-basics/data-structure/README.md | 46 +++++++++++++++++--- 2 files changed, 86 insertions(+), 16 deletions(-) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index fb4a0315a06..5b59997b5fc 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -161,17 +161,51 @@ export const csBasics = [ icon: ICONS.DATA_STRUCTURE, collapsible: true, children: [ - { text: "线性数据结构", link: "linear-data-structure" }, - { text: "哈希表", link: "hash-table" }, - { text: "树结构", link: "tree" }, - { text: "图", link: "graph" }, - { text: "堆", link: "heap" }, - { text: "Trie 前缀树", link: "trie" }, - { text: "并查集", link: "union-find" }, - { text: "跳表", link: "skip-list" }, - { text: "红黑树", link: "red-black-tree" }, - { text: "布隆过滤器", link: "bloom-filter" }, - { text: "LRU 缓存", link: "lru-cache" }, + { + text: "知识体系", + link: "/cs-basics/data-structure/", + }, + { + text: "基础结构", + collapsible: true, + children: [ + { text: "线性数据结构", link: "linear-data-structure" }, + { text: "⭐️哈希表", link: "hash-table" }, + ], + }, + { + text: "树与堆", + collapsible: true, + children: [ + { text: "⭐️树结构", link: "tree" }, + { text: "⭐️堆", link: "heap" }, + { text: "红黑树", link: "red-black-tree" }, + ], + }, + { + text: "图与集合", + collapsible: true, + children: [ + { text: "图", link: "graph" }, + { text: "⭐️并查集", link: "union-find" }, + ], + }, + { + text: "字符串与有序索引", + collapsible: true, + children: [ + { text: "Trie 前缀树", link: "trie" }, + { text: "跳表", link: "skip-list" }, + ], + }, + { + text: "工程型结构", + collapsible: true, + children: [ + { text: "⭐️布隆过滤器", link: "bloom-filter" }, + { text: "⭐️LRU 缓存", link: "lru-cache" }, + ], + }, ], }, { diff --git a/docs/cs-basics/data-structure/README.md b/docs/cs-basics/data-structure/README.md index 5df241058f1..1f05cdf0fa1 100644 --- a/docs/cs-basics/data-structure/README.md +++ b/docs/cs-basics/data-structure/README.md @@ -1,25 +1,26 @@ --- -title: 数据结构专题:面试复习路线、复杂度、Java 集合与工程场景 -description: 数据结构面试复习路线,涵盖数组、链表、栈、队列、哈希表、树、图、堆、Trie、并查集、跳表、红黑树、布隆过滤器、LRU 和 Java 后端工程场景。 +title: 数据结构知识体系:数组、链表、哈希表、树、图、堆与面试 +description: 数据结构面试复习路线,涵盖数组、链表、栈、队列、哈希表、树、图、堆、Trie、并查集、跳表、红黑树、布隆过滤器、LRU、复杂度分析和 Java 后端工程场景。 category: 计算机基础 tag: - 数据结构 - 算法 - 面试 -sidebar: false sitemap: changefreq: weekly priority: 0.9 head: - - meta - name: keywords - content: 数据结构,数据结构面试题,数组,链表,栈,队列,哈希表,树,图,堆,Trie,并查集,跳表,红黑树,布隆过滤器,LRU,Java集合,后端面试 + content: 数据结构,数据结构面试题,数据结构复习路线,数组,链表,栈,队列,哈希表,HashMap,树,图,堆,Trie,并查集,跳表,红黑树,布隆过滤器,LRU,Java集合,Redis,MySQL索引,后端面试 --- -这份 **数据结构专题** 按面试和 Java 后端场景组织内容:先理解数据怎么存,再看常见操作复杂度,最后把结构和 Java 集合、MySQL 索引、Redis、缓存、消息队列这些工程问题连起来。 +这份 **数据结构知识体系** 按面试和 Java 后端场景组织内容:先理解数据怎么存,再看常见操作复杂度,最后把结构和 Java 集合、MySQL 索引、Redis、缓存、消息队列这些工程问题连起来。 面试里问数据结构,很少只停在“数组是什么”。更常见的是追问:数组和链表为什么一个查询快、一个插入删除方便?`HashMap` 为什么需要扩容?B+ 树为什么适合索引?布隆过滤器为什么会误判?这些问题背后都在考同一件事:你是否理解结构选择带来的复杂度和场景取舍。 +准备数据结构时,不建议只背定义。更有效的方式是把每个结构拆成 4 个问题:怎么存、怎么查、怎么改、适合什么场景。能把这 4 个问题讲清楚,再去刷对应的算法题,效率会高很多。 + ## 适合谁看 - 正在补数据结构基础,准备校招或社招后端面试的同学。 @@ -37,6 +38,24 @@ head: | 工程关联 | HashMap、TreeMap、PriorityQueue、Redis ZSet 用了什么结构? | Java/数据库/缓存中的真实应用 | | 算法承接 | 树遍历、图搜索、Top K、LRU 怎么写? | 和算法模板一起复习 | +## 面试回答框架 + +数据结构题的回答不要只停在“是什么”。面试里更稳的表达方式是按下面这条线展开: + +```text +定义 -> 存储方式 -> 常见操作复杂度 -> 优缺点 -> 适用场景 -> Java/Redis/MySQL 中的应用 +``` + +以哈希表为例,一个完整回答可以这样组织: + +1. 哈希表通过哈希函数把 key 映射到数组下标。 +2. 查询、插入、删除平均是 `O(1)`,但冲突严重时会退化。 +3. 冲突可以用拉链法、开放寻址法等方式处理。 +4. Java `HashMap` 使用数组 + 链表 + 红黑树,扩容用于控制负载因子。 +5. 它适合快速查找、计数、去重、缓存索引等场景,但会消耗额外空间。 + +这种回答比“哈希表查询是 O(1)”更耐追问,因为它同时交代了原理、复杂度和工程落点。 + ## 建议阅读顺序 1. [线性数据结构详解](./linear-data-structure.md):先掌握数组、链表、栈、队列,理解顺序存储和链式存储。 @@ -61,6 +80,23 @@ head: | [跳表面试题总结](./skip-list.md) | 多级索引、范围查询 | Redis ZSet | | [LRU 缓存面试题总结](./lru-cache.md) | 哈希表 + 双向链表 | 本地缓存、页面置换 | +## 结构选型速查 + +很多数据结构问题,实际是在问“这个场景为什么选它,而不是另一个结构”。下面这张表适合面试前快速复盘: + +| 场景 | 优先考虑 | 取舍点 | +| ------------------------- | ------------------- | -------------------------------------------------- | +| 按下标频繁随机访问 | 数组、`ArrayList` | 查询快,插入删除中间元素成本高 | +| 频繁在两端插入删除 | 双端队列、链表 | 指针操作灵活,但随机访问慢 | +| 快速判断元素是否存在 | 哈希表、布隆过滤器 | 哈希表准确但占空间,布隆过滤器省空间但可能误判 | +| 维护有序集合和范围查询 | 红黑树、跳表、B+ 树 | 红黑树适合内存有序集合,跳表适合范围查询和工程实现 | +| 处理最大值、最小值、Top K | 堆、优先队列 | 只关心局部最值,不适合全量有序遍历 | +| 判断连通性和分组 | 并查集 | 合并和查询很快,但不适合频繁删除关系 | +| 前缀匹配、搜索提示 | Trie | 查询与字符串长度相关,但节点数量可能较多 | +| 缓存淘汰 | LRU、LFU | LRU 看最近访问,LFU 看访问频率 | + +复习时可以反过来问自己:如果不用这个结构,会慢在哪里?会多占多少空间?边界条件是什么?这几个问题想清楚,面试追问通常就能接住。 + ## 7 天复习路线 | 天数 | 重点 | 建议动作 | From 2a3a2b7dc0c38271a34a8f80f9adb798a5716b33 Mon Sep 17 00:00:00 2001 From: Guide Date: Sat, 13 Jun 2026 11:53:15 +0800 Subject: [PATCH 018/116] =?UTF-8?q?docs:=20=E6=8E=A5=E5=85=A5=E6=AD=BB?= =?UTF-8?q?=E9=94=81=E8=AF=A6=E8=A7=A3=E6=96=87=E7=AB=A0=20=E2=80=94=20?= =?UTF-8?q?=E6=93=8D=E4=BD=9C=E7=B3=BB=E7=BB=9F=E4=B8=93=E9=A2=98=E5=AF=BC?= =?UTF-8?q?=E8=88=AA=E4=B8=8E=E9=9D=A2=E8=AF=95=E9=A2=98=E8=A1=A5=E5=85=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增死锁详解文章并补齐 SEO 头部信息 - 更新操作系统 sidebar、README 和根 README 导航入口 - 精简并补充操作系统面试题中的死锁说明、配图和详解链接 --- README.md | 1 + docs/.vuepress/sidebar/cs-basics.ts | 1 + docs/cs-basics/operating-system/README.md | 14 +- docs/cs-basics/operating-system/dead-lock.md | 660 ++++++++++++++++++ .../operating-system-basic-questions-01.md | 114 +-- 5 files changed, 694 insertions(+), 96 deletions(-) create mode 100644 docs/cs-basics/operating-system/dead-lock.md diff --git a/README.md b/README.md index 4c3c6fd26d4..ccfea6e556b 100755 --- a/README.md +++ b/README.md @@ -149,6 +149,7 @@ JVM 这部分内容主要参考 [JVM 虚拟机规范-Java8](https://docs.oracle. - [操作系统常见知识点&面试题总结(下)](./docs/cs-basics/operating-system/operating-system-basic-questions-02.md) - [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./docs/cs-basics/operating-system/process-and-thread.md) - [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./docs/cs-basics/operating-system/ipc.md) +- [死锁详解:四个必要条件、Java 死锁排查与数据库死锁处理](./docs/cs-basics/operating-system/dead-lock.md) - [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./docs/cs-basics/operating-system/virtual-memory.md) - [I/O 多路复用详解:select、poll、epoll 原理与区别](./docs/cs-basics/operating-system/io-multiplexing.md) - [零拷贝详解:mmap、sendfile 与 splice](./docs/cs-basics/operating-system/zero-copy.md) diff --git a/docs/.vuepress/sidebar/cs-basics.ts b/docs/.vuepress/sidebar/cs-basics.ts index 5b59997b5fc..7a54df361f0 100644 --- a/docs/.vuepress/sidebar/cs-basics.ts +++ b/docs/.vuepress/sidebar/cs-basics.ts @@ -143,6 +143,7 @@ export const csBasics = [ children: [ { text: "⭐️进程与线程详解", link: "process-and-thread" }, { text: "进程间通信(IPC)详解", link: "ipc" }, + { text: "⭐️死锁详解", link: "dead-lock" }, ], }, { diff --git a/docs/cs-basics/operating-system/README.md b/docs/cs-basics/operating-system/README.md index 208733a380d..d695c7b43d3 100644 --- a/docs/cs-basics/operating-system/README.md +++ b/docs/cs-basics/operating-system/README.md @@ -40,11 +40,12 @@ head: 2. [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续补齐文件系统、I/O、Linux 等问题。 3. [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./process-and-thread.md):系统理解进程、线程、PCB/TCB、fork/exec/wait、线程模型和上下文切换。 4. [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md):对比管道、消息队列、共享内存、信号量、Socket、Binder 等 IPC 方案。 -5. [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):把分页、页表、TLB、缺页中断和页面置换串起来。 -6. [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):理解一个线程处理海量连接背后的内核机制。 -7. [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):搞清传统 I/O、mmap、sendfile、splice 的拷贝路径和适用场景。 -8. [Linux 基础知识总结](./linux-intro.md):掌握目录结构、文件权限、常用命令和基础排障能力。 -9. [Shell 编程基础知识总结](./shell-intro.md):学习变量、条件、循环、函数和常用脚本写法。 +5. [死锁详解:四个必要条件、Java 死锁排查与数据库死锁处理](./dead-lock.md):讲清死锁等待环、四个必要条件、Java 线程死锁排查和数据库事务重试。 +6. [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):把分页、页表、TLB、缺页中断和页面置换串起来。 +7. [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):理解一个线程处理海量连接背后的内核机制。 +8. [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):搞清传统 I/O、mmap、sendfile、splice 的拷贝路径和适用场景。 +9. [Linux 基础知识总结](./linux-intro.md):掌握目录结构、文件权限、常用命令和基础排障能力。 +10. [Shell 编程基础知识总结](./shell-intro.md):学习变量、条件、循环、函数和常用脚本写法。 ## 核心文章 @@ -52,6 +53,7 @@ head: - [操作系统常见面试题总结(下)](./operating-system-basic-questions-02.md):继续整理文件系统、I/O、多路复用、Linux 等知识点。 - [进程与线程详解:区别、状态、通信、上下文切换与虚拟线程](./process-and-thread.md):讲清进程和线程的资源边界、状态转换、Linux 创建机制和 Java 虚拟线程。 - [进程间通信(IPC)详解:管道、消息队列、共享内存、Socket 与 Binder](./ipc.md):讲清常见 IPC 方式的原理、优缺点和选型思路。 +- [死锁详解:四个必要条件、Java 死锁排查与数据库死锁处理](./dead-lock.md):讲清死锁形成条件、资源分配图、Java 排查工具、数据库死锁检测和应用层重试策略。 - [虚拟内存详解:地址转换、TLB、缺页中断与页面置换](./virtual-memory.md):讲清虚拟地址、物理地址、分页、多级页表、TLB、缺页中断和页面置换算法。 - [I/O 多路复用详解:select、poll、epoll 原理与区别](./io-multiplexing.md):讲清网络 I/O 的两个阶段、五种 I/O 模型,以及 select、poll、epoll 的区别。 - [零拷贝详解:mmap、sendfile 与 splice](./zero-copy.md):讲清零拷贝到底省掉了什么,以及 Java NIO、Kafka、RocketMQ 中的典型应用。 @@ -63,7 +65,7 @@ head: - 进程和线程有什么区别?线程之间共享哪些资源? - 进程间通信有哪些方式?各自适合什么场景? - 什么是上下文切换?频繁上下文切换有什么影响? -- 死锁产生的必要条件是什么?如何预防和避免死锁? +- 死锁产生的必要条件是什么?Java 和数据库里如何排查死锁? - 虚拟内存是什么?分页和分段有什么区别? - TLB、缺页中断和页面置换分别解决什么问题? - 页面置换算法有哪些?缺页中断是怎么回事? diff --git a/docs/cs-basics/operating-system/dead-lock.md b/docs/cs-basics/operating-system/dead-lock.md new file mode 100644 index 00000000000..d015f449284 --- /dev/null +++ b/docs/cs-basics/operating-system/dead-lock.md @@ -0,0 +1,660 @@ +--- +title: 死锁详解:四个必要条件、Java 死锁排查与数据库死锁处理 +description: 死锁高频面试题总结,从死锁定义和四个必要条件讲起,结合 Java synchronized、ReentrantLock、ThreadMXBean、jstack、jcmd、JConsole 以及 PostgreSQL、MySQL 数据库死锁排查与事务重试实践。 +category: 计算机基础 +tag: + - 操作系统 + - Java 并发 + - 数据库 +head: + - - meta + - name: keywords + content: 死锁,Deadlock,死锁四个必要条件,Java死锁,线程死锁,synchronized,ReentrantLock,ThreadMXBean,jstack,jcmd,JConsole,数据库死锁,MySQL死锁,PostgreSQL死锁,操作系统面试题,Java并发面试题 +--- + +线程 A 已经拿到了资源 1,线程 B 也拿到了资源 2。接下来,线程 A 想继续往下走,需要资源 2;线程 B 想继续往下走,又需要资源 1。 + +两个线程都没抛异常,也不是 CPU 把机器打满了。线上看到的现象可能只是几个请求一直不返回,线程池里的工作线程慢慢被占住。 + +这类问题麻烦就麻烦在这里:程序没有“算错”,而是卡在一条自己解不开的等待链上。 + +线程死锁说的就是这种情况:一组线程互相等对方释放资源,等待关系绕成闭环,参与其中的线程都没办法靠自己继续执行。 + +如果这些线程正好承载订单、支付、库存这类关键流程,外部看到的就不只是某个线程 `BLOCKED` 了,而是接口超时、队列堆积,甚至进程迟迟退不干净。 + +![死锁场景示意图:线程 A 持有 resource1 并等待 resource2,线程 B 持有 resource2 并等待 resource1,等待链形成闭环](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-deadlock-scenario.png) + +把范围放大一点,死锁不只属于 Java 线程。进程、数据库事务、分布式任务,只要互相占着资源再继续等待,都可能卡成同样的形状。这里的资源也不一定是操作系统教材里的打印机、磁带机,它可以是 Java 对象监视器、`ReentrantLock`、数据库行锁、分布式锁、连接池里的连接、线程池里的工作线程,甚至是管道缓冲区。 + +后面会用 Java 代码演示,是因为这类例子最容易复现。但要记住,死锁不是 Java 专属的问题。只要系统里同时出现独占资源、持有后继续等待、资源不能被强制剥夺、等待关系成环,线程、进程和事务都会踩进去。 + +这篇文章按排查时更常用的顺序来讲:先看等待环怎么形成,再看四个必要条件、Java 复现代码、资源分配图、处理策略,最后落到线上该怎么抓线程栈、怎么看数据库锁。 + +## 死锁是怎么卡住的? + +先看并发编程里最常见的场景。系统里有两个线程和两份资源: + +- 线程 A 先拿到资源 1,再去申请资源 2。 +- 线程 B 先拿到资源 2,再去申请资源 1。 + +如果两个线程刚好交错执行,就会出现下面这个状态: + +- 线程 A 持有资源 1,等待资源 2。 +- 线程 B 持有资源 2,等待资源 1。 + +线程 A 想继续运行,必须等线程 B 释放资源 2;线程 B 想继续运行,又必须等线程 A 释放资源 1。两边都在等对方先动,但谁都没有继续执行到释放资源的机会。 + +所以,死锁和“等得久”不是一回事。普通阻塞还有自然恢复的机会:别的线程释放锁,事务提交,网络 I/O 返回,后面的线程就能继续跑。死锁里多了一个环,环上的每个参与者都在等别人先释放资源。 + +还有一个排查时很容易误判的点:**死锁不一定伴随高 CPU**。很多时候线程只是安静地停在 `BLOCKED` 或 `WAITING`,CPU 反而很低。接口超时、线程池占满、数据库连接耗尽时,CPU 只能作为线索之一,不能当成唯一判断依据。 + +## 死锁的四个必要条件 + +操作系统教材通常会讲 Coffman 条件。死锁要发生,下面 4 个条件必须同时成立: + +| 条件 | 含义 | 对应到 Java 或数据库 | +| ------------------------ | ---------------------------------------- | --------------------------------------------- | +| 互斥 | 某个资源同一时刻只能被一个执行单元占用 | `synchronized` 锁对象、行级排他锁、独占文件锁 | +| 请求与保持(占有并等待) | 已经拿着一部分资源,同时继续等待其他资源 | 线程持有 `resource1` 时继续申请 `resource2` | +| 非抢占 | 资源不能被外部强行拿走,只能由持有者释放 | Java 内置锁不能被另一个线程直接剥夺 | +| 循环等待 | 等待关系形成闭环 | 线程 1 等线程 2,线程 2 又等线程 1 | + +![死锁四个必要条件示意图:互斥、请求与保持、非抢占、循环等待同时成立才会形成死锁](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-four-conditions.png) + +这张表不要当成“满足其中一条就死锁”的清单。它真正表达的是:四项同时出现,死锁才具备发生条件;少掉任意一项,等待环就很难闭合。 + +写业务代码时,最容易下手的是第 2 条和第 4 条。 + +互斥通常绕不开。同一行库存、同一个账户余额、同一段共享内存,本来就不能让多个线程同时乱写。非抢占也不好硬改,锁保护的往往是一段尚未完成的状态,粗暴抢走可能留下半成品。相比之下,让线程一次拿齐资源,或者规定所有入口都按同一顺序拿锁,更容易变成团队能执行的代码规范。 + +## 用 Java 复现一个死锁 + +下面这段代码就是把图 1 写成 Java。两个 `Object` 分别充当资源 1 和资源 2,两个线程按相反顺序进入 `synchronized`。 + +`Thread.sleep(1000)` 不是死锁的原因,它只是把两个线程交错执行的窗口拉大,让问题更容易复现。 + +```java +public class DeadLockDemo { + private static final Object resource1 = new Object(); + private static final Object resource2 = new Object(); + + public static void main(String[] args) { + new Thread(() -> { + synchronized (resource1) { + System.out.println(Thread.currentThread() + "get resource1"); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + System.out.println(Thread.currentThread() + "waiting get resource2"); + synchronized (resource2) { + System.out.println(Thread.currentThread() + "get resource2"); + } + } + }, "线程 1").start(); + + new Thread(() -> { + synchronized (resource2) { + System.out.println(Thread.currentThread() + "get resource2"); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + System.out.println(Thread.currentThread() + "waiting get resource1"); + synchronized (resource1) { + System.out.println(Thread.currentThread() + "get resource1"); + } + } + }, "线程 2").start(); + } +} +``` + +比较典型的一次输出是: + +```text +Thread[线程 1,5,main]get resource1 +Thread[线程 2,5,main]get resource2 +Thread[线程 1,5,main]waiting get resource2 +Thread[线程 2,5,main]waiting get resource1 +``` + +程序到这里就停住了。`sleep()` 早晚会结束,真正卡住的是第二层 `synchronized`:线程 1 进不去 `resource2`,线程 2 进不去 `resource1`。 + +把现场对回前面的四个条件: + +- 互斥:`resource1` 和 `resource2` 同一时间只能被一个线程持有。 +- 请求与保持:线程 1 拿着 `resource1` 等 `resource2`,线程 2 拿着 `resource2` 等 `resource1`。 +- 非抢占:Java 不会强制把 `resource1` 从线程 1 手里拿走。 +- 循环等待:线程 1 等线程 2,线程 2 又等线程 1。 + +四个条件都对上了,剩下的就是调度时序。也正因为触发依赖时序,有些死锁在线上不是每次都能复现,压测跑十次可能只有一两次卡住。 + +**怎么改这段代码才能没有死锁问题?** + +最直接的修法是把加锁顺序固定下来。所有线程都先拿 `resource1`,再拿 `resource2`,等待链就没有机会绕回起点。 + +```java +public class OrderedLockDemo { + private static final Object resource1 = new Object(); + private static final Object resource2 = new Object(); + + public static void main(String[] args) { + Runnable task = () -> { + synchronized (resource1) { + System.out.println(Thread.currentThread() + "get resource1"); + + synchronized (resource2) { + System.out.println(Thread.currentThread() + "get resource2"); + } + } + }; + + new Thread(task, "线程 1").start(); + new Thread(task, "线程 2").start(); + } +} +``` + +这个改法破坏的是“循环等待”。只要所有代码路径都遵守同一个顺序,就不会出现 A 等 B、B 又等 A 的闭环。 + +难点在“所有代码路径”。小例子里只有两个锁,一眼就能看完;业务系统里,锁可能散在订单、库存、支付几个模块里。A 链路先拿订单锁再拿库存锁,B 链路先拿库存锁再拿订单锁,单独看每个方法都像是合理的,组合起来才出问题。 + +实际项目里,我更建议把下面几条写进并发代码的检查清单: + +- 资源要有稳定顺序。可以按业务 ID、数据库主键、账户号这类不会变的值排序,别依赖对象哈希这种不适合表达业务顺序的东西。 +- 锁内只做必要的状态修改。RPC、慢 SQL、文件 I/O 这类操作尽量放到锁外,否则一次慢调用就会把等待链拉长。 +- 拿不齐资源就退出来。已经拿到 A、拿不到 B 时,释放 A 后重试,比拿着 A 一直等 B 更安全。 +- 业务允许失败时,用 `tryLock(timeout, unit)` 给等待加上上限,别让线程无限挂住。 +- 如果两把锁总是一起出现,考虑合成一把更粗的锁。并发度会下降,但换来的是更容易证明的正确性。 + +最后这一条看起来有点“退步”,但工程里经常有用。锁拆得太细不一定更高级;如果几份状态天然强相关,拆开反而会给死锁留出空间。 + +## 资源分配图和等待图 + +操作系统教材里常用资源分配图来画死锁。图里其实就两类东西: + +- 进程或线程节点。 +- 资源节点。 + +箭头也分两种: + +- 从线程指向资源,表示线程正在等待这个资源。 +- 从资源指向线程,表示资源已经分配给这个线程。 + +先看一个最有用的结论:图里没有环,就没有死锁。 + +图里有环时,不能立刻一刀切,还要看资源实例数: + +- 每类资源只有 1 个实例时,有环就代表死锁。 +- 每类资源有多个实例时,有环只说明可能死锁,还要继续判断是否存在某个线程能先完成并释放资源。 + +拿数据库行锁举个例子。事务 T1 已经锁住订单 `id=1`,接着要更新 `id=2`;事务 T2 先锁住了 `id=2`,又回头更新 `id=1`。这时可以把资源节点先拿掉,只看事务之间的等待关系: + +```text +T1 -> T2 +T2 -> T1 +``` + +这种只保留“谁等谁”的图叫等待图(Wait-for Graph),可以看成资源分配图的简化版。Java 线程死锁、数据库死锁检测、Linux lockdep 都会用到类似的图思维,只是使用时机不一样:数据库通常等事务真的阻塞后再检查等待环;lockdep 更像是记录锁获取顺序,提前发现某些顺序组合可能绕成环。 + +![资源分配图与等待图示意图:资源分配图包含线程和资源节点,等待图只保留线程之间的等待关系](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-resource-allocation-graph.png) + +## 预防、避免、检测、恢复 + +讲死锁处理时,经常会看到 4 个词:预防、避免、检测、恢复。名字很像,但它们介入的时间点不同。 + +业务代码里最常见的是预防,比如统一加锁顺序、缩短持锁时间;数据库更习惯检测和恢复,因为事务可以回滚;银行家算法属于“避免”,很适合理解安全状态,但普通后端服务很少真的照着实现一套。 + +| 方法 | 做法 | 代价 | 工程常见程度 | +| ---- | ---------------------------------------------- | -------------------------------- | ------------------------------ | +| 预防 | 破坏死锁四条件之一,让死锁结构上不成立 | 可能降低并发度或增加编码约束 | 很常见 | +| 避免 | 分配资源前判断这次分配会不会把系统推向危险状态 | 需要提前知道资源需求,检查成本高 | 教材常讲,通用系统少见 | +| 检测 | 允许死锁发生,定期或按需检查等待环 | 检测本身有成本 | 数据库、JVM 工具、内核调试常见 | +| 恢复 | 检测到死锁后终止、回滚或抢占资源 | 可能丢弃已完成工作 | 数据库事务里比较自然 | + +![死锁处理策略图:预防、避免、检测、恢复四类方法的作用位置和工程常见程度](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-strategies.png) + +### 死锁预防 + +预防做的事很直接:别让四个必要条件同时凑齐。 + +**破坏互斥**:把资源改成可共享。只读数据、不可变对象、无锁数据结构、追加写日志,都能减少互斥需求。但这条路经常走不通,比如同一行库存扣减、同一个文件写入位置、同一个用户余额,本来就不能让多个执行单元随便同时改。 + +**破坏占有并等待**:要么一次拿齐资源,要么一个都不拿。这样就不会出现“手里攥着 A,又一直等 B”的状态。代价也清楚:资源利用率可能下降,调用方还得提前知道自己到底要哪些资源。 + +**破坏非抢占**:拿不到新资源时,主动释放已经拿到的资源,稍后再试。Java 内置锁不支持超时获取,也不能让别的线程强制撤销;`Lock` 接口提供的 `tryLock()`,可以把“等不到就退出来”写进代码里。 + +```java +boolean gotA = false; +boolean gotB = false; + +try { + gotA = lockA.tryLock(100, TimeUnit.MILLISECONDS); + if (!gotA) { + return; + } + + gotB = lockB.tryLock(100, TimeUnit.MILLISECONDS); + if (!gotB) { + return; + } + + // 同时拿到两把锁后再处理共享状态 + updateSharedState(); +} catch (InterruptedException e) { + Thread.currentThread().interrupt(); + // 不要吞掉中断信号,具体是返回还是抛异常由业务决定。 +} finally { + if (gotB) { + lockB.unlock(); + } + if (gotA) { + lockA.unlock(); + } +} +``` + +这段代码的好处是不会无限等下去。坏处也要看清:它只是把等待变成了失败返回,后面怎么重试、是否允许重试、有没有幂等键,都得由业务自己处理。否则死锁没了,频繁失败或活锁又来了。 + +**破坏循环等待**:给资源排一个稳定顺序,所有线程只能按这个顺序申请。后端业务里最常见的例子是批量更新数据库行时先按主键排序,再逐条更新。 + +### 死锁避免 + +死锁避免不直接拆四个条件,而是在资源分配前先问一句:这次分配出去之后,系统还找不找得到一条“大家都能陆续完成”的顺序? + +教材里最典型的是银行家算法。它要求每个进程提前声明最大资源需求,系统每次准备分配资源前,都要做一次安全性检查: + +- 如果分配后仍然存在一个安全序列,就允许分配。 +- 如果分配后找不到安全序列,就先让申请方等待。 + +安全状态不会走到死锁;不安全状态也不是已经死锁,只是后面可能走进死锁。 + +银行家算法适合用来理解“安全状态”,但普通业务服务很少直接用它。原因并不玄乎:大多数程序很难提前说清最大资源需求,请求顺序也会随业务分支变化;每次分配前都做全局检查,成本还不低。 + +### 死锁检测 + +检测的思路换了一个方向:系统先正常运行,等线程或事务真的互相等住了,再去找等待环。 + +数据库很适合这么做。事务本来就有回滚边界,发现死锁后选一个事务回滚,另一个事务就能继续执行。应用侧要做的是识别这类错误,并决定是否重试整个事务。 + +Java 进程里也能做诊断。JDK 提供了 `ThreadMXBean`: + +```java +import java.lang.management.ManagementFactory; +import java.lang.management.ThreadInfo; +import java.lang.management.ThreadMXBean; + +public class DeadlockDetector { + public static void printDeadlocks() { + ThreadMXBean bean = ManagementFactory.getThreadMXBean(); + long[] threadIds = bean.findDeadlockedThreads(); + + if (threadIds == null || threadIds.length == 0) { + System.out.println("No deadlock found"); + return; + } + + ThreadInfo[] threadInfos = bean.getThreadInfo(threadIds, true, true); + for (ThreadInfo threadInfo : threadInfos) { + System.out.println(threadInfo); + } + } +} +``` + +`findDeadlockedThreads()` 可以检查对象监视器,也能覆盖 `java.util.concurrent` 里的 ownable synchronizer。它更适合放在诊断工具或临时排障脚本里,不适合高频塞进业务主流程;这类检查本身也会有开销。 + +它的边界也要说清楚:它只能看到 JVM 内部可见的 monitor 和 ownable synchronizer。线程 A 拿着 Java 锁去等数据库行锁,线程 B 拿着数据库行锁又卡在另一个应用动作上,这种跨系统等待链,单靠 `ThreadMXBean` 看不完整,还得把线程栈、数据库锁视图和业务日志放在一起对。 + +线上更常见的是直接打线程栈: + +```bash +jcmd Thread.print -l +jstack -l +``` + +如果输出里出现 `Found one Java-level deadlock`、`waiting to lock`、`which is held by`,通常就可以顺着等待链反查到业务代码。这里建议带上 `-l`,因为很多项目里用的是 `ReentrantLock`、`ReentrantReadWriteLock` 这类 JUC 锁;少了 `-l`,ownable synchronizer 的信息可能不完整。 + +本地复现时,JConsole、VisualVM 这类图形化工具也很好用。以 JConsole 为例,先找到 JDK 的 `bin` 目录并打开 `jconsole`。 + +![jconsole](https://oss.javaguide.cn/github/javaguide/java/concurrent/jdk-home-bin-jconsole.png) + +连接目标 Java 进程后,进入“线程”页面,点击“检测死锁”。 + +![jconsole 检测死锁](https://oss.javaguide.cn/github/javaguide/java/concurrent/jconsole-check-deadlock.png) + +如果目标进程里存在 Java 线程死锁,JConsole 会把相关线程单独列出来。 + +![jconsole 检测到死锁](https://oss.javaguide.cn/github/javaguide/java/concurrent/jconsole-check-deadlock-done.png) + +线上环境一般还是优先用 `jcmd`、`jstack`。它们可以通过 SSH 执行,输出也容易留档。JConsole 更适合本地复现、教学演示,或者测试环境里快速看线程状态。生产环境远程连 JConsole 要额外考虑权限、网络暴露和运行开销,很多团队会选择先导出线程栈,再离线分析。 + +如果应用大量使用 Java 21+ 虚拟线程,还要多留一个心眼。虚拟线程不是长期绑定在某个 OS 线程上,传统 `jstack` 或 `Thread.print` 看到的信息可能不如平台线程直观。可以用下面的命令导出虚拟线程 dump: + +```bash +jcmd Thread.dump_to_file -format=text thread-dump.txt +jcmd Thread.dump_to_file -format=json thread-dump.json +``` + +虚拟线程 dump 和传统线程 dump 的字段并不完全一样;对象地址、锁、JNI 统计、堆统计等传统线程 dump 里常见的信息未必都会包含。排查时别只看一份 dump,业务日志、JFR、数据库和外部依赖状态都要一起看。 + +### 死锁恢复 + +恢复比检测更棘手,因为系统得决定“牺牲谁”。 + +常见手段有 3 类: + +- 终止所有参与死锁的执行单元。 +- 一次终止一个,检测死锁是否解除。 +- 抢占某些资源,回滚到可继续执行的状态。 + +数据库事务适合恢复,因为事务边界清楚,回滚以后可以重新执行。普通 Java 线程就麻烦得多:一个线程持锁时可能已经改了一半内存状态、写了一半文件、发了一半远程请求,直接杀掉通常不可取。Java 早就不推荐使用 `Thread.stop()`,也是这个原因。 + +应用代码更应该做的是避免把自己写进绝路:一旦卡住,只能靠杀进程恢复。 + +## 数据库里的死锁 + +死锁在数据库里很常见,尤其是多事务更新多行数据时。 + +假设有一张订单表: + +```sql +CREATE TABLE orders ( + id BIGINT PRIMARY KEY, + status VARCHAR(32) NOT NULL +); +``` + +两个事务这样执行: + +```sql +-- 事务 T1 +BEGIN; +UPDATE orders SET status = 'PAID' WHERE id = 1; +UPDATE orders SET status = 'PAID' WHERE id = 2; +COMMIT; +``` + +```sql +-- 事务 T2 +BEGIN; +UPDATE orders SET status = 'CANCELLED' WHERE id = 2; +UPDATE orders SET status = 'CANCELLED' WHERE id = 1; +COMMIT; +``` + +如果 T1 先锁住 `id=1`,T2 先锁住 `id=2`,后面就会互相等待。 + +数据库一般不会让这两个事务一直挂着。PostgreSQL 有 `deadlock_timeout` 参数,默认是 `1s`;事务等锁超过这个时间后,数据库才开始检查死锁,因为构造和扫描等待图也要成本。MySQL InnoDB 默认开启死锁检测,发现等待环后会回滚一个事务来解开局面,通常倾向选择修改行数更少的事务。 + +应用层要配合两件事。 + +第一,事务失败后要能重跑。PostgreSQL 的死锁错误码是 SQLSTATE `40P01`;MySQL InnoDB 遇到死锁时会回滚整个事务。应用收到这类错误后,应该重新执行整个事务,而不是只补最后一条 SQL。 + +第二,加锁顺序要稳定。批量更新多行时,先按主键或唯一业务键排序,所有入口都按同一个顺序更新。这个习惯很普通,但能减少大量交叉等待。 + +重试前还要确认业务具备幂等能力。比较常见的做法是使用唯一请求号、业务流水号或状态机校验。否则数据库已经把死锁处理掉了,应用层却可能因为重试引入重复扣款、重复发货。 + +减少和排查数据库死锁时,可以先看这几类信息: + +- 事务尽量短,别在事务里等用户输入、调用慢接口、处理大文件。 +- 索引要正确,否则更新一行可能扫描并锁住更多记录。 +- 少用不必要的 `SELECT ... FOR UPDATE`。 +- MySQL 可以用 `SHOW ENGINE INNODB STATUS` 看最近一次 InnoDB 死锁信息;如果死锁很频繁,可以考虑开启 `innodb_print_all_deadlocks` 把所有死锁信息写入错误日志。 +- PostgreSQL 可以结合错误日志、`pg_locks`、`pg_stat_activity` 查阻塞关系。 + +PostgreSQL 里可以先用下面这个查询看当前哪些会话正在等锁,以及它们被哪些 pid 阻塞: + +```sql +SELECT + a.pid, + a.usename, + a.state, + a.wait_event_type, + a.wait_event, + pg_blocking_pids(a.pid) AS blocking_pids, + a.query +FROM pg_stat_activity a +WHERE a.wait_event_type = 'Lock'; +``` + +这条 SQL 只能看当前等待关系。分析一次已经发生的死锁,还要回到数据库错误日志里的死锁详情,找到应用日志里的 traceId/requestId,再还原两个事务各自执行 SQL 的顺序。 + +数据库死锁不是“数据库坏了”。更多时候,它是在提醒你:应用层访问同一批资源的顺序不够稳定。 + +## 死锁、饥饿和活锁有什么区别? + +这几个概念都会表现成“程序没按预期往前走”,但现场差别很大。 + +| 问题 | 表现 | 典型原因 | +| ---- | ---------------------------------------------- | ------------------------------ | +| 死锁 | 多个执行单元互相等待,形成闭环 | 反向加锁、事务交叉更新 | +| 饥饿 | 某个执行单元长期拿不到资源,但系统整体仍在推进 | 优先级过低、非公平锁竞争 | +| 活锁 | 执行单元一直在动作,但总是互相让路,没人完成 | 失败后同时重试、退避策略太同步 | + +![死锁、饥饿和活锁对比图:死锁表现为等待环,饥饿表现为长期拿不到资源,活锁表现为持续动作但没有进展](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-deadlock-vs-starvation-livelock.png) + +可以用三个画面记:死锁像两辆车在窄桥中间顶住,谁都不倒车;饥饿像队伍里一直有人插队,队尾那个人始终轮不到;活锁像两个人迎面走来,每次都同时往同一边让,结果一直错不开。 + +排查时别只看“卡住”这一个现象。死锁要找等待环,饥饿要看调度或锁竞争是否长期偏向,活锁要看重试逻辑是不是把所有参与者绑在同一个节奏上。 + +## 哪些卡住不一定是死锁? + +线上有不少“卡住”看起来像死锁,最后查下来并没有等待环。常见的有这些: + +- **线程池耗尽**:所有工作线程都在跑慢任务,新请求只能排队。 +- **连接池耗尽**:线程都在等数据库连接,但没有形成互相等待的闭环。 +- **慢 SQL**:线程停在 JDBC 调用里,数据库还在执行。 +- **外部服务超时**:线程卡在 HTTP/RPC 调用上,等待对方响应。 +- **GC 或 safepoint 停顿**:所有 Java 线程短时间暂停。 +- **饥饿**:某些线程长期抢不到资源,但系统整体仍在推进。 + +判断死锁,关键证据不是“慢”或“卡”,而是能不能找到稳定的等待环。 + +## 线上怎么排查 Java 死锁? + +如果线上接口卡住,先别急着重启。只要进程还活着,就尽量先留下线程栈和现场指标。 + +### 1. 先确认是不是“全挂” + +先看现象是不是集中在“线程不释放资源”上: + +- 某些接口一直超时,但进程还活着。 +- CPU 不高,线程数、连接数、请求队列持续堆积。 +- 线程池活跃线程长期占满,队列不下降。 +- 数据库连接池连接被占住不释放。 + +这些现象只能说明服务在等,不足以证明死锁。慢 SQL、外部依赖卡住、线程池配置不合理,也会制造类似现场。 + +### 2. 连续抓 2 到 3 次线程栈 + +线程栈建议连续抓几次,间隔 10 到 30 秒。只抓一次,很容易把瞬时阻塞误判成死锁: + +```bash +jcmd Thread.print -l > thread-1.log +sleep 10 +jcmd Thread.print -l > thread-2.log +sleep 10 +jcmd Thread.print -l > thread-3.log +``` + +多次栈的价值在于对比。如果三次都停在同一把锁、同一个连接池、同一段业务代码上,判断会比单次栈可靠得多。 + +Java 能识别的线程死锁,线程栈通常会直接打印死锁信息。没有直接打印时,也可以观察大量线程是不是长期停在同一批锁、同一个连接池获取逻辑或同一段业务方法上。 + +### 3. 顺着 `waiting to lock` 找持有者 + +读线程栈时,先抓这几类信息: + +- 线程名和线程状态,例如 `BLOCKED`、`WAITING`。 +- 正在等待的锁对象。 +- 当前已经持有的锁。 +- 栈顶业务方法。 +- `parking to wait for` 对应的 `Lock` 或条件队列。 + +如果能看到 A 等 B 持有的锁,B 又等 A 持有的锁,等待环基本就浮出来了。 + +`synchronized` 相关死锁通常会看到 `waiting to lock <...>` 和 `locked <...>`;`ReentrantLock` 这类 JUC 锁通常会看到 `parking to wait for <...>`,并且需要关注 `Locked ownable synchronizers`。因此抓栈时建议带上 `-l`。 + +### 4. 回到代码看锁顺序 + +定位到栈里的业务方法后,再回代码里查这些点: + +- 是否存在多个入口反向获取同一组锁。 +- 是否在持锁期间调用外部服务或数据库。 +- 是否锁住了范围过大的对象,例如全局 `Map`、单例对象、`Class` 对象。 +- 是否混用了 Java 锁和数据库事务锁,导致链路更长。 +- 是否用了非公平锁、无限等待、无超时获取。 + +很多死锁不是某一行代码单独造成的,而是两个调用链组合以后才出现。单看 A 链路、B 链路都说得过去,放在一起才绕成环。 + +## 写代码时怎么减少死锁? + +下面几条更像代码评审时的检查项,尤其适合多锁、多事务、多资源更新的场景。 + +### 固定加锁顺序 + +同时操作多个用户、订单或账户时,先排序再加锁。下面这个转账例子假设账户 ID 全局唯一,并且创建后不再变化。 + +```java +public void transfer(Account from, Account to, long amount) { + if (from == to) { + return; + } + + Account first; + Account second; + int compare = Long.compare(from.id(), to.id()); + if (compare < 0) { + first = from; + second = to; + } else if (compare > 0) { + first = to; + second = from; + } else { + throw new IllegalStateException("Account id must be unique"); + } + + synchronized (first) { + synchronized (second) { + from.withdraw(amount); + to.deposit(amount); + } + } +} +``` + +这个例子里,不管是 A 给 B 转账,还是 B 给 A 转账,都会先锁 ID 小的账户,再锁 ID 大的账户。顺序固定后,循环等待就少了一条边。 + +### 避免持锁做慢操作 + +持锁期间尽量别做下面这些事: + +- RPC 或 HTTP 请求。 +- 慢 SQL 或大事务。 +- 文件上传下载。 +- 等待消息队列返回。 +- 调用不清楚内部会不会加锁的第三方代码。 + +锁应该保护共享状态,而不是把整段业务流程都包进去。能提前算好的数据放在锁外算,锁内只留下最短的状态切换。 + +### 使用超时和失败策略 + +内置锁 `synchronized` 没有超时获取能力。业务允许失败或重试时,可以考虑 `ReentrantLock.tryLock()`: + +```java +try { + if (!lock.tryLock(200, TimeUnit.MILLISECONDS)) { + throw new IllegalStateException("系统繁忙,请稍后重试"); + } + + try { + updateSharedState(); + } finally { + lock.unlock(); + } +} catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IllegalStateException("获取锁时被中断", e); +} +``` + +超时只能限制等待时间,不能自动保证业务正确。拿不到锁以后要不要重试、最多重试几次、会不会重复提交、是否需要幂等键,这些问题都要提前设计好。否则,超时只是让错误更快暴露出来。 + +### 少混用多套锁体系 + +比较难排的是跨层死锁,比如: + +- Java 线程持有 JVM 锁,同时等待数据库行锁。 +- 另一个请求持有数据库行锁,回调到应用逻辑里等待 JVM 锁。 + +这种等待链会同时出现在 JVM 线程栈和数据库日志里,单看一边都不完整。能把锁控制在同一层,就别让等待关系穿透太多组件;必须跨层时,至少要有超时、日志和统一顺序。 + +### 给锁命名,给线程命名 + +线上排查时,最怕看到的就是“Thread-17 等待 Object@4afcd809”这种信息。线程池自定义线程名、锁对象绑定业务 ID、日志里打印关键资源顺序,平时多写几行,出问题时能省很多时间。 + +比如线程名里带上业务池: + +```java +private static final AtomicInteger THREAD_INDEX = new AtomicInteger(); + +ThreadFactory factory = runnable -> { + Thread thread = new Thread(runnable); + thread.setName("order-worker-" + THREAD_INDEX.incrementAndGet()); + return thread; +}; +``` + +`AtomicInteger` 来自 `java.util.concurrent.atomic`。自己编号比直接依赖线程 ID 更稳,也兼容 Java 8/11 这类仍然很常见的运行环境。 + +命名本身不能防死锁,但能让你更快知道是哪一类业务线程卡住了。 + +## 面试怎么回答死锁? + +面试里问死锁,不用一上来背很长的定义。可以先用一个两锁互等的例子把场景讲清楚: + +> 死锁是多个线程或进程互相等待对方释放资源,导致所有参与者都无法继续执行的状态。典型例子是线程 A 拿着锁 1 等锁 2,线程 B 拿着锁 2 等锁 1。 + +然后补四个必要条件: + +> 死锁要同时满足互斥、占有并等待、非抢占、循环等待这 4 个条件。只要能破坏其中一个条件,就可以从结构上避免死锁。 + +再说处理方法: + +> 工程里最常用的是预防,比如统一加锁顺序、缩小锁范围、一次申请完整资源、使用超时锁。操作系统教材还会讲银行家算法,它属于死锁避免,需要提前知道最大资源需求。数据库一般采用检测和恢复,发现等待环后回滚一个事务,应用层再重试。 + +如果继续追问 Java 排查: + +> Java 可以用 `jcmd Thread.print -l` 或 `jstack -l ` 打线程栈,也可以用 `ThreadMXBean.findDeadlockedThreads()` 在程序里做诊断。排查时看线程状态、正在等待的锁、已经持有的锁,再回到代码里确认是否存在反向加锁或持锁慢操作。 + +这样答能覆盖概念、条件、方案和排查,比只背四个条件更完整。 + +## 总结 + +死锁最该记住的不是术语,而是等待关系。 + +只要代码里存在“已经持有一部分资源,又继续等待另一部分资源”的路径,就要多问一句:这些等待关系有没有可能绕成环?如果有,要么固定顺序,要么缩短持有时间,要么允许超时撤退,要么交给数据库事务这类能检测、能回滚的系统处理。 + +有些地方没法保证永远不死锁,比如复杂数据库事务、高并发批量更新、跨服务资源编排。更现实的目标是把概率降下来,把现场留住,把失败做成可以安全重试,而不是一路拖到只能重启进程。 + +## 参考资料 + +- [JavaGuide:操作系统常见面试题总结(上)](https://github.com/Snailclimb/JavaGuide) +- [用个通俗的例子讲一讲死锁 - 知乎专栏](https://zhuanlan.zhihu.com/p/26945588) +- [Yale CS:Deadlock](https://www.cs.yale.edu/homes/aspnes/pinewiki/Deadlock.html) +- [University of Wisconsin CS 537 Notes:Deadlock](https://pages.cs.wisc.edu/~bart/537/lecturenotes/s12.html) +- [Oracle Java Tutorials:Deadlock](https://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html) +- [Oracle JDK API:ReentrantLock](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/locks/ReentrantLock.html) +- [Oracle JDK API:ThreadMXBean](https://docs.oracle.com/javase/8/docs/api/java/lang/management/ThreadMXBean.html) +- [Oracle Troubleshooting Guide:The jstack Utility](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr016.html) +- [Oracle Java Documentation:Virtual Threads](https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html) +- [Linux Kernel Documentation:Runtime locking correctness validator](https://docs.kernel.org/locking/lockdep-design.html) +- [PostgreSQL Documentation:Lock Management](https://www.postgresql.org/docs/current/runtime-config-locks.html) +- [PostgreSQL Documentation:Error Codes](https://www.postgresql.org/docs/current/errcodes-appendix.html) +- [PostgreSQL Documentation:pg_locks](https://www.postgresql.org/docs/current/view-pg-locks.html) +- [MySQL 8.4 Reference Manual:Deadlock Detection](https://dev.mysql.com/doc/refman/8.4/en/innodb-deadlock-detection.html) +- [MySQL 8.4 Reference Manual:InnoDB Error Handling](https://dev.mysql.com/doc/refman/8.4/en/innodb-error-handling.html) diff --git a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md index cab55ba25d7..c1588960612 100644 --- a/docs/cs-basics/operating-system/operating-system-basic-questions-01.md +++ b/docs/cs-basics/operating-system/operating-system-basic-questions-01.md @@ -355,16 +355,20 @@ Shell 启动外部命令时,常见链路就是:Shell 先 `fork()` 出子进 ### 什么是死锁? -死锁(Deadlock)描述的是这样一种情况:多个进程/线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放。由于进程/线程被无限期地阻塞,因此程序不可能正常终止。 +死锁(Deadlock)描述的是这样一种情况:一组进程/线程互相等待对方释放资源或完成动作,等待关系形成闭环,导致所有参与者都无法自行继续执行。 -一个最经典的例子就是**“交叉持锁”**。想象有两个线程和两个锁: +更具体地说,死锁不是“等得久”这么简单。普通阻塞可能等锁释放、I/O 返回或事务提交后继续执行;死锁里的等待链绕成了环,如果没有外力介入,这个环不会自然解开。 + +关于死锁的形成过程、Java 线程死锁排查和数据库死锁处理,可以看这篇更完整的专题:[死锁详解:四个必要条件、Java 死锁排查与数据库死锁处理](./dead-lock.md)。 + +一个最经典的例子就是 **“交叉持锁”** 。想象有两个线程和两个锁: - 线程 1 先拿到了锁 A,然后尝试去获取锁 B。 - 几乎同时,线程 2 拿到了锁 B,然后尝试去获取锁 A。 -这时,线程 1 等着线程 2 释放锁 B,而线程 2 等着线程 1 释放锁 A,双方都持有对方需要的资源,并等待对方释放,就形成了一个“死结”。 +这时,线程 1 等着线程 2 释放锁 B,线程 2 等着线程 1 释放锁 A,双方都持有对方需要的资源,并等待对方释放,就形成了一个等待环。 -![死锁展示](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/deadlock-conditions-robots.png) +![死锁场景示意图:线程 A 持有 resource1 并等待 resource2,线程 B 持有 resource2 并等待 resource1,等待链形成闭环](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-deadlock-scenario.png) ### 产生死锁的四个必要条件是什么? @@ -373,24 +377,20 @@ Shell 启动外部命令时,常见链路就是:Shell 先 `fork()` 出子进 1. **互斥**:资源必须处于非共享模式,即一次只有一个进程可以使用。如果另一进程申请该资源,那么必须等待直到该资源被释放为止。 2. **占有并等待**:一个进程至少应该占有一个资源,并等待另一资源,而该资源被其他进程所占有。 3. **非抢占**:资源不能被抢占。只能在持有资源的进程完成任务后,该资源才会被释放。 -4. **循环等待**:有一组等待进程 {P0, P1, ..., Pn},P0 等待的资源被 P1 占有,P1 等待的资源被 P2 占有,...,Pn-1 等待的资源被 Pn 占有,Pn 等待的资源被 P0 占有。 - -**注意**:这四个条件是产生死锁的 **必要条件**,也就是说只要系统发生死锁,这些条件必然成立,而只要上述条件之一不满足,就不会发生死锁。 +4. **循环等待**:有一组等待进程 `{P0, P1, ..., Pn}`,`P0` 等待的资源被 `P1` 占有,`P1` 等待的资源被 `P2` 占有,...,`Pn-1` 等待的资源被 `Pn` 占有,`Pn` 等待的资源又被 `P0` 占有。 -下面是百度百科对必要条件的解释: +![死锁四个必要条件示意图:互斥、请求与保持、非抢占、循环等待同时成立才会形成死锁](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-four-conditions.png) -> 如果没有事物情况 A,则必然没有事物情况 B,也就是说如果有事物情况 B 则一定有事物情况 A,那么 A 就是 B 的必要条件。从逻辑学上看,B 能推导出 A,A 就是 B 的必要条件,等价于 B 是 A 的充分条件。 +**注意**:这四个条件是产生死锁的必要条件,必须同时成立。只满足其中一两个条件不一定会死锁;反过来,只要能稳定破坏其中任意一个条件,就可以从结构上预防死锁。 ### 能写一个模拟产生死锁的代码吗? -下面通过一个实际的例子来模拟下图展示的线程死锁: - -![线程死锁示意图](https://oss.javaguide.cn/github/javaguide/java/2019-4%E6%AD%BB%E9%94%811-20230814005444749.png) +下面通过一个实际的例子来复现上面的交叉持锁场景: ```java public class DeadLockDemo { - private static Object resource1 = new Object();//资源 1 - private static Object resource2 = new Object();//资源 2 + private static final Object resource1 = new Object(); // 资源 1 + private static final Object resource2 = new Object(); // 资源 2 public static void main(String[] args) { new Thread(() -> { @@ -399,7 +399,7 @@ public class DeadLockDemo { try { Thread.sleep(1000); } catch (InterruptedException e) { - e.printStackTrace(); + Thread.currentThread().interrupt(); } System.out.println(Thread.currentThread() + "waiting get resource2"); synchronized (resource2) { @@ -414,7 +414,7 @@ public class DeadLockDemo { try { Thread.sleep(1000); } catch (InterruptedException e) { - e.printStackTrace(); + Thread.currentThread().interrupt(); } System.out.println(Thread.currentThread() + "waiting get resource1"); synchronized (resource1) { @@ -435,86 +435,20 @@ Thread[线程 1,5,main]waiting get resource2 Thread[线程 2,5,main]waiting get resource1 ``` -线程 A 通过 `synchronized (resource1)` 获得 `resource1` 的监视器锁,然后通过 `Thread.sleep(1000);` 让线程 A 休眠 1s 为的是让线程 B 得到执行然后获取到 `resource2` 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源,然后这两个线程就会陷入互相等待的状态,这也就产生了死锁。 +线程 1 通过 `synchronized (resource1)` 获得 `resource1` 的监视器锁,线程 2 通过 `synchronized (resource2)` 获得 `resource2` 的监视器锁。`Thread.sleep(1000)` 不是死锁的原因,它只是把两个线程交错执行的窗口拉大,让死锁更容易复现。休眠结束后,两个线程都开始申请对方持有的资源,于是陷入互相等待。 ### 解决死锁的方法 -解决死锁的方法可以从多个角度去分析,一般的情况下,有**预防、避免、检测和解除四种**。 - -- **死锁预防**:这是我们程序员最常用的方法。通过编码规范来破坏条件。最经典的就是**破坏循环等待**,比如规定所有线程都必须**按相同的顺序**来获取锁(比如先 A 后 B),这样就不会形成环路。 -- **死锁避免**:这是一种更动态的方法,比如操作系统的**银行家算法**。它会在分配资源前进行预测,如果这次分配可能导致未来发生死锁,就拒绝分配。但这种方法开销很大,在通用系统中用得比较少。 -- **死锁检测与解除**:这是一种“事后补救”的策略,就像乐观锁。系统允许死锁发生,但会有一个后台线程(或机制)定期检测是否存在死锁环路(比如通过分析线程等待图)。一旦发现,就会采取措施解除,比如**强制剥夺某个线程的资源或直接终止它**。数据库系统中的死锁处理就常常采用这种方式。 - -#### 死锁的预防 - -死锁四大必要条件上面都已经列出来了,很显然,只要破坏四个必要条件中的任何一个都能够预防死锁的发生。 - -破坏第一个条件 **互斥条件**:使得资源是可以同时访问的,这是种简单的方法,磁盘就可以用这种方法管理,但是我们要知道,有很多资源 **往往是不能同时访问的**,所以这种做法在大多数的场合是行不通的。 - -破坏第三个条件 **非抢占**:也就是说可以采用 **剥夺式调度算法**,但剥夺式调度方法目前一般仅适用于 **主存资源** 和 **处理器资源** 的分配,并不适用于所有的资源,会导致 **资源利用率下降**。 - -所以一般比较实用的 **预防死锁的方法**,是通过考虑破坏第二个条件和第四个条件。 - -**1、静态分配策略** - -静态分配策略可以破坏死锁产生的第二个条件(占有并等待)。所谓静态分配策略,就是指一个进程必须在执行前就申请到它所需要的全部资源,并且知道它所要的资源都得到满足之后才开始执行。进程要么占有所有的资源然后开始执行,要么不占有资源,不会出现占有一些资源等待一些资源的情况。 - -静态分配策略逻辑简单,实现也很容易,但这种策略 **严重地降低了资源利用率**,因为在每个进程所占有的资源中,有些资源是在比较靠后的执行时间里采用的,甚至有些资源是在额外的情况下才使用的,这样就可能造成一个进程占有了一些 **几乎不用的资源而使其他需要该资源的进程产生等待** 的情况。 - -**2、层次分配策略** - -层次分配策略破坏了产生死锁的第四个条件(循环等待)。在层次分配策略下,所有的资源被分成了多个层次,一个进程得到某一次的一个资源后,它只能再申请较高一层的资源;当一个进程要释放某层的一个资源时,必须先释放所占用的较高层的资源,按这种策略,是不可能出现循环等待链的,因为那样的话,就出现了已经申请了较高层的资源,反而去申请了较低层的资源,不符合层次分配策略,证明略。 - -#### 死锁的避免 - -上面提到的 **破坏** 死锁产生的四个必要条件之一就可以成功 **预防系统发生死锁**,但是会导致 **低效的进程运行** 和 **资源使用率**。而死锁的避免相反,它的角度是允许系统中**同时存在四个必要条件**,只要掌握并发进程中与每个进程有关的资源动态申请情况,做出 **明智和合理的选择**,仍然可以避免死锁,因为四大条件仅仅是产生死锁的必要条件。 - -我们将系统的状态分为 **安全状态** 和 **不安全状态**,每当在为申请者分配资源前先测试系统状态,若把系统资源分配给申请者会产生死锁,则拒绝分配,否则接受申请,并为它分配资源。 - -> 如果操作系统能够保证所有的进程在有限的时间内得到需要的全部资源,则称系统处于安全状态,否则说系统是不安全的。很显然,系统处于安全状态则不会发生死锁,系统若处于不安全状态则可能发生死锁。 - -那么如何保证系统保持在安全状态呢?通过算法,其中最具有代表性的 **避免死锁算法** 就是 Dijkstra 的银行家算法,银行家算法用一句话表达就是:当一个进程申请使用资源的时候,**银行家算法** 通过先 **试探** 分配给该进程资源,然后通过 **安全性算法** 判断分配后系统是否处于安全状态,若不安全则试探分配作废,让该进程继续等待,若能够进入到安全的状态,则就 **真的分配资源给该进程**。 - -银行家算法详情可见:[《一句话+一张图说清楚——银行家算法》](https://blog.csdn.net/qq_33414271/article/details/80245715)。 - -操作系统教程书中讲述的银行家算法也比较清晰,可以一看。 - -死锁的避免(银行家算法)改善了 **资源使用率低的问题**,但是它要不断地检测每个进程对各类资源的占用和申请情况,以及做 **安全性检查**,需要花费较多的时间。 - -#### 死锁的检测 - -对资源的分配加以限制可以 **预防和避免** 死锁的发生,但是都不利于各进程对系统资源的**充分共享**。解决死锁问题的另一条途径是 **死锁检测和解除**(这里突然联想到了乐观锁和悲观锁,感觉死锁的检测和解除就像是 **乐观锁**,分配资源时不去提前管会不会发生死锁了,等到真的死锁出现了再来解决嘛,而 **死锁的预防和避免** 更像是悲观锁,总是觉得死锁会出现,所以在分配资源的时候就很谨慎)。 - -这种方法对资源的分配不加以任何限制,也不采取死锁避免措施,但系统 **定时地运行一个“死锁检测”** 的程序,判断系统内是否出现死锁,如果检测到系统发生了死锁,再采取措施去解除它。 - -##### 进程-资源分配图 - -操作系统中的每一刻时刻的**系统状态**都可以用**进程-资源分配图**来表示,进程-资源分配图是描述进程和资源申请及分配关系的一种有向图,可用于**检测系统是否处于死锁状态**。 - -用一个方框表示每一个资源类,方框中的黑点表示该资源类中的各个资源,用一个圆圈表示每一个进程,用 **有向边** 来表示**进程申请资源和资源被分配的情况**。 - -图中 2-21 是**进程-资源分配图**的一个例子,其中共有三个资源类,每个进程的资源占有和申请情况已清楚地表示在图中。在这个例子中,由于存在 **占有和等待资源的环路**,导致一组进程永远处于等待资源的状态,发生了 **死锁**。 - -![进程-资源分配图](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/process-resource-allocation-diagram.jpg) - -进程-资源分配图中存在环路并不一定是发生了死锁。因为循环等待资源仅仅是死锁发生的必要条件,而不是充分条件。图 2-22 便是一个有环路而无死锁的例子。虽然进程 P1 和进程 P3 分别占用了一个资源 R1 和一个资源 R2,并且因为等待另一个资源 R2 和另一个资源 R1 形成了环路,但进程 P2 和进程 P4 分别占有了一个资源 R1 和一个资源 R2,它们申请的资源得到了满足,在有限的时间里会归还资源,于是进程 P1 或 P3 都能获得另一个所需的资源,环路自动解除,系统也就不存在死锁状态了。 - -##### 死锁检测步骤 - -知道了死锁检测的原理,我们可以利用下列步骤编写一个 **死锁检测** 程序,检测系统是否产生了死锁。 - -1. 如果进程-资源分配图中无环路,则此时系统没有发生死锁。 -2. 如果进程-资源分配图中有环路,且每个资源类仅有一个资源,则系统中已经发生了死锁。 -3. 如果进程-资源分配图中有环路,且涉及到的资源类有多个资源,此时系统未必会发生死锁。如果能在进程-资源分配图中找出一个 **既不阻塞又非独立的进程**,该进程能够在有限的时间内归还占有的资源,也就是把边给消除掉了,重复此过程,直到能在有限的时间内 **消除所有的边**,则不会发生死锁,否则会发生死锁。(消除边的过程类似于 **拓扑排序**) +面试里回答到这个程度即可:解决死锁一般有 **预防、避免、检测和解除/恢复** 四类思路。 -#### 死锁的解除 +- **预防**:提前破坏死锁四个必要条件之一。工程里最常见的是固定加锁顺序、缩小锁范围、避免持锁做慢操作。 +- **避免**:分配资源前判断系统是否仍处于安全状态,典型代表是银行家算法。这个方法更偏教材理解,普通业务系统很少直接实现。 +- **检测**:允许等待发生,再检查等待图或资源分配图里是否出现环。Java 里可以用 `jcmd Thread.print -l`、`jstack -l ` 或 `ThreadMXBean.findDeadlockedThreads()` 辅助排查;数据库也会检测事务等待环。 +- **解除/恢复**:发现死锁后打破等待环,例如终止进程、回滚事务、抢占资源或让应用层重试。数据库事务天然支持回滚,因此更适合采用检测和恢复。 -当死锁检测程序检测到存在死锁发生时,应设法让其解除,让系统从死锁状态中恢复过来,常用的解除死锁的方法有以下四种: +![死锁处理策略图:预防、避免、检测、恢复四类方法的作用位置和工程常见程度](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-strategies.png) -1. **立即结束所有进程的执行,重新启动操作系统**:这种方法简单,但以前所在的工作全部作废,损失很大。 -2. **撤销涉及死锁的所有进程,解除死锁后继续运行**:这种方法能彻底打破**死锁的循环等待**条件,但将付出很大代价,例如有些进程可能已经计算了很长时间,由于被撤销而使产生的部分结果也被消除了,再重新执行时还要再次进行计算。 -3. **逐个撤销涉及死锁的进程,回收其资源直至死锁解除。** -4. **抢占资源**:从涉及死锁的一个或几个进程中抢占资源,把夺得的资源再分配给涉及死锁的进程直至死锁解除。 +这部分面试不必展开太细,抓住层次即可。想继续看资源分配图、等待图、Java 线程栈排查和数据库死锁重试,可以看:[死锁详解:四个必要条件、Java 死锁排查与数据库死锁处理](./dead-lock.md)。 ## 参考 From 28a80e77ece9dcbb0f21b37ac48486354e115b15 Mon Sep 17 00:00:00 2001 From: Guide Date: Mon, 15 Jun 2026 07:24:11 +0800 Subject: [PATCH 019/116] =?UTF-8?q?docs:=20=E6=96=B0=E5=A2=9E=20Java=20?= =?UTF-8?q?=E9=94=81=E8=AF=A6=E8=A7=A3=E6=96=87=E7=AB=A0=20=E2=80=94=20?= =?UTF-8?q?=E5=B9=B6=E5=8F=91=E4=B8=93=E9=A2=98=E5=86=85=E5=AE=B9=E4=BD=93?= =?UTF-8?q?=E7=B3=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增 Java 锁详解,串联互斥锁、读写锁、自旋锁与 synchronized 锁优化 - 更新并发侧边栏、专题 README 和根 README,补齐入口与学习路径 - 调整并发问答中的死锁配图引用,复用操作系统死锁专题配图 - 已通过 prettier、markdownlint 和 VuePress 构建验证 --- README.md | 1 + docs/.vuepress/sidebar/index.ts | 1 + docs/java/concurrent/README.md | 10 +- .../java-concurrent-questions-01.md | 2 +- docs/java/concurrent/java-lock.md | 436 ++++++++++++++++++ 5 files changed, 445 insertions(+), 5 deletions(-) create mode 100644 docs/java/concurrent/java-lock.md diff --git a/README.md b/README.md index ccfea6e556b..bdc911b419c 100755 --- a/README.md +++ b/README.md @@ -100,6 +100,7 @@ **重要知识点详解**: +- [Java 锁详解](./docs/java/concurrent/java-lock.md) - [乐观锁和悲观锁详解](./docs/java/concurrent/optimistic-lock-and-pessimistic-lock.md) - [CAS 详解](./docs/java/concurrent/cas.md) - [JMM(Java 内存模型)详解](./docs/java/concurrent/jmm.md) diff --git a/docs/.vuepress/sidebar/index.ts b/docs/.vuepress/sidebar/index.ts index bd0b52f0aff..17ddb9f08fe 100644 --- a/docs/.vuepress/sidebar/index.ts +++ b/docs/.vuepress/sidebar/index.ts @@ -118,6 +118,7 @@ export default sidebar({ "java-concurrent-questions-02", "java-concurrent-questions-03", createImportantSection([ + { text: "Java 锁详解", link: "java-lock" }, "optimistic-lock-and-pessimistic-lock", "cas", "jmm", diff --git a/docs/java/concurrent/README.md b/docs/java/concurrent/README.md index d93fb78645e..2a1db685e6c 100644 --- a/docs/java/concurrent/README.md +++ b/docs/java/concurrent/README.md @@ -1,6 +1,6 @@ --- title: Java 并发编程专题:线程、锁、JMM、CAS、AQS、线程池与虚拟线程 -description: Java 并发编程面试与学习路线,涵盖线程、锁、JMM、CAS、AQS、ReentrantLock、ThreadLocal、线程池、CompletableFuture 和虚拟线程。 +description: Java 并发编程面试与学习路线,涵盖线程、锁、synchronized、ReentrantLock、JMM、CAS、AQS、ThreadLocal、线程池、CompletableFuture 和虚拟线程。 category: Java tag: - Java @@ -12,7 +12,7 @@ sitemap: head: - - meta - name: keywords - content: Java并发,Java并发面试题,JMM,CAS,AQS,ReentrantLock,ThreadLocal,线程池,CompletableFuture,并发容器,Atomic,虚拟线程 + content: Java并发,Java锁,synchronized,ReentrantLock,JMM,CAS,AQS,ThreadLocal,线程池,CompletableFuture,并发容器,Atomic,虚拟线程 --- Java 并发编程是后端开发和面试中最重要、也最容易混淆的模块之一。学习并发不能只背 API,要把线程生命周期、锁机制、内存模型、原子操作、线程池和并发工具类放在同一条主线上理解。 @@ -27,7 +27,7 @@ Java 并发编程是后端开发和面试中最重要、也最容易混淆的模 ## 学习重点 - 线程创建、生命周期、上下文切换、线程安全和常见并发问题。 -- `synchronized`、`volatile`、`ReentrantLock`、乐观锁、悲观锁的适用边界。 +- `synchronized`、`volatile`、`ReentrantLock`、互斥锁、读写锁、乐观锁、悲观锁的适用边界。 - JMM、happens-before、指令重排、可见性、原子性和有序性。 - CAS、Atomic 原子类、AQS、并发容器和阻塞队列的底层思路。 - 线程池核心参数、拒绝策略、任务队列、参数配置和生产实践。 @@ -37,7 +37,7 @@ Java 并发编程是后端开发和面试中最重要、也最容易混淆的模 1. [Java并发常见面试题总结(上)](./java-concurrent-questions-01.md):先建立线程、锁和线程安全的基础问题清单。 2. [Java并发常见面试题总结(中)](./java-concurrent-questions-02.md) 和 [Java并发常见面试题总结(下)](./java-concurrent-questions-03.md):继续补齐 JMM、CAS、AQS、线程池和并发工具。 -3. [乐观锁和悲观锁详解](./optimistic-lock-and-pessimistic-lock.md)、[CAS 详解](./cas.md)、[JMM(Java 内存模型)详解](./jmm.md):理解并发控制的底层语义。 +3. [Java 锁详解](./java-lock.md)、[乐观锁和悲观锁详解](./optimistic-lock-and-pessimistic-lock.md)、[CAS 详解](./cas.md)、[JMM(Java 内存模型)详解](./jmm.md):先建立锁体系,再理解并发控制的底层语义。 4. [AQS 详解](./aqs.md)、[从ReentrantLock的实现看AQS的原理及应用](./reentrantlock.md):深入理解 Java 锁和同步器。 5. [Java 线程池详解](./java-thread-pool-summary.md) 和 [Java 线程池最佳实践](./java-thread-pool-best-practices.md):掌握生产中最常用的并发基础设施。 @@ -51,6 +51,7 @@ Java 并发编程是后端开发和面试中最重要、也最容易混淆的模 ### 锁、内存模型与同步器 +- [Java 锁详解](./java-lock.md):从互斥锁、读写锁、自旋锁到 `synchronized`、`ReentrantLock`、AQS,建立 Java 锁体系。 - [乐观锁和悲观锁详解](./optimistic-lock-and-pessimistic-lock.md):理解不同并发冲突处理策略。 - [CAS 详解](./cas.md):理解比较并交换、ABA 问题和自旋开销。 - [JMM(Java 内存模型)详解](./jmm.md):掌握可见性、原子性、有序性和 happens-before。 @@ -71,6 +72,7 @@ Java 并发编程是后端开发和面试中最重要、也最容易混淆的模 - 线程和进程有什么区别?线程有哪些状态? - 什么是线程安全?如何定位死锁? +- 互斥锁、读写锁、自旋锁有什么区别? - `synchronized` 和 `ReentrantLock` 有什么区别? - `volatile` 能保证原子性吗?它解决什么问题? - JMM 是什么?happens-before 规则有什么用? diff --git a/docs/java/concurrent/java-concurrent-questions-01.md b/docs/java/concurrent/java-concurrent-questions-01.md index c692b730f0e..00d5f7497df 100644 --- a/docs/java/concurrent/java-concurrent-questions-01.md +++ b/docs/java/concurrent/java-concurrent-questions-01.md @@ -263,7 +263,7 @@ Java 使用的线程调度是抢占式的。也就是说,JVM 本身不负责 如下图所示,线程 A 持有资源 2,线程 B 持有资源 1,他们同时都想申请对方的资源,所以这两个线程就会互相等待而进入死锁状态。 -![线程死锁示意图 ](https://oss.javaguide.cn/github/javaguide/java/2019-4%E6%AD%BB%E9%94%811.png) +![死锁场景示意图:线程 A 持有 resource1 并等待 resource2,线程 B 持有 resource2 并等待 resource1,等待链形成闭环](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-deadlock-scenario.png) 下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》): diff --git a/docs/java/concurrent/java-lock.md b/docs/java/concurrent/java-lock.md new file mode 100644 index 00000000000..971c1608f6c --- /dev/null +++ b/docs/java/concurrent/java-lock.md @@ -0,0 +1,436 @@ +--- +title: Java 锁详解:互斥锁、读写锁、自旋锁与 synchronized 锁优化 +description: Java 锁机制系统梳理:从互斥锁、读写锁、自旋锁到 synchronized、ReentrantLock、AQS、StampedLock,讲清锁分类、实现原理、版本差异与选型建议。 +category: Java +tag: + - Java并发 +head: + - - meta + - name: keywords + content: Java锁,互斥锁,读写锁,自旋锁,synchronized,ReentrantLock,AQS,StampedLock,CAS,锁升级,锁优化,Java并发 +--- + +学 Java 并发时,锁相关的名字很容易让大家搞混:互斥锁、读写锁、自旋锁、悲观锁、乐观锁、CAS、AQS、`synchronized`、`ReentrantLock`、`StampedLock`、偏向锁、轻量级锁、重量级锁。 + +这些名字并不都在同一个分类维度里。 + +有的说“谁能进入临界区”,比如互斥锁和读写锁;有的说“拿不到锁时怎么等”,比如自旋锁和阻塞锁;有的说“修改共享数据前先锁住,还是提交时再校验”,比如悲观锁和乐观锁;还有的说 HotSpot 在不同竞争强度下怎么优化 `synchronized`。 + +这篇文章先把锁的坐标系立起来,再看 Java 里常用锁工具怎么落地。关于悲观锁、乐观锁和 CAS 的细节,站内已经有两篇文章详细介绍:[乐观锁和悲观锁详解](./optimistic-lock-and-pessimistic-lock.md)、[CAS 详解](./cas.md)。本文只保留必要上下文,重点放在“锁体系怎么串起来”。 + +PS:本文主要以 HotSpot / OpenJDK 为背景。`synchronized` 的 monitor 互斥和内存语义属于 Java/JVM 规范层面;对象头、Mark Word、轻量级锁、锁膨胀这些内容属于 HotSpot 实现优化,不是 Java 语言规范承诺的固定流程。偏向锁从 JDK 15 起默认禁用并废弃相关参数,JDK 18 起相关参数已经 obsoleted;虚拟线程与 `synchronized` pinning 的结论也要区分 JDK 21~23 和 JDK 24+。 + +文章正式开始之前,我先用一张表把分类维度拆开,让大家看的更清晰一些: + +| 维度 | 典型名称 | 回答的问题 | +| -------------- | ---------------------------------------------- | ------------------------------------ | +| 临界区互斥方式 | 互斥锁、读写锁 | 谁能进入临界区 | +| 等待策略 | 自旋锁、阻塞锁 | 拿不到锁时怎么等 | +| 并发控制思路 | 悲观锁、乐观锁 | 先锁住再改,还是提交时校验 | +| 原子更新机制 | CAS、Atomic 类 | 如何无阻塞更新单个变量 | +| JVM 实现优化 | 轻量级锁、重量级锁、锁膨胀 | HotSpot 如何降低 `synchronized` 成本 | +| Java 锁工具 | `synchronized`、`ReentrantLock`、`StampedLock` | 代码里具体用什么 | + +## 一把锁到底保护什么? + +锁要解决的是临界区问题。临界区不是某段“看起来危险”的代码,而是那段会访问共享可变状态,并且不能让多个执行单元随意交错执行的代码。 + +比如下面这个自增: + +```java +count++; +``` + +源码里只有一行,但它不是一个不可拆的动作。线程通常要先读出 `count`,再加 1,最后写回去。两个线程同时执行时,可能都读到旧值 `0`,各自算出 `1`,最后都把 `1` 写回去。两个线程都执行了自增,结果只加了一次。 + +锁的做法很直接:进入这段代码前先获得锁,执行完再释放锁。只要所有访问同一份共享状态的代码都遵守同一把锁的约定,就可以把原本可能交错的读写压成一段互斥执行。 + +这里有一句很容易被忽略的话:**锁保护的不是对象本身,而是访问对象状态的协议**。 + +`synchronized (account)` 不会神奇地让 `account` 的所有字段都安全。如果另一段代码绕过这把锁直接改 `account.balance`,线程安全照样会被破坏。MIT 6.005 的锁课程反复强调的也是这个点:锁应该守住某个数据抽象的表示不变量,而不是随便找个对象套一下。 + +## 互斥锁:同一时刻只允许一个线程进入 + +互斥锁(Mutex)的规则很简单:同一时刻,最多只有一个线程持有锁并进入临界区。 + +在 Java 中,`synchronized` 和 `ReentrantLock` 都可以作为互斥锁使用: + +```java +class Counter { + private int count; + + public synchronized void increment() { + count++; + } + + public synchronized int get() { + return count; + } +} +``` + +换成 `ReentrantLock`,写法会啰嗦一点,但能拿到更多控制权: + +```java +class Counter { + private final ReentrantLock lock = new ReentrantLock(); + private int count; + + public void increment() { + lock.lock(); + try { + count++; + } finally { + lock.unlock(); + } + } +} +``` + +`try/finally` 不能省。`synchronized` 的释放动作由 JVM 帮你做,代码块正常退出或异常退出都会释放 monitor;`ReentrantLock` 是显式 API,拿锁和解锁要自己配对。Oracle 的 `ReentrantLock` 文档也把“调用 `lock` 后立刻进入 `try` 块”作为推荐写法。 + +互斥锁真正难的地方不在语法,而在锁粒度。 + +一把大锁把所有操作都包住,最省心,但并发度低;多把小锁分别保护不同数据,吞吐可能更好,但锁顺序、死锁、状态一致性都更难管。OSTEP 在讲 POSIX mutex 时也提到过这个取舍:不同数据用不同锁能增加并发,但程序员必须清楚每把锁到底保护哪一块状态。 + +## 读写锁:读读共享,写操作独占 + +互斥锁对读操作也很严格:只要一个线程在读,另一个线程也不能进来读。但很多业务对象有一个特点:读不会改变状态,多个读线程同时执行并不会互相破坏。 + +读写锁就是为这种场景准备的。 + +它把访问分成两类: + +- 读锁:共享锁,多个线程可以同时持有。 +- 写锁:独占锁,只能一个线程持有,并且写锁和读锁互斥。 + +对应规则也很好记: + +- 读读不互斥。 +- 读写互斥。 +- 写写互斥。 + +Java 里的典型实现是 `ReentrantReadWriteLock`: + +```java +class ProfileCache { + private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); + private final Lock readLock = rwLock.readLock(); + private final Lock writeLock = rwLock.writeLock(); + private final Map cache = new HashMap<>(); + + public String get(long userId) { + readLock.lock(); + try { + return cache.get(userId); + } finally { + readLock.unlock(); + } + } + + public void put(long userId, String profile) { + writeLock.lock(); + try { + cache.put(userId, profile); + } finally { + writeLock.unlock(); + } + } +} +``` + +读写锁适合读多写少、读操作足够短、数据结构不容易被拆坏的场景。它不适合所有缓存,也不一定比互斥锁快。如果写操作很频繁,读线程和写线程会不断互相挡路,读写锁的维护成本反而可能抵消收益。 + +Java 还提供了 `StampedLock`,它支持写锁、悲观读锁和乐观读。乐观读不是传统意义上的“拿到一把读锁”,而是先拿一个 stamp,读完后再校验期间有没有写入发生: + +```java +class Point { + private final StampedLock lock = new StampedLock(); + private double x; + private double y; + + double distanceFromOrigin() { + long stamp = lock.tryOptimisticRead(); + double currentX = x; + double currentY = y; + if (!lock.validate(stamp)) { + stamp = lock.readLock(); + try { + currentX = x; + currentY = y; + } finally { + lock.unlockRead(stamp); + } + } + return Math.hypot(currentX, currentY); + } +} +``` + +`StampedLock` 的乐观读有边界:读到的数据可能短暂不一致,所以只适合能在本地变量里完成读取、并且可以通过 `validate` 失败后重读来兜底的短读场景。它也不是 `ReentrantReadWriteLock` 的平替,尤其要注意它不支持重入。 + +## 自旋锁:不阻塞,先原地等一会儿 + +线程拿不到锁时,通常有两种等待方式: + +- 阻塞:挂起当前线程,让操作系统之后再唤醒。 +- 自旋:不挂起线程,在 CPU 上循环检查锁是否可用。 + +自旋锁适合临界区非常短的场景。比如持锁线程马上就会释放锁,如果等待线程直接阻塞,线程挂起和唤醒的成本可能比“原地转几圈”等待还高。 + +问题也在这里:自旋不是免费等待,它会持续占用 CPU。如果锁很久不释放,或者等待线程很多,自旋会把 CPU 时间浪费在空转上。 + +Java 代码里可以用 CAS 写出一个很小的自旋锁示例: + +```java +class SpinLock { + private final AtomicReference owner = new AtomicReference<>(); + + public void lock() { + Thread current = Thread.currentThread(); + while (!owner.compareAndSet(null, current)) { + Thread.onSpinWait(); + } + } + + public void unlock() { + Thread current = Thread.currentThread(); + if (!owner.compareAndSet(current, null)) { + throw new IllegalMonitorStateException(); + } + } +} +``` + +这段代码只是用来说明“自旋 + CAS”的关系,不建议直接拿去做业务锁。真实锁要考虑可重入、公平性、中断、超时、异常释放、监控指标、等待队列等问题。JDK 已经把这些复杂性封装在 `synchronized`、`ReentrantLock`、AQS 同步器和 Atomic 类里了。 + +## 悲观锁、乐观锁和 CAS 的位置 + +悲观锁和乐观锁不是具体某个 Java 类,而是两种并发控制思路。 + +悲观锁假设冲突很可能发生,所以先把资源锁住再操作。`synchronized`、`ReentrantLock`、数据库 `SELECT ... FOR UPDATE` 都是常见例子。 + +乐观锁假设冲突不频繁,先不阻塞别人,提交修改时再检查数据有没有被改过。数据库里的 `version` 字段、Java Atomic 类里的 CAS,都属于这个方向。 + +CAS(Compare-And-Swap,比较并交换)可以理解成一种硬件支持的原子更新方式:只有当内存中的值仍然等于预期旧值时,才把它改成新值。否则说明有人先改过了,当前线程可以选择重试、放弃或走降级逻辑。 + +CAS 常见问题有三个: + +- 失败重试会消耗 CPU,冲突越激烈越明显。 +- 只能很自然地处理单个变量,多个变量的一致性要额外设计。 +- ABA 问题:值从 A 变成 B,又变回 A,单看值会以为它没变过。 + +ABA 可以用版本号、时间戳或带标记引用解决。Java 里有 `AtomicStampedReference` 和 `AtomicMarkableReference` 这类工具,不过在业务代码里更常见的做法是让数据模型本身带版本号。 + +这块如果继续展开,就会和已有文章重复。想看实现方式、版本号示例、ABA 处理和 Atomic 类源码,可以继续读: + +- [乐观锁和悲观锁详解](./optimistic-lock-and-pessimistic-lock.md) +- [CAS 详解](./cas.md) +- [Atomic 原子类总结](./atomic-classes.md) + +## synchronized 的底层:monitor、字节码和内存语义 + +`synchronized` 是 Java 语言内置的同步机制,可以修饰实例方法、静态方法,也可以包住代码块。 + +```java +class Account { + private long balance; + + public synchronized void deposit(long amount) { + balance += amount; + } + + public long balance() { + synchronized (this) { + return balance; + } + } +} +``` + +同步方法和同步代码块在字节码层面的表现不完全一样: + +- 同步方法依赖方法访问标志 `ACC_SYNCHRONIZED`。 +- 同步代码块会生成 `monitorenter` 和 `monitorexit` 指令。 + +不管表现形式如何,语义都是进入 monitor、退出 monitor。Java 语言规范还规定了锁释放和后续锁获取之间的 happens-before 关系:一个线程释放某把锁之前的写入,对随后获得同一把锁的线程可见。 + +这也是 `synchronized` 和“只做互斥”的普通概念锁不同的地方。它同时提供互斥和内存可见性。只保护临界区但不建立可见性,另一个线程可能仍然读到旧值。 + +另外,`synchronized` 是可重入的。一个线程已经持有某个对象的 monitor 时,可以再次进入同一把锁保护的代码,JVM 会记录重入次数,退出时逐层减少。 + +```java +class ReentrantDemo { + public synchronized void outer() { + inner(); + } + + public synchronized void inner() { + // 同一线程可以再次进入 this 的 monitor + } +} +``` + +## synchronized 锁优化:别把“锁升级”背成固定口诀 + +很多资料会把 `synchronized` 讲成“无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁”。这条线索对理解 HotSpot 早期优化很有帮助,但不能脱离版本。 + +JDK 6 之后,HotSpot 为 `synchronized` 做了大量优化。偏向锁面向“总是同一个线程进入同一把锁”的场景;轻量级锁面向“竞争不激烈,多个线程错开进入”的场景;重量级锁则会用到 ObjectMonitor,竞争线程可能阻塞和唤醒。 + +版本差异要单独记一下: + +- JDK 6 到 JDK 14:偏向锁是 HotSpot 常见优化之一。 +- JDK 15:JEP 374 将偏向锁默认禁用,并废弃相关参数。 +- JDK 18:偏向锁相关参数被 obsoleted,传入后会被忽略并给出警告。 +- JDK 21 到 JDK 23:虚拟线程在 `synchronized` 中阻塞时可能 pin 住平台线程。 +- JDK 24:JEP 491 改进了虚拟线程与 `synchronized` 的配合,阻塞在 `synchronized` 上的虚拟线程可以释放底层平台线程,减少 pinning 问题。 + +所以,面试或写文章时可以讲“HotSpot 曾经通过偏向锁、轻量级锁、重量级锁降低 `synchronized` 成本”,但不要把偏向锁说成现代 JDK 一定会走的默认路径。 + +工程上更重要的是另一个结论:`synchronized` 已经不是早年那个“能不用就不用”的重量级选择。普通互斥场景下,它语法简单、异常释放安全、JIT 优化成熟。只有当你需要公平锁、可中断获取、超时获取、多个条件队列时,才更自然地转向 `ReentrantLock`。 + +## ReentrantLock、Condition 和 AQS 怎么接上 + +`ReentrantLock` 提供了比 `synchronized` 更细的控制能力: + +- 可以选择公平锁或非公平锁。 +- 可以用 `lockInterruptibly()` 响应中断。 +- 可以用 `tryLock()` 或 `tryLock(timeout, unit)` 避免无限等待。 +- 可以创建多个 `Condition`,把不同等待条件拆开管理。 + +一个典型写法如下: + +```java +class BoundedBuffer { + private final ReentrantLock lock = new ReentrantLock(); + private final Condition notFull = lock.newCondition(); + private final Condition notEmpty = lock.newCondition(); + private final Queue queue = new ArrayDeque<>(); + private final int capacity; + + BoundedBuffer(int capacity) { + this.capacity = capacity; + } + + public void put(E item) throws InterruptedException { + lock.lockInterruptibly(); + try { + while (queue.size() == capacity) { + notFull.await(); + } + queue.add(item); + notEmpty.signal(); + } finally { + lock.unlock(); + } + } + + public E take() throws InterruptedException { + lock.lockInterruptibly(); + try { + while (queue.isEmpty()) { + notEmpty.await(); + } + E item = queue.remove(); + notFull.signal(); + return item; + } finally { + lock.unlock(); + } + } +} +``` + +这里的 `while` 也不能随便改成 `if`。线程被唤醒后,只能说明“有机会重新竞争锁并检查条件”,不代表条件一定成立。虚假唤醒、多个等待线程竞争、条件被别的线程先消费掉,都要求醒来后再次检查。 + +`ReentrantLock` 底层依赖 AQS(AbstractQueuedSynchronizer)。AQS 可以先粗略理解成一套同步器框架:用一个 `state` 表示同步状态,用 FIFO 队列管理没抢到资源的线程,再配合 CAS、`LockSupport.park/unpark` 完成排队、阻塞和唤醒。 + +很多并发工具都建立在 AQS 之上,比如 `ReentrantLock`、`Semaphore`、`CountDownLatch`、`ReentrantReadWriteLock`。想继续深入,可以看 [AQS 详解](./aqs.md) 和 [从ReentrantLock的实现看AQS的原理及应用](./reentrantlock.md)。 + +## Java 锁该怎么选? + +选锁时不要先问“哪个锁性能最好”。更靠谱的问法是:共享状态在哪里?临界区有多长?拿不到锁时能不能等?失败以后能不能重试? + +如果只是保护 JVM 进程内的一小段状态,比如更新几个字段、维护一个内存 Map、切换对象状态,`synchronized` 往往就够了。它语法短,退出代码块时自动释放锁,少了手写 `unlock()` 漏掉的风险。等你真的需要超时获取、可中断获取、公平锁,或者要用多个 `Condition` 管理不同等待队列,再考虑 `ReentrantLock`。 + +读多写少时,可以看 `ReentrantReadWriteLock`。这里的重点是“写少”,不是“代码里有读方法”。如果写操作很频繁,读锁和写锁会一直互相挡,维护读写状态也有成本,最后未必比一把互斥锁更划算。`StampedLock` 的乐观读更挑场景:读逻辑要短,读到中间状态也不能出大问题,并且必须接受校验失败后重新读一遍。 + +如果只是更新一个计数、状态位或引用,优先看 Atomic 类、`LongAdder`、`LongAccumulator` 这类工具。它们适合很短的原子更新,不适合把一整段业务流程塞进 CAS 重试循环里。业务流程越长,失败重试越容易把 CPU 消耗在无效循环上,也更难处理副作用。 + +如果问题已经越过 JVM 边界,比如多个应用实例同时改同一行数据库记录,Java 里的锁就管不住了。冲突不频繁时,可以用版本号做乐观锁;冲突比较频繁、必须强一致修改时,通常要回到数据库行锁、`SELECT ... FOR UPDATE`、唯一约束这类数据库机制。再往外走到跨服务互斥,就需要 Redis、ZooKeeper、数据库等外部系统来承接,不能指望 `synchronized` 或 `ReentrantLock`。 + +锁粒度也别一味追求“小”。一把大锁容易保证正确性,但吞吐可能受影响;拆成多把小锁,竞争会少一些,可锁顺序、死锁和排查成本都会上来。很多时候,先用清楚的一把锁把不变量守住,再根据压测结果拆锁,比一开始就设计一堆细粒度锁更稳。 + +## 常见坑 + +**锁对象不稳定。** + +有些代码看起来加了锁,实际锁的不是同一把。常见原因是锁对象会变,比如字符串拼接结果、装箱对象、可重新赋值的字段。线程 A 进来时锁的是旧对象,线程 B 进来时锁的是新对象,两边互不影响,临界区就被拆开了。 + +```java +private Object lock = new Object(); + +public void update() { + synchronized (lock) { + lock = new Object(); // 后续线程可能会锁到另一把锁 + } +} +``` + +如果需要单独的锁对象,通常把它定义成 `private final`,并且不要把它暴露给外部代码。 + +**锁住外部可见对象。** + +`synchronized (this)` 和 `synchronized (SomeClass.class)` 有时没问题,但它们也可能被外部代码拿来加锁,导致你无法控制锁竞争范围。库代码尤其要谨慎,通常更推荐私有 final 锁对象。 + +```java +private final Object lock = new Object(); +``` + +**持锁期间做慢操作。** + +持锁时访问数据库、调用 RPC、写大文件,都会拉长锁占用时间。锁占用越久,等待线程越多,超时、线程池耗尽和死锁风险都会变高。 + +**锁顺序不一致。** + +两个线程分别按 `A -> B` 和 `B -> A` 的顺序加锁,很容易形成死锁。多把锁同时使用时,要给资源排一个全局稳定顺序。死锁的完整介绍可以看 [死锁详解](../../cs-basics/operating-system/dead-lock.md)。 + +**把线程安全类和复合操作混为一谈。** + +`ConcurrentHashMap` 的单次 `get`、`put` 是线程安全的,但“先判断不存在,再插入”是复合操作,需要用 `computeIfAbsent` 这类原子方法,或者额外同步。 + +```java +// 不推荐:containsKey 和 put 之间可能被其他线程插入 +if (!map.containsKey(key)) { + map.put(key, createValue()); +} + +// 推荐:把复合逻辑交给 ConcurrentHashMap 的原子方法 +map.computeIfAbsent(key, ignored -> createValue()); +``` + +**只看锁,不看资源池。** + +线上很多“卡住”并不是 Java 锁死锁,而是线程都在等数据库连接、HTTP 连接、线程池队列或外部服务返回。线程栈里看到 `WAITING` 不等于死锁,关键证据是稳定的等待环。 + +## 小结 + +锁不是一个单独知识点,而是一组并发控制工具的总称。 + +互斥锁和读写锁回答“谁能进临界区”;自旋锁和阻塞锁回答“拿不到锁怎么等”;悲观锁和乐观锁回答“冲突发生前后怎么处理”;CAS 和 Atomic 类解决单变量原子更新;`synchronized`、`ReentrantLock`、`StampedLock`、AQS 则是 Java 把这些思想落到代码里的方式。 + +真正写代码时,先把共享状态和不变量找出来,再决定锁保护什么、锁粒度多大、等待是否能中断、失败是否能重试。工具本身不是重点,重点是让所有访问共享状态的路径遵守同一套同步协议。 + +## 参考资料 + +- [The Java Language Specification, Chapter 17. Threads and Locks](https://docs.oracle.com/javase/specs/jls/se24/html/jls-17.html) +- [The Java Virtual Machine Specification, monitorenter](https://docs.oracle.com/javase/specs/jvms/se24/html/jvms-6.html#jvms-6.5.monitorenter) +- [Oracle Java API: Lock](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Lock.html) +- [Oracle Java API: ReentrantLock](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/ReentrantLock.html) +- [Oracle Java API: StampedLock](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html) +- [OpenJDK JEP 374: Deprecate and Disable Biased Locking](https://openjdk.org/jeps/374) +- [OpenJDK JEP 491: Synchronize Virtual Threads without Pinning](https://openjdk.org/jeps/491) +- [OSTEP 中文版:Locks](https://pages.cs.wisc.edu/~remzi/OSTEP/Chinese/28.pdf) +- [MIT 6.005: Locks and Synchronization](http://web.mit.edu/6.005/www/fa15/classes/23-locks/) + + From 5790fb210b09c2b0021f9362f701b822812c6178 Mon Sep 17 00:00:00 2001 From: Guide Date: Mon, 15 Jun 2026 07:34:06 +0800 Subject: [PATCH 020/116] =?UTF-8?q?docs:=20=E7=BB=9F=E4=B8=80=20Java=20?= =?UTF-8?q?=E6=96=87=E6=A1=A3=E6=8E=92=E7=89=88=20=E2=80=94=20=E6=8F=90?= =?UTF-8?q?=E5=8D=87=E9=98=85=E8=AF=BB=E4=B8=80=E8=87=B4=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 规范基础、集合、并发、IO、JVM 和新特性文档的中英文空格 - 统一 JEP 标题括号、链接周边标点和代码名词排版 - 验证 git diff --check 通过 --- docs/java/basis/bigdecimal.md | 12 +- docs/java/basis/generics-and-wildcards.md | 28 +- docs/java/basis/java-basic-questions-01.md | 88 +++--- docs/java/basis/java-basic-questions-02.md | 94 +++---- docs/java/basis/java-basic-questions-03.md | 104 +++---- docs/java/basis/java-keyword-summary.md | 24 +- docs/java/basis/proxy.md | 26 +- docs/java/basis/reflection.md | 10 +- docs/java/basis/serialization.md | 12 +- docs/java/basis/spi.md | 20 +- docs/java/basis/syntactic-sugar.md | 66 ++--- docs/java/basis/unsafe.md | 75 ++--- .../why-there-only-value-passing-in-java.md | 4 +- .../arrayblockingqueue-source-code.md | 46 ++-- docs/java/collection/arraylist-source-code.md | 58 ++-- .../concurrent-hash-map-source-code.md | 18 +- .../copyonwritearraylist-source-code.md | 34 +-- .../java/collection/delayqueue-source-code.md | 36 +-- docs/java/collection/hashmap-source-code.md | 6 +- .../java-collection-precautions-for-use.md | 44 +-- .../java-collection-questions-01.md | 106 +++---- .../java-collection-questions-02.md | 88 +++--- .../collection/linkedhashmap-source-code.md | 36 +-- .../java/collection/linkedlist-source-code.md | 22 +- docs/java/concurrent/aqs.md | 210 +++++++------- docs/java/concurrent/atomic-classes.md | 4 +- docs/java/concurrent/cas.md | 32 +-- .../concurrent/completablefuture-intro.md | 42 +-- .../concurrent/java-concurrent-collections.md | 12 +- .../java-concurrent-questions-01.md | 70 ++--- .../java-concurrent-questions-02.md | 170 ++++++------ .../java-concurrent-questions-03.md | 196 ++++++------- .../java-thread-pool-best-practices.md | 32 +-- .../concurrent/java-thread-pool-summary.md | 92 +++---- docs/java/concurrent/jmm.md | 34 +-- .../optimistic-lock-and-pessimistic-lock.md | 26 +- docs/java/concurrent/reentrantlock.md | 2 +- docs/java/concurrent/threadlocal.md | 260 +++++++++--------- docs/java/io/io-basis.md | 58 ++-- docs/java/io/io-design-patterns.md | 38 +-- docs/java/io/io-model.md | 16 +- docs/java/io/nio-basis.md | 36 +-- docs/java/jvm/class-file-structure.md | 20 +- docs/java/jvm/class-loading-process.md | 24 +- docs/java/jvm/classloader.md | 64 ++--- ...dk-monitoring-and-troubleshooting-tools.md | 24 +- docs/java/jvm/jvm-garbage-collection.md | 28 +- docs/java/jvm/jvm-in-action.md | 6 +- docs/java/jvm/jvm-intro.md | 36 +-- docs/java/jvm/jvm-parameters-intro.md | 20 +- docs/java/jvm/memory-area.md | 32 +-- docs/java/new-features/java10.md | 6 +- docs/java/new-features/java11.md | 2 +- docs/java/new-features/java12-13.md | 8 +- docs/java/new-features/java14-15.md | 14 +- docs/java/new-features/java16.md | 10 +- docs/java/new-features/java17.md | 6 +- docs/java/new-features/java18.md | 4 +- docs/java/new-features/java19.md | 6 +- docs/java/new-features/java20.md | 12 +- docs/java/new-features/java21.md | 24 +- docs/java/new-features/java22-23.md | 20 +- docs/java/new-features/java24.md | 34 +-- docs/java/new-features/java25.md | 26 +- docs/java/new-features/java26.md | 20 +- .../new-features/java8-common-new-features.md | 46 ++-- .../new-features/java8-tutorial-translate.md | 88 +++--- docs/java/new-features/java9.md | 28 +- 68 files changed, 1498 insertions(+), 1497 deletions(-) diff --git a/docs/java/basis/bigdecimal.md b/docs/java/basis/bigdecimal.md index 7978438f298..eb4ca20dd56 100644 --- a/docs/java/basis/bigdecimal.md +++ b/docs/java/basis/bigdecimal.md @@ -72,7 +72,7 @@ System.out.println(x.compareTo(y));// 0 ### 创建 -我们在使用 `BigDecimal` 时,为了防止精度丢失,推荐使用它的`BigDecimal(String val)`构造方法或者 `BigDecimal.valueOf(double val)` 静态方法来创建对象。 +我们在使用 `BigDecimal` 时,为了防止精度丢失,推荐使用它的 `BigDecimal(String val)` 构造方法或者 `BigDecimal.valueOf(double val)` 静态方法来创建对象。 《阿里巴巴 Java 开发手册》对这部分内容也有提到,如下图所示。 @@ -92,7 +92,7 @@ System.out.println(a.divide(b));// 无法除尽,抛出 ArithmeticException 异 System.out.println(a.divide(b, 2, RoundingMode.HALF_UP));// 1.11 ``` -这里需要注意的是,在我们使用 `divide` 方法的时候尽量使用 3 个参数版本,并且`RoundingMode` 不要选择 `UNNECESSARY`,否则很可能会遇到 `ArithmeticException`(无法除尽出现无限循环小数的时候),其中 `scale` 表示要保留几位小数,`roundingMode` 代表保留规则。 +这里需要注意的是,在我们使用 `divide` 方法的时候尽量使用 3 个参数版本,并且 `RoundingMode` 不要选择 `UNNECESSARY`,否则很可能会遇到 `ArithmeticException`(无法除尽出现无限循环小数的时候),其中 `scale` 表示要保留几位小数,`roundingMode` 代表保留规则。 ```java public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) { @@ -125,7 +125,7 @@ public enum RoundingMode { ### 大小比较 -`a.compareTo(b)` : 返回 -1 表示 `a` 小于 `b`,0 表示 `a` 等于 `b` , 1 表示 `a` 大于 `b`。 +`a.compareTo(b)` : 返回 -1 表示 `a` 小于 `b`,0 表示 `a` 等于 `b`, 1 表示 `a` 大于 `b`。 ```java BigDecimal a = new BigDecimal("1.0"); @@ -135,7 +135,7 @@ System.out.println(a.compareTo(b));// 1 ### 保留几位小数 -通过 `setScale`方法设置保留几位小数以及保留规则。保留规则有挺多种,不需要记,IDEA 会提示。 +通过 `setScale` 方法设置保留几位小数以及保留规则。保留规则有挺多种,不需要记,IDEA 会提示。 ```java BigDecimal m = new BigDecimal("1.255433"); @@ -356,7 +356,7 @@ public class BigDecimalUtil { } ``` -相关 issue:[建议对保留规则设置为 RoundingMode.HALF_EVEN,即四舍六入五成双,#2129](https://github.com/Snailclimb/JavaGuide/issues/2129) 。 +相关 issue:[建议对保留规则设置为 RoundingMode.HALF_EVEN,即四舍六入五成双,#2129](https://github.com/Snailclimb/JavaGuide/issues/2129)。 ![RoundingMode.HALF_EVEN](https://oss.javaguide.cn/github/javaguide/java/basis/RoundingMode.HALF_EVEN.png) @@ -364,6 +364,6 @@ public class BigDecimalUtil { 浮点数没有办法用二进制精确表示,因此存在精度丢失的风险。 -不过,Java 提供了`BigDecimal` 来操作浮点数。`BigDecimal` 的实现利用到了 `BigInteger` (用来操作大整数), 所不同的是 `BigDecimal` 加入了小数位的概念。 +不过,Java 提供了 `BigDecimal` 来操作浮点数。`BigDecimal` 的实现利用到了 `BigInteger`(用来操作大整数), 所不同的是 `BigDecimal` 加入了小数位的概念。 diff --git a/docs/java/basis/generics-and-wildcards.md b/docs/java/basis/generics-and-wildcards.md index 1740999940c..2e65ef52bbc 100644 --- a/docs/java/basis/generics-and-wildcards.md +++ b/docs/java/basis/generics-and-wildcards.md @@ -22,7 +22,7 @@ head: ArrayList extends AbstractList ``` -并且,原生 `List` 返回类型是 `Object` ,需要手动转换类型才能使用,使用泛型后编译器自动转换。 +并且,原生 `List` 返回类型是 `Object`,需要手动转换类型才能使用,使用泛型后编译器自动转换。 ### 泛型的使用方式有哪几种? @@ -54,7 +54,7 @@ Generic genericInteger = new Generic(123456); // JDK 7 起可写:new Generic<>(123456) ``` -**2.泛型接口** : +**2.泛型接口**: ```java public interface Generator { @@ -84,7 +84,7 @@ class GeneratorImpl implements Generator { } ``` -**3.泛型方法** : +**3.泛型方法**: ```java public static < E > void printArray( E[] inputArray ) @@ -113,11 +113,11 @@ printArray( stringArray ); - 构建集合工具类(参考 `Collections` 中的 `sort`, `binarySearch` 方法)。 - …… -### 什么是泛型擦除机制?为什么要擦除? +### 什么是泛型擦除机制?为什么要擦除? -**Java 的泛型是伪泛型,这是因为 Java 在编译期间,所有的泛型信息都会被擦掉,这也就是通常所说类型擦除 。** +**Java 的泛型是伪泛型,这是因为 Java 在编译期间,所有的泛型信息都会被擦掉,这也就是通常所说类型擦除。** -编译器会在编译期间会动态地将泛型 `T` 擦除为 `Object` 或将 `T extends xxx` 擦除为其限定类型 `xxx` 。 +编译器会在编译期间会动态地将泛型 `T` 擦除为 `Object` 或将 `T extends xxx` 擦除为其限定类型 `xxx`。 因此,泛型本质上其实还是编译器的行为,为了保证引入泛型机制但不创建新的类型,减少虚拟机的运行开销,编译器通过擦除将泛型类转化为一般类。 @@ -146,7 +146,7 @@ public void print(List list) { } ![泛型擦除的问题](https://oss.javaguide.cn/github/javaguide/java/basis/generics-runtime-erasure.png) -原因也很简单,泛型擦除之后,`List` 与 `List` 在编译以后都变成了 `List` 。 +原因也很简单,泛型擦除之后,`List` 与 `List` 在编译以后都变成了 `List`。 **既然编译器要把泛型擦除,那为什么还要用泛型呢?用 Object 代替不行吗?** @@ -156,7 +156,7 @@ public void print(List list) { } - 使用 `Object` 类型需要手动添加强制类型转换,降低代码可读性,提高出错概率。 -- 泛型可以使用自限定类型如 `T extends Comparable` 。 +- 泛型可以使用自限定类型如 `T extends Comparable`。 ### 什么是桥方法? @@ -187,7 +187,7 @@ class MyNode extends Node { } ``` -⚠️**注意** :桥方法为编译器自动生成,非手写。 +⚠️**注意**:桥方法为编译器自动生成,非手写。 ### 泛型有哪些限制?为什么? @@ -228,7 +228,7 @@ public class Singleton { } ``` -无法编译,因为不能使用 `static` 修饰泛型 `T` 。 +无法编译,因为不能使用 `static` 修饰泛型 `T`。 ## 通配符 @@ -245,7 +245,7 @@ public class Singleton { ``` -### 通配符 ?和常用的泛型 T 之间有什么区别? +### 通配符?和常用的泛型 T 之间有什么区别? - `T` 可以用于声明变量或常量而 `?` 不行。 - `T` 一般用于声明泛型类或方法,通配符 `?` 一般用于泛型方法的调用代码和形参。 @@ -293,7 +293,7 @@ list2.add("sss");//警告信息 ``` -**下边界通配符 `super`** 与上边界通配符 `extends`刚好相反,它可以实现泛型的向下转型即传入的类型实参必须是指定类型的父类型。 +**下边界通配符 `super`** 与上边界通配符 `extends` 刚好相反,它可以实现泛型的向下转型即传入的类型实参必须是指定类型的父类型。 举个例子: @@ -329,7 +329,7 @@ Node nc = new Node<>(); Node ns = nc; ``` -不能,因为`Node` 不是 `Node` 的子类 +不能,因为 `Node` 不是 `Node` 的子类 ```java class Shape { /* ... */ } @@ -358,5 +358,5 @@ public static void print(List list) { ## 参考 -- Java 官方文档 : https://docs.oracle.com/javase/tutorial/java/generics/index.html +- Java 官方文档: https://docs.oracle.com/javase/tutorial/java/generics/index.html - Java 基础 一文搞懂泛型:https://www.cnblogs.com/XiiX/p/14719568.html diff --git a/docs/java/basis/java-basic-questions-01.md b/docs/java/basis/java-basic-questions-01.md index d8b03dbb60f..628a00d2fa6 100644 --- a/docs/java/basis/java-basic-questions-01.md +++ b/docs/java/basis/java-basic-questions-01.md @@ -12,7 +12,7 @@ head: ## 基础概念与常识 -### Java 语言有哪些特点? +### Java 语言有哪些特点? 1. 简单易学(语法简单,上手容易); 2. 面向对象(封装,继承,多态); @@ -25,7 +25,7 @@ head: 9. 编译与解释并存; 10. …… -> **🐛 修正(参见:[issue#544](https://github.com/Snailclimb/JavaGuide/issues/544))**:C++11 开始(2011 年的时候),C++ 就引入了多线程库,在 Windows、Linux、macOS 都可以使用`std::thread`和`std::async`来创建线程。参考链接: +> **🐛 修正(参见:[issue#544](https://github.com/Snailclimb/JavaGuide/issues/544))**:C++11 开始(2011 年的时候),C++ 就引入了多线程库,在 Windows、Linux、macOS 都可以使用 `std::thread` 和 `std::async` 来创建线程。参考链接: 🌈 拓展一下: @@ -40,7 +40,7 @@ head: 除了 Java SE 和 Java EE,还有一个 Java ME(Java Platform,Micro Edition)。Java ME 是 Java 的微型版本,主要用于开发嵌入式消费电子设备的应用程序,例如手机、PDA、机顶盒、冰箱、空调等。Java ME 无需重点关注,知道有这个东西就好了,现在已经用不上了。 -### ⭐️JVM vs JDK vs JRE +### ⭐️ JVM vs JDK vs JRE #### JVM @@ -52,7 +52,7 @@ Java 虚拟机(Java Virtual Machine, JVM)是运行 Java 字节码的虚拟 **JVM 并不是只有一种!只要满足 JVM 规范,每个公司、组织或者个人都可以开发自己的专属 JVM。** 也就是说我们平时接触到的 HotSpot VM 仅仅是是 JVM 规范的一种实现而已。 -除了我们平时最常用的 HotSpot VM 外,还有 J9 VM、Zing VM、JRockit VM 等 JVM 。维基百科上就有常见 JVM 的对比:[Comparison of Java virtual machines](https://en.wikipedia.org/wiki/Comparison_of_Java_virtual_machines) ,感兴趣的可以去看看。并且,你可以在 [Java SE Specifications](https://docs.oracle.com/javase/specs/index.html) 上找到各个版本的 JDK 对应的 JVM 规范。 +除了我们平时最常用的 HotSpot VM 外,还有 J9 VM、Zing VM、JRockit VM 等 JVM。维基百科上就有常见 JVM 的对比:[Comparison of Java virtual machines](https://en.wikipedia.org/wiki/Comparison_of_Java_virtual_machines),感兴趣的可以去看看。并且,你可以在 [Java SE Specifications](https://docs.oracle.com/javase/specs/index.html) 上找到各个版本的 JDK 对应的 JVM 规范。 ![](https://oss.javaguide.cn/github/javaguide/java/basis/JavaSeSpecifications.jpg) @@ -73,7 +73,7 @@ JRE 是运行已编译 Java 程序所需的环境,主要包含以下两个部 ![jdk-include-jre](https://oss.javaguide.cn/github/javaguide/java/basis/jdk-include-jre.png) -不过,从 JDK 9 开始,就不需要区分 JDK 和 JRE 的关系了,取而代之的是模块系统(JDK 被重新组织成 94 个模块)+ [jlink](http://openjdk.java.net/jeps/282) 工具 (随 Java 9 一起发布的新命令行工具,用于生成自定义 Java 运行时映像,该映像仅包含给定应用程序所需的模块) 。并且,从 JDK 11 开始,Oracle 不再提供单独的 JRE 下载。 +不过,从 JDK 9 开始,就不需要区分 JDK 和 JRE 的关系了,取而代之的是模块系统(JDK 被重新组织成 94 个模块)+ [jlink](http://openjdk.java.net/jeps/282) 工具(随 Java 9 一起发布的新命令行工具,用于生成自定义 Java 运行时映像,该映像仅包含给定应用程序所需的模块)。并且,从 JDK 11 开始,Oracle 不再提供单独的 JRE 下载。 在 [Java 9 新特性概览](https://javaguide.cn/java/new-features/java9.html)这篇文章中,我在介绍模块化系统的时候提到: @@ -83,7 +83,7 @@ JRE 是运行已编译 Java 程序所需的环境,主要包含以下两个部 定制的、模块化的 Java 运行时映像有助于简化 Java 应用的部署和节省内存并增强安全性和可维护性。这对于满足现代应用程序架构的需求,如虚拟化、容器化、微服务和云原生开发,是非常重要的。 -### ⭐️什么是字节码?采用字节码的好处是什么? +### ⭐️ 什么是字节码?采用字节码的好处是什么? 在 Java 中,JVM 可以理解的代码就叫做字节码(即扩展名为 `.class` 的文件),它不面向任何特定的处理器,只面向虚拟机。Java 语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以, Java 程序运行时相对来说还是高效的(不过,和 C、 C++,Rust,Go 等语言还是有一定差距的),而且,由于字节码并不针对一种特定的机器,因此,Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。 @@ -91,7 +91,7 @@ JRE 是运行已编译 Java 程序所需的环境,主要包含以下两个部 ![Java程序转变为机器代码的过程](https://oss.javaguide.cn/github/javaguide/java/basis/java-code-to-machine-code.png) -我们需要格外注意的是 `.class->机器码` 这一步。在这一步 JVM 类加载器首先加载字节码文件,然后通过解释器逐行解释执行,这种方式的执行速度会相对比较慢。而且,有些方法和代码块是经常需要被调用的(也就是所谓的热点代码),所以后面引进了 **JIT(Just in Time Compilation)** 编译器,而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后,其会将字节码对应的机器码保存下来,下次可以直接使用。而我们知道,机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 **Java 是编译与解释共存的语言** 。 +我们需要格外注意的是 `.class->机器码` 这一步。在这一步 JVM 类加载器首先加载字节码文件,然后通过解释器逐行解释执行,这种方式的执行速度会相对比较慢。而且,有些方法和代码块是经常需要被调用的(也就是所谓的热点代码),所以后面引进了 **JIT(Just in Time Compilation)** 编译器,而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后,其会将字节码对应的机器码保存下来,下次可以直接使用。而我们知道,机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 **Java 是编译与解释共存的语言**。 > 🌈 拓展阅读: > @@ -110,7 +110,7 @@ JDK、JRE、JVM、JIT 这四者的关系如下图所示。 ![JVM 的大致结构模型](https://oss.javaguide.cn/github/javaguide/java/basis/jvm-rough-structure-model.png) -### ⭐️为什么说 Java 语言“编译与解释并存”? +### ⭐️ 为什么说 Java 语言“编译与解释并存”? 其实这个问题我们讲字节码的时候已经提到过,因为比较重要,所以我们这里再提一下。 @@ -133,7 +133,7 @@ JDK、JRE、JVM、JIT 这四者的关系如下图所示。 ### AOT 有什么优点?为什么不全部使用 AOT 呢? -JDK 9 引入了一种新的编译模式 **AOT(Ahead of Time Compilation)** 。和 JIT 不同的是,这种编译模式会在程序被执行前就将其编译成机器码,属于静态编译(C、 C++,Rust,Go 等语言就是静态编译)。AOT 避免了 JIT 预热等各方面的开销,可以提高 Java 程序的启动速度,避免预热时间长。并且,AOT 还能减少内存占用和增强 Java 程序的安全性(AOT 编译后的代码不容易被反编译和修改),特别适合云原生场景。 +JDK 9 引入了一种新的编译模式 **AOT(Ahead of Time Compilation)**。和 JIT 不同的是,这种编译模式会在程序被执行前就将其编译成机器码,属于静态编译(C、 C++,Rust,Go 等语言就是静态编译)。AOT 避免了 JIT 预热等各方面的开销,可以提高 Java 程序的启动速度,避免预热时间长。并且,AOT 还能减少内存占用和增强 Java 程序的安全性(AOT 编译后的代码不容易被反编译和修改),特别适合云原生场景。 **JIT 与 AOT 两者的关键指标对比**: @@ -162,7 +162,7 @@ JDK 9 引入了一种新的编译模式 **AOT(Ahead of Time Compilation)** 。 ### Oracle JDK vs OpenJDK -可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么 Oracle JDK 和 OpenJDK 之间是否存在重大差异?下面我通过收集到的一些资料,为你解答这个被很多人忽视的问题。 +可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK。那么 Oracle JDK 和 OpenJDK 之间是否存在重大差异?下面我通过收集到的一些资料,为你解答这个被很多人忽视的问题。 首先,2006 年 SUN 公司将 Java 开源,也就有了 OpenJDK。2009 年 Oracle 收购了 Sun 公司,于是自己在 OpenJDK 的基础上搞了一个 Oracle JDK。Oracle JDK 是不开源的,并且刚开始的几个版本(Java8 ~ Java11)还会相比于 OpenJDK 添加一些特有的功能和工具。 @@ -176,7 +176,7 @@ JDK 9 引入了一种新的编译模式 **AOT(Ahead of Time Compilation)** 。 最后,简单总结一下 Oracle JDK 和 OpenJDK 的区别: -1. **是否开源**:OpenJDK 是一个参考模型并且是完全开源的,而 Oracle JDK 是基于 OpenJDK 实现的,并不是完全开源的(个人观点:众所周知,JDK 原来是 SUN 公司开发的,后来 SUN 公司又卖给了 Oracle 公司,Oracle 公司以 Oracle 数据库而著名,而 Oracle 数据库又是闭源的,这个时候 Oracle 公司就不想完全开源了,但是原来的 SUN 公司又把 JDK 给开源了,如果这个时候 Oracle 收购回来之后就把他给闭源,必然会引起很多 Java 开发者的不满,导致大家对 Java 失去信心,那 Oracle 公司收购回来不就把 Java 烂在手里了吗!然后,Oracle 公司就想了个骚操作,这样吧,我把一部分核心代码开源出来给你们玩,并且我要和你们自己搞的 JDK 区分下,你们叫 OpenJDK,我叫 Oracle JDK,我发布我的,你们继续玩你们的,要是你们搞出来什么好玩的东西,我后续发布 Oracle JDK 也会拿来用一下,一举两得!)OpenJDK 开源项目:[https://github.com/openjdk/jdk](https://github.com/openjdk/jdk) 。 +1. **是否开源**:OpenJDK 是一个参考模型并且是完全开源的,而 Oracle JDK 是基于 OpenJDK 实现的,并不是完全开源的(个人观点:众所周知,JDK 原来是 SUN 公司开发的,后来 SUN 公司又卖给了 Oracle 公司,Oracle 公司以 Oracle 数据库而著名,而 Oracle 数据库又是闭源的,这个时候 Oracle 公司就不想完全开源了,但是原来的 SUN 公司又把 JDK 给开源了,如果这个时候 Oracle 收购回来之后就把他给闭源,必然会引起很多 Java 开发者的不满,导致大家对 Java 失去信心,那 Oracle 公司收购回来不就把 Java 烂在手里了吗!然后,Oracle 公司就想了个骚操作,这样吧,我把一部分核心代码开源出来给你们玩,并且我要和你们自己搞的 JDK 区分下,你们叫 OpenJDK,我叫 Oracle JDK,我发布我的,你们继续玩你们的,要是你们搞出来什么好玩的东西,我后续发布 Oracle JDK 也会拿来用一下,一举两得!)OpenJDK 开源项目:[https://github.com/openjdk/jdk](https://github.com/openjdk/jdk)。 2. **是否免费**:Oracle JDK 会提供免费版本,但一般有时间限制。JDK17 之后的版本可以免费分发和商用,但是仅有 3 年时间,3 年后无法免费商用。不过,JDK8u221 之前只要不升级可以无限期免费。OpenJDK 是完全免费的。 3. **功能性**:Oracle JDK 在 OpenJDK 的基础上添加了一些特有的功能和工具,比如 Java Flight Recorder(JFR,一种监控工具)、Java Mission Control(JMC,一种监控工具)等工具。不过,在 Java 11 之后,OracleJDK 和 OpenJDK 的功能基本一致,之前 OracleJDK 中的私有组件大多数也已经被捐赠给开源组织。 4. **稳定性**:OpenJDK 不提供 LTS 服务,而 OracleJDK 大概每三年都会推出一个 LTS 版进行长期支持。不过,很多公司都基于 OpenJDK 提供了对应的和 OracleJDK 周期相同的 LTS 版。因此,两者稳定性其实也是差不多的。 @@ -203,7 +203,7 @@ JDK 9 引入了一种新的编译模式 **AOT(Ahead of Time Compilation)** 。 - BCL 协议(Oracle Binary Code License Agreement):可以使用 JDK(支持商用),但是不能进行修改。 - OTN 协议(Oracle Technology Network License Agreement):11 及之后新发布的 JDK 用的都是这个协议,可以自己私下用,但是商用需要付费。 -### Java 和 C++ 的区别? +### Java 和 C++ 的区别? 我知道很多人没学过 C++,但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀!没办法!!!就算没学过 C++,也要记下来。 @@ -231,7 +231,7 @@ Java 中的注释有三种: ![](https://oss.javaguide.cn/github/javaguide/java/basis/image-20220714112336911.png) -在我们编写代码的时候,如果代码量比较少,我们自己或者团队其他成员还可以很轻易地看懂代码,但是当项目结构一旦复杂起来,我们就需要用到注释了。注释并不会执行(编译器在编译代码之前会把代码中的所有注释抹掉,字节码中不保留注释),是我们程序员写给自己看的,注释是你的代码说明书,能够帮助看代码的人快速地理清代码之间的逻辑关系。因此,在写程序的时候随手加上注释是一个非常好的习惯。 +在我们编写代码的时候,如果代码量比较少,我们自己或者团队其他成员还可以很轻易地看懂代码,但是当项目结构一旦复杂起来,我们就需要用到注释了。注释并不会执行(编译器在编译代码之前会把代码中的所有注释抹掉,字节码中不保留注释),是我们程序员写给自己看的,注释是你的代码说明书,能够帮助看代码的人快速地理清代码之间的逻辑关系。因此,在写程序的时候随手加上注释是一个非常好的习惯。 《Clean Code》这本书明确指出: @@ -256,9 +256,9 @@ Java 中的注释有三种: ### 标识符和关键字的区别是什么? -在我们编写程序的时候,需要大量地为程序、类、变量、方法等取名字,于是就有了 **标识符** 。简单来说, **标识符就是一个名字** 。 +在我们编写程序的时候,需要大量地为程序、类、变量、方法等取名字,于是就有了 **标识符**。简单来说, **标识符就是一个名字**。 -有一些标识符,Java 语言已经赋予了其特殊的含义,只能用于特定的地方,这些特殊的标识符就是 **关键字** 。简单来说,**关键字是被赋予特殊含义的标识符** 。比如,在我们的日常生活中,如果我们想要开一家店,则要给这个店起一个名字,起的这个“名字”就叫标识符。但是我们店的名字不能叫“警察局”,因为“警察局”这个名字已经被赋予了特殊的含义,而“警察局”就是我们日常生活中的关键字。 +有一些标识符,Java 语言已经赋予了其特殊的含义,只能用于特定的地方,这些特殊的标识符就是 **关键字**。简单来说,**关键字是被赋予特殊含义的标识符**。比如,在我们的日常生活中,如果我们想要开一家店,则要给这个店起一个名字,起的这个“名字”就叫标识符。但是我们店的名字不能叫“警察局”,因为“警察局”这个名字已经被赋予了特殊的含义,而“警察局”就是我们日常生活中的关键字。 ### Java 语言关键字有哪些? @@ -288,7 +288,7 @@ Java 中的注释有三种: 官方文档:[https://docs.oracle.com/javase/tutorial/java/nutsandbolts/\_keywords.html](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html) -### ⭐️自增自减运算符 +### ⭐️ 自增自减运算符 在写代码的过程中,常见的一种情况是需要某个整数类型变量增加 1 或减少 1。Java 提供了自增运算符 (`++`) 和自减运算符 (`--`) 来简化这种操作。 @@ -322,7 +322,7 @@ flowchart LR linkStyle default stroke-width:1.5px,opacity:0.8 ``` -下面来看一个考察自增自减运算符的高频笔试题:执行下面的代码后,`a` 、`b` 、 `c` 、`d`和`e`的值是? +下面来看一个考察自增自减运算符的高频笔试题:执行下面的代码后,`a`、`b`、 `c`、`d` 和 `e` 的值是? ```java int a = 9; @@ -332,9 +332,9 @@ int d = c--; int e = --d; ``` -答案:`a = 11` 、`b = 9` 、 `c = 10` 、 `d = 10` 、 `e = 10`。 +答案:`a = 11`、`b = 9`、 `c = 10`、 `d = 10`、 `e = 10`。 -### ⭐️移位运算符 +### ⭐️ 移位运算符 移位运算符是最基本的运算符之一,几乎每种编程语言都包含这一运算符。移位操作中,被操作的数据被视为二进制数,移位就是将其向左或向右移动若干位的运算。 @@ -407,7 +407,7 @@ flowchart TB Java 中有三种移位运算符: -- `<<` :左移运算符,向左移若干位,高位丢弃,低位补零。`x << n`,相当于 x 乘以 2 的 n 次方(不溢出的情况下)。 +- `<<` :左移运算符,向左移若干位,高位丢弃,低位补零。`x << n`,相当于 x 乘以 2 的 n 次方(不溢出的情况下)。 - `>>` :带符号右移,向右移若干位,高位补符号位,低位丢弃。正数高位补 0,负数高位补 1。`x >> n`,相当于 x 除以 2 的 n 次方。 - `>>>` :无符号右移,忽略符号位,空位都以 0 补齐。 @@ -415,13 +415,13 @@ Java 中有三种移位运算符: 由于 `double`,`float` 在二进制中的表现比较特殊,因此不能来进行移位操作。 -移位操作符实际上支持的类型只有`int`和`long`,编译器在对`short`、`byte`、`char`类型进行移位前,都会将其转换为`int`类型再操作。 +移位操作符实际上支持的类型只有 `int` 和 `long`,编译器在对 `short`、`byte`、`char` 类型进行移位前,都会将其转换为 `int` 类型再操作。 **如果移位的位数超过数值所占有的位数会怎样?** 当 int 类型左移/右移位数大于等于 32 位操作时,会先求余(%)后再进行左移/右移操作。也就是说左移/右移 32 位相当于不进行移位操作(32%32=0),左移/右移 42 位相当于左移/右移 10 位(42%32=10)。当 long 类型进行左移/右移操作时,由于 long 对应的二进制是 64 位,因此求余操作的基数也变成了 64。 -也就是说:`x<<42`等同于`x<<10`,`x>>42`等同于`x>>10`,`x >>>42`等同于`x >>> 10`。 +也就是说:`x<<42` 等同于 `x<<10`,`x>>42` 等同于 `x>>10`,`x >>>42` 等同于 `x >>> 10`。 **左移运算符代码示例**: @@ -458,7 +458,7 @@ System.out.println("左移 10 位后的数据对应的二进制字符 " + Intege ### continue、break 和 return 的区别是什么? -在循环结构中,当循环条件不满足或者循环次数达到要求时,循环会正常结束。但是,有时候可能需要在循环的过程中,当发生了某种条件之后 ,提前终止循环,这就需要用到下面几个关键词: +在循环结构中,当循环条件不满足或者循环次数达到要求时,循环会正常结束。但是,有时候可能需要在循环的过程中,当发生了某种条件之后,提前终止循环,这就需要用到下面几个关键词: 1. `continue`:指跳出当前的这一次循环,继续下一次循环。 2. `break`:指跳出整个循环体,继续执行循环下面的语句。 @@ -548,7 +548,7 @@ xixi haha ``` -## ⭐️基本数据类型 +## ⭐️ 基本数据类型 ### Java 中的几种基本数据类型了解么? @@ -604,7 +604,7 @@ flowchart TB | `double` | 64 | 8 | 0d | 4.9E-324 ~ 1.7976931348623157E308 | | `boolean` | 1 | | false | true、false | -可以看到,像 `byte`、`short`、`int`、`long`能表示的最大正数都减 1 了。这是为什么呢?这是因为在二进制补码表示法中,最高位是用来表示符号的(0 表示正数,1 表示负数),其余位表示数值部分。所以,如果我们要表示最大的正数,我们需要把除了最高位之外的所有位都设为 1。如果我们再加 1,就会导致溢出,变成一个负数。 +可以看到,像 `byte`、`short`、`int`、`long` 能表示的最大正数都减 1 了。这是为什么呢?这是因为在二进制补码表示法中,最高位是用来表示符号的(0 表示正数,1 表示负数),其余位表示数值部分。所以,如果我们要表示最大的正数,我们需要把除了最高位之外的所有位都设为 1。如果我们再加 1,就会导致溢出,变成一个负数。 对于 `boolean`,官方文档未明确定义,它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位,但是实际中会考虑计算机高效存储因素。 @@ -616,14 +616,14 @@ flowchart TB 2. Java 里使用 `float` 类型的数据一定要在数值后面加上 **f 或 F**,否则将无法通过编译。 3. `char a = 'h'`char :单引号,`String a = "hello"` :双引号。 -这八种基本类型都有对应的包装类分别为:`Byte`、`Short`、`Integer`、`Long`、`Float`、`Double`、`Character`、`Boolean` 。 +这八种基本类型都有对应的包装类分别为:`Byte`、`Short`、`Integer`、`Long`、`Float`、`Double`、`Character`、`Boolean`。 ### 基本类型和包装类型的区别? - **用途**:除了定义一些常量和局部变量之外,我们在其他地方比如方法参数、对象属性中很少会使用基本类型来定义变量。并且,包装类型可用于泛型,而基本类型不可以。 -- **存储方式**:基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中,基本数据类型的成员变量(未被 `static` 修饰 )存放在 Java 虚拟机的堆中。包装类型属于对象类型,我们知道几乎所有对象实例都存在于堆中。 +- **存储方式**:基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中,基本数据类型的成员变量(未被 `static` 修饰)存放在 Java 虚拟机的堆中。包装类型属于对象类型,我们知道几乎所有对象实例都存在于堆中。 - **占用空间**:相比于包装类型(对象类型), 基本数据类型占用的空间往往非常小。 -- **默认值**:成员变量包装类型不赋值就是 `null` ,而基本类型有默认值且不是 `null`。 +- **默认值**:成员变量包装类型不赋值就是 `null`,而基本类型有默认值且不是 `null`。 - **比较方式**:对于基本数据类型来说,`==` 比较的是值。对于包装数据类型来说,`==` 比较的是对象的内存地址。所有整型包装类对象之间值的比较,全部使用 `equals()` 方法。 **为什么说是几乎所有对象实例都存在于堆中呢?** 这是因为 HotSpot 虚拟机引入了 JIT 优化之后,会对对象进行逃逸分析,如果发现某一个对象并没有逃逸到方法外部,那么就可能通过标量替换来实现栈上分配,而避免堆上分配内存 @@ -654,7 +654,7 @@ Java 基本数据类型的包装类型的大部分都用到了缓存机制来提 对于 `Integer`,可以通过 JVM 参数 `-XX:AutoBoxCacheMax=` 修改缓存上限,但不能修改下限 -128。实际使用时,并不建议设置过大的值,避免浪费内存,甚至是 OOM。 -对于`Byte`,`Short`,`Long` ,`Character` 没有类似 `-XX:AutoBoxCacheMax` 参数可以修改,因此缓存范围是固定的,无法通过 JVM 参数调整。`Boolean` 则直接返回预定义的 `TRUE` 和 `FALSE` 实例,没有缓存范围的概念。 +对于 `Byte`,`Short`,`Long` ,`Character` 没有类似 `-XX:AutoBoxCacheMax` 参数可以修改,因此缓存范围是固定的,无法通过 JVM 参数调整。`Boolean` 则直接返回预定义的 `TRUE` 和 `FALSE` 实例,没有缓存范围的概念。 **Integer 缓存源码:** @@ -729,9 +729,9 @@ Integer i2 = new Integer(40); System.out.println(i1==i2); ``` -`Integer i1=40` 这一行代码会发生装箱,也就是说这行代码等价于 `Integer i1=Integer.valueOf(40)` 。因此,`i1` 直接使用的是缓存中的对象。而`Integer i2 = new Integer(40)` 会直接创建新的对象。 +`Integer i1=40` 这一行代码会发生装箱,也就是说这行代码等价于 `Integer i1=Integer.valueOf(40)`。因此,`i1` 直接使用的是缓存中的对象。而 `Integer i2 = new Integer(40)` 会直接创建新的对象。 -因此,答案是 `false` 。你答对了吗? +因此,答案是 `false`。你答对了吗? 记住:**所有整型包装类对象之间值的比较,全部使用 equals 方法比较**。 @@ -813,7 +813,7 @@ int n = i; //拆箱 RETURN ``` -从字节码中,我们发现装箱其实就是调用了 包装类的`valueOf()`方法,拆箱其实就是调用了 `xxxValue()`方法。 +从字节码中,我们发现装箱其实就是调用了 包装类的 `valueOf()` 方法,拆箱其实就是调用了 `xxxValue()` 方法。 因此, @@ -903,14 +903,14 @@ System.out.println(l + 1 == Long.MIN_VALUE); // true ## 变量 -### ⭐️成员变量与局部变量的区别? +### ⭐️ 成员变量与局部变量的区别? ![](https://oss.javaguide.cn/github/javaguide/java/basis/java-basis-variables-member-variable-vs-local-variable.png) - **语法形式**:从语法形式上看,成员变量是属于类的,而局部变量是在代码块或方法中定义的变量或是方法的参数;成员变量可以被 `public`,`private`,`static` 等修饰符所修饰,而局部变量不能被访问控制修饰符及 `static` 所修饰;但是,成员变量和局部变量都能被 `final` 所修饰。 - **存储方式**:从变量在内存中的存储方式来看,如果成员变量是使用 `static` 修饰的,那么这个成员变量是属于类的,如果没有使用 `static` 修饰,这个成员变量是属于实例的。而对象存在于堆内存,局部变量则存在于栈内存。 - **生存时间**:从变量在内存中的生存时间上看,成员变量是对象的一部分,它随着对象的创建而存在,而局部变量随着方法的调用而自动生成,随着方法的调用结束而消亡。 -- **默认值**:从变量是否有默认值来看,成员变量如果没有被赋初始值,则会自动以类型的默认值而赋值(一种情况例外:被 `final` 修饰的成员变量也必须显式地赋值),而局部变量则不会自动赋值。 +- **默认值**:从变量是否有默认值来看,成员变量如果没有被赋初始值,则会自动以类型的默认值而赋值(一种情况例外:被 `final` 修饰的成员变量也必须显式地赋值),而局部变量则不会自动赋值。 **为什么成员变量有默认值?** @@ -923,7 +923,7 @@ System.out.println(l + 1 == Long.MIN_VALUE); // true 并且,如果一个变量没有被初始化,它的内存里存放的就是“垃圾值”——之前那块内存遗留下的任意数据。如果程序读取并使用了这个垃圾值,就会产生完全不可预测的结果,比如一个数字变成了随机数,一个对象引用变成了非法地址,这会直接导致程序崩溃或出现诡异的 bug。 -为了避免你拿到一个含有“垃圾值”的危险对象,Java干脆为所有成员变量提供了一个安全的默认值(如 null 或 0),作为一种**安全兜底机制**。 +为了避免你拿到一个含有“垃圾值”的危险对象,Java 干脆为所有成员变量提供了一个安全的默认值(如 null 或 0),作为一种**安全兜底机制**。 成员变量与局部变量代码示例: @@ -967,7 +967,7 @@ public class VariableExample { ![](https://oss.javaguide.cn/github/javaguide/java/basis/java-basis-variables-static-variable.png) -静态变量是通过类名来访问的,例如`StaticVariableExample.staticVar`(如果被 `private`关键字修饰就无法这样访问了)。 +静态变量是通过类名来访问的,例如 `StaticVariableExample.staticVar`(如果被 `private` 关键字修饰就无法这样访问了)。 ```java public class StaticVariableExample { @@ -985,7 +985,7 @@ public class ConstantVariableExample { } ``` -### 字符型常量和字符串常量的区别? +### 字符型常量和字符串常量的区别? - **形式** : 字符常量是单引号引起的一个字符,字符串常量是双引号引起的 0 个或若干个字符。 - **含义** : 字符常量相当于一个整型值(ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。 @@ -1018,7 +1018,7 @@ public class StringExample { ## 方法 -### 什么是方法的返回值?方法有哪几种类型? +### 什么是方法的返回值?方法有哪几种类型? **方法的返回值** 是指我们获取到的某个方法体中的代码执行后产生的结果!(前提是该方法可能产生结果)。返回值的作用是接收出结果,使得它可以用于其他的操作! @@ -1065,7 +1065,7 @@ public int f4(int a, int b) { } ``` -### 静态方法为什么不能调用非静态成员? +### 静态方法为什么不能调用非静态成员? 这个需要结合 JVM 的相关知识,主要原因如下: @@ -1090,11 +1090,11 @@ public class Example { } ``` -### ⭐️静态方法和实例方法有何不同? +### ⭐️ 静态方法和实例方法有何不同? **1、调用方式** -在外部调用静态方法时,可以使用 `类名.方法名` 的方式,也可以使用 `对象.方法名` 的方式,而实例方法只有后面这种方式。也就是说,**调用静态方法可以无需创建对象** 。 +在外部调用静态方法时,可以使用 `类名.方法名` 的方式,也可以使用 `对象.方法名` 的方式,而实例方法只有后面这种方式。也就是说,**调用静态方法可以无需创建对象**。 不过,需要注意的是一般不建议使用 `对象.方法名` 的方式来调用静态方法。这种方式非常容易造成混淆,静态方法不属于类的某个对象而是属于这个类。 @@ -1123,7 +1123,7 @@ public class Person { 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),不允许访问实例成员(即实例成员变量和实例方法),而实例方法不存在这个限制。 -### ⭐️重载和重写有什么区别? +### ⭐️ 重载和重写有什么区别? > 重载就是同样的一个方法能够根据输入数据的不同,做出不同的处理 > @@ -1168,7 +1168,7 @@ public class Person { | **访问修饰符** | 与访问修饰符**无关**,可以任意修改。 | 子类方法的访问权限**不能低于**父类方法的访问权限。(public > protected > default > private) | | **绑定时期** | 编译时绑定或称静态绑定 | 运行时绑定 (Run-time Binding) 或称动态绑定 | -**方法的重写要遵循“两同两小一大”**(以下内容摘录自《疯狂 Java 讲义》,[issue#892](https://github.com/Snailclimb/JavaGuide/issues/892) ): +**方法的重写要遵循“两同两小一大”**(以下内容摘录自《疯狂 Java 讲义》,[issue#892](https://github.com/Snailclimb/JavaGuide/issues/892)): - “两同”即方法名相同、形参列表相同; - “两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等,子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等; @@ -1265,7 +1265,7 @@ c d ``` -另外,Java 的可变参数编译后实际会被转换成一个数组,我们看编译后生成的 `class`文件就可以看出来了。 +另外,Java 的可变参数编译后实际会被转换成一个数组,我们看编译后生成的 `class` 文件就可以看出来了。 ```java public class VariableLengthArgument { diff --git a/docs/java/basis/java-basic-questions-02.md b/docs/java/basis/java-basic-questions-02.md index 85c64c67eab..8bce8483b22 100644 --- a/docs/java/basis/java-basic-questions-02.md +++ b/docs/java/basis/java-basic-questions-02.md @@ -14,7 +14,7 @@ head: ## 面向对象基础 -### ⭐️面向对象和面向过程的区别 +### ⭐️ 面向对象和面向过程的区别 面向过程编程(Procedural-Oriented Programming,POP)和面向对象编程(Object-Oriented Programming,OOP)是两种常见的编程范式,两者的主要区别在于解决问题的方式不同: @@ -29,7 +29,7 @@ head: POP 的编程方式通常更为简单和直接,适合处理一些较简单的任务。 -POP 和 OOP 的性能差异主要取决于它们的运行机制,而不仅仅是编程范式本身。因此,简单地比较两者的性能是一个常见的误区(相关 issue : [面向过程:面向过程性能比面向对象高??](https://github.com/Snailclimb/JavaGuide/issues/431) )。 +POP 和 OOP 的性能差异主要取决于它们的运行机制,而不仅仅是编程范式本身。因此,简单地比较两者的性能是一个常见的误区(相关 issue : [面向过程:面向过程性能比面向对象高??](https://github.com/Snailclimb/JavaGuide/issues/431))。 ![ POP 和 OOP 性能比较不合适](https://oss.javaguide.cn/github/javaguide/java/basis/pop-vs-oop-performance.png) @@ -95,14 +95,14 @@ public class Main { 我们直接定义了圆的半径,并使用该半径直接计算出圆的面积和周长。 -### 创建一个对象用什么运算符?对象实例与对象引用有何不同? +### 创建一个对象用什么运算符?对象实例与对象引用有何不同? new 运算符,new 创建对象实例(对象实例在堆内存中),对象引用指向对象实例(对象引用存放在栈内存中)。 - 一个对象引用可以指向 0 个或 1 个对象(一根绳子可以不系气球,也可以系一个气球); - 一个对象可以有 n 个引用指向它(可以用 n 条绳子系住一个气球)。 -### ⭐️对象的相等和引用相等的区别 +### ⭐️ 对象的相等和引用相等的区别 - 对象的相等一般比较的是内存中存放的内容是否相等。 - 引用相等一般比较的是他们指向的内存地址是否相等。 @@ -134,9 +134,9 @@ true 从上面的代码输出结果可以看出: - `str1` 和 `str2` 不相等,而 `str1` 和 `str3` 相等。这是因为 `==` 运算符比较的是字符串的引用是否相等。 -- `str1`、 `str2`、`str3` 三者的内容都相等。这是因为`equals` 方法比较的是字符串的内容,即使这些字符串的对象引用不同,只要它们的内容相等,就认为它们是相等的。 +- `str1`、 `str2`、`str3` 三者的内容都相等。这是因为 `equals` 方法比较的是字符串的内容,即使这些字符串的对象引用不同,只要它们的内容相等,就认为它们是相等的。 -### 如果一个类没有声明构造方法,该程序能正确执行吗? +### 如果一个类没有声明构造方法,该程序能正确执行吗? 构造方法是一种特殊的方法,主要作用是完成对象的初始化工作。 @@ -154,11 +154,11 @@ true 构造方法**不能被重写(override)**,但**可以被重载(overload)**。因此,一个类中可以有多个构造方法,这些构造方法可以具有不同的参数列表,以提供不同的对象初始化方式。 -### ⭐️面向对象三大特征 +### ⭐️ 面向对象三大特征 #### 封装 -封装是指把一个对象的状态信息(也就是属性)隐藏在对象内部,不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息(也就是属性),但是可以通过遥控器(方法)来控制空调。如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。就好像如果没有空调遥控器,那么我们就无法操控空凋制冷,空调本身就没有意义了(当然现在还有很多其他方法 ,这里只是为了举例子)。 +封装是指把一个对象的状态信息(也就是属性)隐藏在对象内部,不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息(也就是属性),但是可以通过遥控器(方法)来控制空调。如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。就好像如果没有空调遥控器,那么我们就无法操控空凋制冷,空调本身就没有意义了(当然现在还有很多其他方法,这里只是为了举例子)。 ```java public class Student { @@ -189,7 +189,7 @@ public class Student { #### 继承 -不同类型的对象,相互之间经常有一定数量的共同点。例如,小明同学、小红同学、小李同学,都共享学生的特性(班级、学号等)。同时,每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好,小红的性格惹人喜爱;小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承,可以快速地创建新的类,可以提高代码的重用,程序的可维护性,节省大量创建新类的时间 ,提高我们的开发效率。 +不同类型的对象,相互之间经常有一定数量的共同点。例如,小明同学、小红同学、小李同学,都共享学生的特性(班级、学号等)。同时,每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好,小红的性格惹人喜爱;小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承,可以快速地创建新的类,可以提高代码的重用,程序的可维护性,节省大量创建新类的时间,提高我们的开发效率。 **关于继承如下 3 点请记住:** @@ -241,7 +241,7 @@ flowchart LR linkStyle default stroke-width:1.5px,opacity:0.8 ``` -### ⭐️接口和抽象类有什么共同点和区别? +### ⭐️ 接口和抽象类有什么共同点和区别? #### 接口和抽象类的共同点 @@ -254,12 +254,12 @@ flowchart LR - **继承和实现**:一个类只能继承一个类(包括抽象类),因为 Java 不支持多继承。但一个类可以实现多个接口,一个接口也可以继承多个其他接口。 - **成员变量**:接口中的成员变量只能是 `public static final` 类型的,不能被修改且必须有初始值。抽象类的成员变量可以有任何修饰符(`private`, `protected`, `public`),可以在子类中被重新定义或赋值。 - **方法**: - - Java 8 之前,接口中的方法默认是 `public abstract` ,也就是只能有方法声明。自 Java 8 起,可以在接口中定义 `default`(默认) 方法和 `static` (静态)方法。 自 Java 9 起,接口可以包含 `private` 方法。 + - Java 8 之前,接口中的方法默认是 `public abstract`,也就是只能有方法声明。自 Java 8 起,可以在接口中定义 `default`(默认) 方法和 `static`(静态)方法。 自 Java 9 起,接口可以包含 `private` 方法。 - 抽象类可以包含抽象方法和非抽象方法。抽象方法没有方法体,必须在子类中实现。非抽象方法有具体实现,可以直接在抽象类中使用或在子类中重写。 在 Java 8 及以上版本中,接口引入了新的方法类型:`default` 方法、`static` 方法和 `private` 方法。这些方法让接口的使用更加灵活。 -Java 8 引入的`default` 方法用于提供接口方法的默认实现,可以在实现类中被覆盖。这样就可以在不修改实现类的情况下向现有接口添加新功能,从而增强接口的扩展性和向后兼容性。 +Java 8 引入的 `default` 方法用于提供接口方法的默认实现,可以在实现类中被覆盖。这样就可以在不修改实现类的情况下向现有接口添加新功能,从而增强接口的扩展性和向后兼容性。 ```java public interface MyInterface { @@ -269,7 +269,7 @@ public interface MyInterface { } ``` -Java 8 引入的`static` 方法无法在实现类中被覆盖,只能通过接口名直接调用( `MyInterface.staticMethod()`),类似于类中的静态方法。`static` 方法通常用于定义一些通用的、与接口相关的工具方法,一般很少用。 +Java 8 引入的 `static` 方法无法在实现类中被覆盖,只能通过接口名直接调用(`MyInterface.staticMethod()`),类似于类中的静态方法。`static` 方法通常用于定义一些通用的、与接口相关的工具方法,一般很少用。 ```java public interface MyInterface { @@ -279,7 +279,7 @@ public interface MyInterface { } ``` -Java 9 允许在接口中使用 `private` 方法。`private`方法可以用于在接口内部共享代码,不对外暴露。 +Java 9 允许在接口中使用 `private` 方法。`private` 方法可以用于在接口内部共享代码,不对外暴露。 ```java public interface MyInterface { @@ -406,7 +406,7 @@ System.out.println(person1.getAddress() == person1Copy.getAddress()); ![图解浅拷贝、深拷贝和引用拷贝](https://oss.javaguide.cn/github/javaguide/java/basis/shallow&deep-copy.png) -## ⭐️Object +## ⭐️ Object ### Object 类的常见方法有哪些? @@ -468,7 +468,7 @@ protected void finalize() throws Throwable { } > 因为 Java 只有值传递,所以,对于 == 来说,不管是比较基本数据类型,还是引用数据类型的变量,其本质比较的都是值,只是引用类型变量存的值是对象的地址。 -**`equals()`** 不能用于判断基本数据类型的变量,只能用来判断两个对象是否相等。`equals()`方法存在于`Object`类中,而`Object`类是所有类的直接或间接父类,因此所有的类都有`equals()`方法。 +**`equals()`** 不能用于判断基本数据类型的变量,只能用来判断两个对象是否相等。`equals()` 方法存在于 `Object` 类中,而 `Object` 类是所有类的直接或间接父类,因此所有的类都有 `equals()` 方法。 `Object` 类 `equals()` 方法: @@ -480,10 +480,10 @@ public boolean equals(Object obj) { `equals()` 方法存在两种使用情况: -- **类没有重写 `equals()`方法**:通过`equals()`比较该类的两个对象时,等价于通过“==”比较这两个对象,使用的默认是 `Object`类`equals()`方法。 -- **类重写了 `equals()`方法**:一般我们都重写 `equals()`方法来比较两个对象中的属性是否相等;若它们的属性相等,则返回 true(即,认为这两个对象相等)。 +- **类没有重写 `equals()` 方法**:通过 `equals()` 比较该类的两个对象时,等价于通过“==”比较这两个对象,使用的默认是 `Object` 类 `equals()` 方法。 +- **类重写了 `equals()` 方法**:一般我们都重写 `equals()` 方法来比较两个对象中的属性是否相等;若它们的属性相等,则返回 true(即,认为这两个对象相等)。 -举个例子(这里只是为了举例。实际上,你按照下面这种写法的话,像 IDEA 这种比较智能的 IDE 都会提示你将 `==` 换成 `equals()` ): +举个例子(这里只是为了举例。实际上,你按照下面这种写法的话,像 IDEA 这种比较智能的 IDE 都会提示你将 `==` 换成 `equals()`): ```java String a = new String("ab"); // a 为一个引用 @@ -498,9 +498,9 @@ System.out.println(42 == 42.0);// true `String` 中的 `equals` 方法是被重写过的,因为 `Object` 的 `equals` 方法是比较的对象的内存地址,而 `String` 的 `equals` 方法比较的是对象的值。 -当使用字符串字面量创建 `String` 类型的对象(如`String aa = "ab"`)时,虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象,如果有就把它赋给当前引用;如果没有,就在常量池中创建一个 `String` 对象并赋给当前引用。但当使用`new`关键字创建对象(如`String a = new String("ab")`)时,虚拟机总是会在堆内存中**创建一个新的对象**并使用常量池中的值(如果没有,会先在字符串常量池中创建字符串对象 "ab")进行初始化,然后赋给当前引用。 +当使用字符串字面量创建 `String` 类型的对象(如 `String aa = "ab"`)时,虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象,如果有就把它赋给当前引用;如果没有,就在常量池中创建一个 `String` 对象并赋给当前引用。但当使用 `new` 关键字创建对象(如 `String a = new String("ab")`)时,虚拟机总是会在堆内存中**创建一个新的对象**并使用常量池中的值(如果没有,会先在字符串常量池中创建字符串对象 "ab")进行初始化,然后赋给当前引用。 -`String`类`equals()`方法: +`String` 类 `equals()` 方法: ```java public boolean equals(Object anObject) { @@ -534,7 +534,7 @@ public boolean equals(Object anObject) { `hashCode()` 定义在 JDK 的 `Object` 类中,这就意味着 Java 中的任何类都包含有 `hashCode()` 函数。另外需要注意的是:`Object` 的 `hashCode()` 方法是本地方法,也就是用 C 语言或 C++ 实现的。 -> ⚠️ 注意:该方法在 **Oracle OpenJDK8** 中默认是 “使用线程局部状态来实现 Marsaglia's xor-shift 随机数生成”, 并不是 “地址” 或者 “地址转换而来”, 不同 JDK/VM 可能不同。在 **Oracle OpenJDK8** 中有六种生成方式 (其中第五种是返回地址), 通过添加 VM 参数: -XX:hashCode=4 启用第五种。参考源码: +> ⚠️ 注意:该方法在 **Oracle OpenJDK8** 中默认是 “使用线程局部状态来实现 Marsaglia's xor-shift 随机数生成”, 并不是 “地址” 或者 “地址转换而来”, 不同 JDK/VM 可能不同。在 **Oracle OpenJDK8** 中有六种生成方式(其中第五种是返回地址), 通过添加 VM 参数: -XX:hashCode=4 启用第五种。参考源码: > > - (1127 行) > - (537 行开始) @@ -562,13 +562,13 @@ public native int hashCode(); **那为什么 JDK 还要同时提供这两个方法呢?** -这是因为在一些容器(比如 `HashMap`、`HashSet`)中,有了 `hashCode()` 之后,判断元素是否在对应容器中的效率会更高(参考添加元素进`HashSet`的过程)! +这是因为在一些容器(比如 `HashMap`、`HashSet`)中,有了 `hashCode()` 之后,判断元素是否在对应容器中的效率会更高(参考添加元素进 `HashSet` 的过程)! -我们在前面也提到了添加元素进`HashSet`的过程,如果 `HashSet` 在对比的时候,同样的 `hashCode` 有多个对象,它会继续使用 `equals()` 来判断是否真的相同。也就是说 `hashCode` 帮助我们大大缩小了查找成本。 +我们在前面也提到了添加元素进 `HashSet` 的过程,如果 `HashSet` 在对比的时候,同样的 `hashCode` 有多个对象,它会继续使用 `equals()` 来判断是否真的相同。也就是说 `hashCode` 帮助我们大大缩小了查找成本。 **那为什么不只提供 `hashCode()` 方法呢?** -这是因为两个对象的`hashCode` 值相等并不代表两个对象就相等。 +这是因为两个对象的 `hashCode` 值相等并不代表两个对象就相等。 **那为什么两个对象有相同的 `hashCode` 值,它们也不一定是相等的?** @@ -576,9 +576,9 @@ public native int hashCode(); 总结下来就是: -- 如果两个对象的`hashCode` 值相等,那这两个对象不一定相等(哈希碰撞)。 -- 如果两个对象的`hashCode` 值相等并且`equals()`方法也返回 `true`,我们才认为这两个对象相等。 -- 如果两个对象的`hashCode` 值不相等,我们就可以直接认为这两个对象不相等。 +- 如果两个对象的 `hashCode` 值相等,那这两个对象不一定相等(哈希碰撞)。 +- 如果两个对象的 `hashCode` 值相等并且 `equals()` 方法也返回 `true`,我们才认为这两个对象相等。 +- 如果两个对象的 `hashCode` 值不相等,我们就可以直接认为这两个对象不相等。 相信大家看了我前面对 `hashCode()` 和 `equals()` 的介绍之后,下面这个问题已经难不倒你们了。 @@ -599,7 +599,7 @@ public native int hashCode(); ## String -### ⭐️String、StringBuffer、StringBuilder 的区别? +### ⭐️ String、StringBuffer、StringBuilder 的区别? **可变性** @@ -644,9 +644,9 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence { - 单线程操作字符串缓冲区下操作大量数据: 适用 `StringBuilder` - 多线程操作字符串缓冲区下操作大量数据: 适用 `StringBuffer` -### ⭐️String 为什么是不可变的? +### ⭐️ String 为什么是不可变的? -`String` 类中使用 `final` 关键字修饰字符数组来保存字符串,~~所以`String` 对象是不可变的。~~ +`String` 类中使用 `final` 关键字修饰字符数组来保存字符串,~~所以 `String` 对象是不可变的。~~ ```java public final class String implements java.io.Serializable, Comparable, CharSequence { @@ -659,7 +659,7 @@ public final class String implements java.io.Serializable, Comparable, C > > `String` 真正不可变有下面几点原因: > -> 1. 保存字符串的数组被 `final` 修饰且为私有的,并且`String` 类没有提供/暴露修改这个字符串的方法。 +> 1. 保存字符串的数组被 `final` 修饰且为私有的,并且 `String` 类没有提供/暴露修改这个字符串的方法。 > 2. `String` 类被 `final` 修饰导致其不能被继承,进而避免了子类破坏 `String` 不可变。 > > 相关阅读:[如何理解 String 类型值的不可变? - 知乎提问](https://www.zhihu.com/question/20618891/answer/114125846) @@ -681,7 +681,7 @@ public final class String implements java.io.Serializable, Comparable, C > > **Java 9 为何要将 `String` 的底层实现由 `char[]` 改成了 `byte[]` ?** > -> 新版的 String 其实支持两个编码方案:Latin-1 和 UTF-16。如果字符串中包含的汉字没有超过 Latin-1 可表示范围内的字符,那就会使用 Latin-1 作为编码方案。Latin-1 编码方案下,`byte` 占一个字节(8 位),`char` 占用 2 个字节(16),`byte` 相较 `char` 节省一半的内存空间。 +> 新版的 String 其实支持两个编码方案:Latin-1 和 UTF-16。如果字符串中包含的汉字没有超过 Latin-1 可表示范围内的字符,那就会使用 Latin-1 作为编码方案。Latin-1 编码方案下,`byte` 占一个字节(8 位),`char` 占用 2 个字节(16),`byte` 相较 `char` 节省一半的内存空间。 > > JDK 官方就说了绝大部分字符串对象只包含 Latin-1 可表示的字符。 > @@ -689,9 +689,9 @@ public final class String implements java.io.Serializable, Comparable, C > > 如果字符串中包含的汉字超过 Latin-1 可表示范围内的字符,`byte` 和 `char` 所占用的空间是一样的。 > -> 这是官方的介绍: 。 +> 这是官方的介绍:。 -### ⭐️字符串拼接用“+” 还是 StringBuilder? +### ⭐️ 字符串拼接用“+” 还是 StringBuilder? Java 语言本身并不支持运算符重载,“+”和“+=”是专门为 String 类重载过的运算符,也是 Java 中仅有的两个重载过的运算符。 @@ -706,7 +706,7 @@ String str4 = str1 + str2 + str3; ![](https://oss.javaguide.cn/github/javaguide/java/image-20220422161637929.png) -可以看出,字符串对象通过“+”的字符串拼接方式,实际上是通过 `StringBuilder` 调用 `append()` 方法实现的,拼接完成之后调用 `toString()` 得到一个 `String` 对象 。 +可以看出,字符串对象通过“+”的字符串拼接方式,实际上是通过 `StringBuilder` 调用 `append()` 方法实现的,拼接完成之后调用 `toString()` 得到一个 `String` 对象。 不过,在循环内使用“+”进行字符串的拼接的话,存在比较明显的缺陷:**编译器不会创建单个 `StringBuilder` 以复用,会导致创建过多的 `StringBuilder` 对象**。 @@ -738,13 +738,13 @@ System.out.println(s); 如果你使用 IDEA 的话,IDEA 自带的代码检查机制也会提示你修改代码。 -在 JDK 9 中,字符串相加“+”改为用动态方法 `makeConcatWithConstants()` 来实现,通过提前分配空间从而减少了部分临时对象的创建。然而这种优化主要针对简单的字符串拼接,如: `a+b+c` 。对于循环中的大量拼接操作,仍然会逐个动态分配内存(类似于两个两个 append 的概念),并不如手动使用 StringBuilder 来进行拼接效率高。这个改进是 JDK9 的 [JEP 280](https://openjdk.org/jeps/280) 提出的,关于这部分改进的详细介绍,推荐阅读这篇文章:还在无脑用 [StringBuilder?来重温一下字符串拼接吧](https://juejin.cn/post/7182872058743750715) 以及参考 [issue#2442](https://github.com/Snailclimb/JavaGuide/issues/2442)。 +在 JDK 9 中,字符串相加“+”改为用动态方法 `makeConcatWithConstants()` 来实现,通过提前分配空间从而减少了部分临时对象的创建。然而这种优化主要针对简单的字符串拼接,如: `a+b+c`。对于循环中的大量拼接操作,仍然会逐个动态分配内存(类似于两个两个 append 的概念),并不如手动使用 StringBuilder 来进行拼接效率高。这个改进是 JDK9 的 [JEP 280](https://openjdk.org/jeps/280) 提出的,关于这部分改进的详细介绍,推荐阅读这篇文章:还在无脑用 [StringBuilder?来重温一下字符串拼接吧](https://juejin.cn/post/7182872058743750715) 以及参考 [issue#2442](https://github.com/Snailclimb/JavaGuide/issues/2442)。 ### String#equals() 和 Object#equals() 有何区别? `String` 中的 `equals` 方法是被重写过的,比较的是 String 字符串的值是否相等。 `Object` 的 `equals` 方法是比较的对象的内存地址。 -### ⭐️字符串常量池的作用了解吗? +### ⭐️ 字符串常量池的作用了解吗? **字符串常量池** 是 JVM 为了提升性能和减少内存消耗针对字符串(String 类)专门开辟的一块区域,主要目的是为了避免字符串的重复创建。 @@ -759,7 +759,7 @@ System.out.println(aa==bb); // true 更多关于字符串常量池的介绍可以看一下 [Java 内存区域详解](https://javaguide.cn/java/jvm/memory-area.html) 这篇文章。 -### ⭐️String s1 = new String("abc");这句话创建了几个字符串对象? +### ⭐️ String s1 = new String("abc");这句话创建了几个字符串对象? 先说答案:会创建 1 或 2 个字符串对象。 @@ -834,9 +834,9 @@ String s2 = new String("abc"); 这里就不对上面的字节码进行详细注释了,7 这个位置的 `ldc` 命令不会在堆中创建新的字符串对象“abc”,这是因为 0 这个位置已经执行了一次 `ldc` 命令,已经在堆中创建过一次字符串对象“abc”了。7 这个位置执行 `ldc` 命令会直接返回字符串常量池中字符串对象“abc”对应的引用。 -### String#intern 方法有什么作用? +### String#intern 方法有什么作用? -`String.intern()` 是一个 `native` (本地) 方法,用来处理字符串常量池中的字符串对象引用。它的工作流程可以概括为以下两种情况: +`String.intern()` 是一个 `native`(本地) 方法,用来处理字符串常量池中的字符串对象引用。它的工作流程可以概括为以下两种情况: 1. **常量池中已有相同内容的字符串对象**:如果字符串常量池中已经有一个与调用 `intern()` 方法的字符串内容相同的 `String` 对象,`intern()` 方法会直接返回常量池中该对象的引用。 2. **常量池中没有相同内容的字符串对象**:如果字符串常量池中还没有一个与调用 `intern()` 方法的字符串内容相同的对象,`intern()` 方法会将当前字符串对象的引用添加到字符串常量池中,并返回该引用。 @@ -884,25 +884,25 @@ System.out.println(str4 == str5);//false ![](https://oss.javaguide.cn/java-guide-blog/image-20210817123252441.png) -**对于编译期可以确定值的字符串,也就是常量字符串 ,jvm 会将其存入字符串常量池。并且,字符串常量拼接得到的字符串常量在编译阶段就已经被存放字符串常量池,这个得益于编译器的优化。** +**对于编译期可以确定值的字符串,也就是常量字符串,jvm 会将其存入字符串常量池。并且,字符串常量拼接得到的字符串常量在编译阶段就已经被存放字符串常量池,这个得益于编译器的优化。** 在编译过程中,Javac 编译器(下文中统称为编译器)会进行一个叫做 **常量折叠(Constant Folding)** 的代码优化。《深入理解 Java 虚拟机》中是也有介绍到: ![](https://oss.javaguide.cn/javaguide/image-20210817142715396.png) -常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中,这是 Javac 编译器会对源代码做的极少量优化措施之一(代码优化几乎都在即时编译器中进行)。 +常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中,这是 Javac 编译器会对源代码做的极少量优化措施之一(代码优化几乎都在即时编译器中进行)。 -对于 `String str3 = "str" + "ing";` 编译器会给你优化成 `String str3 = "string";` 。 +对于 `String str3 = "str" + "ing";` 编译器会给你优化成 `String str3 = "string";`。 并不是所有的常量都会进行折叠,只有编译器在程序编译期就可以确定值的常量才可以: - 基本数据类型( `byte`、`boolean`、`short`、`char`、`int`、`float`、`long`、`double`)以及字符串常量。 - `final` 修饰的基本数据类型和字符串变量 -- 字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算(加减乘除)、基本数据类型的位运算(<<、\>>、\>>> ) +- 字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算(加减乘除)、基本数据类型的位运算(<<、\>>、\>>>) **引用的值在程序编译期是无法确定的,编译器无法对其进行优化。** -对象引用和“+”的字符串拼接方式,实际上是通过 `StringBuilder` 调用 `append()` 方法实现的,拼接完成之后调用 `toString()` 得到一个 `String` 对象 。 +对象引用和“+”的字符串拼接方式,实际上是通过 `StringBuilder` 调用 `append()` 方法实现的,拼接完成之后调用 `toString()` 得到一个 `String` 对象。 ```java String str4 = new StringBuilder().append(str1).append(str2).toString(); @@ -925,7 +925,7 @@ System.out.println(c == d);// true 被 `final` 关键字修饰之后的 `String` 会被编译器当做常量来处理,编译器在程序编译期就可以确定它的值,其效果就相当于访问常量。 -如果 ,编译器在运行时才能知道其确切值的话,就无法对其优化。 +如果,编译器在运行时才能知道其确切值的话,就无法对其优化。 示例代码(`str2` 在运行时才能确定其值): diff --git a/docs/java/basis/java-basic-questions-03.md b/docs/java/basis/java-basic-questions-03.md index 1d4622484c2..8ab481931f3 100644 --- a/docs/java/basis/java-basic-questions-03.md +++ b/docs/java/basis/java-basic-questions-03.md @@ -20,36 +20,36 @@ head: 在 Java 中,所有的异常都有一个共同的祖先 `java.lang` 包中的 `Throwable` 类。`Throwable` 类有两个重要的子类: -- **`Exception`** :程序本身可以处理的异常,可以通过 `catch` 来进行捕获。`Exception` 又可以分为 Checked Exception (受检查异常,必须处理) 和 Unchecked Exception (不受检查异常,可以不处理)。 -- **`Error`** :`Error` 属于程序无法处理的错误 ,~~我们没办法通过 `catch` 来进行捕获~~不建议通过`catch`捕获 。例如 Java 虚拟机运行错误(`Virtual MachineError`)、虚拟机内存不够错误(`OutOfMemoryError`)、类定义错误(`NoClassDefFoundError`)等 。这些异常发生时,Java 虚拟机(JVM)一般会选择线程终止。 +- **`Exception`** :程序本身可以处理的异常,可以通过 `catch` 来进行捕获。`Exception` 又可以分为 Checked Exception(受检查异常,必须处理) 和 Unchecked Exception(不受检查异常,可以不处理)。 +- **`Error`**:`Error` 属于程序无法处理的错误,~~我们没办法通过 `catch` 来进行捕获~~不建议通过 `catch` 捕获。例如 Java 虚拟机运行错误(`Virtual MachineError`)、虚拟机内存不够错误(`OutOfMemoryError`)、类定义错误(`NoClassDefFoundError`)等。这些异常发生时,Java 虚拟机(JVM)一般会选择线程终止。 ### ClassNotFoundException 和 NoClassDefFoundError 的区别 -- `ClassNotFoundException` 是Exception,发生在使用反射等动态加载时找不到类,是可预期的,可以捕获处理。 -- `NoClassDefFoundError` 是Error,是编译时存在的类,在运行时链接不到了(比如 jar 包缺失),是环境问题,导致 JVM 无法继续。 +- `ClassNotFoundException` 是 Exception,发生在使用反射等动态加载时找不到类,是可预期的,可以捕获处理。 +- `NoClassDefFoundError` 是 Error,是编译时存在的类,在运行时链接不到了(比如 jar 包缺失),是环境问题,导致 JVM 无法继续。 -### ⭐️Checked Exception 和 Unchecked Exception 有什么区别? +### ⭐️ Checked Exception 和 Unchecked Exception 有什么区别? -**Checked Exception** 即 受检查异常 ,Java 代码在编译过程中,如果受检查异常没有被 `catch`或者`throws` 关键字处理的话,就没办法通过编译。 +**Checked Exception** 即 受检查异常,Java 代码在编译过程中,如果受检查异常没有被 `catch` 或者 `throws` 关键字处理的话,就没办法通过编译。 比如下面这段 IO 操作的代码: ![](https://oss.javaguide.cn/github/javaguide/java/basis/checked-exception.png) -除了`RuntimeException`及其子类以外,其他的`Exception`类及其子类都属于受检查异常 。常见的受检查异常有:IO 相关的异常、`ClassNotFoundException`、`SQLException`...。 +除了 `RuntimeException` 及其子类以外,其他的 `Exception` 类及其子类都属于受检查异常。常见的受检查异常有:IO 相关的异常、`ClassNotFoundException`、`SQLException`...。 -**Unchecked Exception** 即 **不受检查异常** ,Java 代码在编译过程中 ,我们即使不处理不受检查异常也可以正常通过编译。 +**Unchecked Exception** 即 **不受检查异常**,Java 代码在编译过程中,我们即使不处理不受检查异常也可以正常通过编译。 `RuntimeException` 及其子类都统称为非受检查异常,常见的有(建议记下来,日常开发中会经常用到): -- `NullPointerException`(空指针错误) -- `IllegalArgumentException`(参数错误比如方法入参类型错误) -- `NumberFormatException`(字符串转换为数字格式错误,`IllegalArgumentException`的子类) +- `NullPointerException`(空指针错误) +- `IllegalArgumentException`(参数错误比如方法入参类型错误) +- `NumberFormatException`(字符串转换为数字格式错误,`IllegalArgumentException` 的子类) - `ArrayIndexOutOfBoundsException`(数组越界错误) - `ClassCastException`(类型转换错误) - `ArithmeticException`(算术错误) -- `SecurityException` (安全错误比如权限不够) -- `UnsupportedOperationException`(不支持的操作错误比如重复创建同一用户) +- `SecurityException`(安全错误比如权限不够) +- `UnsupportedOperationException`(不支持的操作错误比如重复创建同一用户) - …… ![](https://oss.javaguide.cn/github/javaguide/java/basis/unchecked-exception.png) @@ -66,13 +66,13 @@ head: - `String getMessage()`: 返回异常发生时的详细信息 - `String toString()`: 返回异常发生时的简要描述 -- `String getLocalizedMessage()`: 返回异常对象的本地化信息。使用 `Throwable` 的子类覆盖这个方法,可以生成本地化信息。如果子类没有覆盖该方法,则该方法返回的信息与 `getMessage()`返回的结果相同 +- `String getLocalizedMessage()`: 返回异常对象的本地化信息。使用 `Throwable` 的子类覆盖这个方法,可以生成本地化信息。如果子类没有覆盖该方法,则该方法返回的信息与 `getMessage()` 返回的结果相同 - `void printStackTrace()`: 在控制台上打印 `Throwable` 对象封装的异常信息 ### try-catch-finally 如何使用? -- `try`块:用于捕获异常。其后可接零个或多个 `catch` 块,如果没有 `catch` 块,则必须跟一个 `finally` 块。 -- `catch`块:用于处理 try 捕获到的异常。 +- `try` 块:用于捕获异常。其后可接零个或多个 `catch` 块,如果没有 `catch` 块,则必须跟一个 `finally` 块。 +- `catch` 块:用于处理 try 捕获到的异常。 - `finally` 块:无论是否捕获或处理异常,`finally` 块里的语句都会被执行。当在 `try` 块或 `catch` 块中遇到 `return` 语句时,`finally` 语句块将在方法返回之前被执行。 代码示例: @@ -155,18 +155,18 @@ Catch Exception -> RuntimeException 相关 issue:。 -🧗🏻 进阶一下:从字节码角度分析`try catch finally`这个语法糖背后的实现原理。 +🧗🏻 进阶一下:从字节码角度分析 `try catch finally` 这个语法糖背后的实现原理。 -### 如何使用 `try-with-resources` 代替`try-catch-finally`? +### 如何使用 `try-with-resources` 代替 `try-catch-finally`? -1. **适用范围(资源的定义):** 任何实现 `java.lang.AutoCloseable`或者 `java.io.Closeable` 的对象 +1. **适用范围(资源的定义):** 任何实现 `java.lang.AutoCloseable` 或者 `java.io.Closeable` 的对象 2. **关闭资源和 finally 块的执行顺序:** 在 `try-with-resources` 语句中,任何 catch 或 finally 块在声明的资源关闭后运行 《Effective Java》中明确指出: -> 面对必须要关闭的资源,我们总是应该优先使用 `try-with-resources` 而不是`try-finally`。随之产生的代码更简短,更清晰,产生的异常对我们也更有用。`try-with-resources`语句让我们更容易编写必须要关闭的资源的代码,若采用`try-finally`则几乎做不到这点。 +> 面对必须要关闭的资源,我们总是应该优先使用 `try-with-resources` 而不是 `try-finally`。随之产生的代码更简短,更清晰,产生的异常对我们也更有用。`try-with-resources` 语句让我们更容易编写必须要关闭的资源的代码,若采用 `try-finally` 则几乎做不到这点。 -Java 中类似于`InputStream`、`OutputStream`、`Scanner`、`PrintWriter`等的资源都需要我们调用`close()`方法来手动关闭,一般情况下我们都是通过`try-catch-finally`语句来实现这个需求,如下: +Java 中类似于 `InputStream`、`OutputStream`、`Scanner`、`PrintWriter` 等的资源都需要我们调用 `close()` 方法来手动关闭,一般情况下我们都是通过 `try-catch-finally` 语句来实现这个需求,如下: ```java //读取文本文件的内容 @@ -197,9 +197,9 @@ try (Scanner scanner = new Scanner(new File("test.txt"))) { } ``` -当然多个资源需要关闭的时候,使用 `try-with-resources` 实现起来也非常简单,如果你还是用`try-catch-finally`可能会带来很多问题。 +当然多个资源需要关闭的时候,使用 `try-with-resources` 实现起来也非常简单,如果你还是用 `try-catch-finally` 可能会带来很多问题。 -通过使用分号分隔,可以在`try-with-resources`块中声明多个资源。 +通过使用分号分隔,可以在 `try-with-resources` 块中声明多个资源。 ```java try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt"))); @@ -214,11 +214,11 @@ catch (IOException e) { } ``` -### ⭐️异常使用有哪些需要注意的地方? +### ⭐️ 异常使用有哪些需要注意的地方? - 不要把异常定义为静态变量,因为这样会导致异常栈信息错乱。每次手动抛出异常,我们都需要手动 new 一个异常对象抛出。 - 抛出的异常信息一定要有意义。 -- 建议抛出更加具体的异常,比如字符串转换为数字格式错误的时候应该抛出`NumberFormatException`而不是其父类`IllegalArgumentException`。 +- 建议抛出更加具体的异常,比如字符串转换为数字格式错误的时候应该抛出 `NumberFormatException` 而不是其父类 `IllegalArgumentException`。 - 避免重复记录日志:如果在捕获异常的地方已经记录了足够的信息(包括异常类型、错误信息和堆栈跟踪等),那么在业务代码中再次抛出这个异常时,就不应该再次记录相同的错误信息。重复记录日志会使得日志文件膨胀,并且可能会掩盖问题的实际原因,使得问题更难以追踪和解决。 - …… @@ -234,7 +234,7 @@ catch (IOException e) { ArrayList extends AbstractList ``` -并且,原生 `List` 返回类型是 `Object` ,需要手动转换类型才能使用,使用泛型后编译器自动转换。 +并且,原生 `List` 返回类型是 `Object`,需要手动转换类型才能使用,使用泛型后编译器自动转换。 ### 泛型的使用方式有哪几种? @@ -317,7 +317,7 @@ printArray( intArray ); printArray( stringArray ); ``` -> 注意: `public static < E > void printArray( E[] inputArray )` 一般被称为静态泛型方法;在 java 中泛型只是一个占位符,必须在传递类型后才能使用。类在实例化时才能真正的传递类型参数,由于静态方法的加载先于类的实例化,也就是说类中的泛型还没有传递真正的类型参数,静态的方法的加载就已经完成了,所以静态泛型方法是没有办法使用类上声明的泛型的。只能使用自己声明的 `` +> 注意: `public static < E > void printArray( E[] inputArray )` 一般被称为静态泛型方法;在 java 中泛型只是一个占位符,必须在传递类型后才能使用。类在实例化时才能真正的传递类型参数,由于静态方法的加载先于类的实例化,也就是说类中的泛型还没有传递真正的类型参数,静态的方法的加载就已经完成了,所以静态泛型方法是没有办法使用类上声明的泛型的。只能使用自己声明的 `` ### 项目中哪里用到了泛型? @@ -326,9 +326,9 @@ printArray( stringArray ); - 构建集合工具类(参考 `Collections` 中的 `sort`, `binarySearch` 方法)。 - …… -## ⭐️反射 +## ⭐️ 反射 -关于反射的详细解读,请看这篇文章 [Java 反射机制详解](https://javaguide.cn/java/basis/reflection.html) 。 +关于反射的详细解读,请看这篇文章 [Java 反射机制详解](https://javaguide.cn/java/basis/reflection.html)。 ### 什么是反射? @@ -351,7 +351,7 @@ printArray( stringArray ); 2. **安全性问题**:反射可以绕过 Java 语言的访问控制机制(如访问 `private` 字段和方法),破坏了封装性,可能导致数据泄露或程序被恶意篡改。此外,还可以绕过泛型检查,带来类型安全隐患。 3. **代码可读性和维护性**:过度使用反射会使代码变得复杂、难以理解和调试。错误通常在运行时才会暴露,不像编译期错误那样容易发现。 -相关阅读:[Java Reflection: Why is it so slow?](https://stackoverflow.com/questions/1392351/java-reflection-why-is-it-so-slow) 。 +相关阅读:[Java Reflection: Why is it so slow?](https://stackoverflow.com/questions/1392351/java-reflection-why-is-it-so-slow)。 ### 反射的应用场景? @@ -416,7 +416,7 @@ CGLIB 是一个第三方的代码生成库。它的原理与 JDK 完全不同, ### 静态代理和动态代理有什么区别? -静态代理和动态代理的核心差异在于 **代理关系的确定时机、实现灵活性及维护成本** 。 +静态代理和动态代理的核心差异在于 **代理关系的确定时机、实现灵活性及维护成本**。 | 对比维度 | 静态代理 (Static Proxy) | 动态代理 (Dynamic Proxy) | | ---------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | @@ -427,16 +427,16 @@ CGLIB 是一个第三方的代码生成库。它的原理与 JDK 完全不同, | 核心优势 | 实现简单、逻辑直观,无额外框架依赖 | 灵活性强、复用性高,降低重复编码,适配复杂场景 | | 典型应用场景 | 简单的装饰器模式、少量固定类的增强需求 | Spring AOP、RPC 框架(如 Dubbo)、ORM 框架 | -### ⭐️JDK 动态代理和 CGLIB 动态代理有什么区别? +### ⭐️ JDK 动态代理和 CGLIB 动态代理有什么区别? -1. JDK 动态代理是官方的,它要求被代理的类必须实现接口。它的原理是动态生成一个接口的实现类来作为代理。CGLIB 是第三方的,它不需要接口。它的原理是动态生成一个被代理类的子类来作为代理。但也正因为是继承,所以它不能代理 `final` 的类,被代理的方法也不能是 `final` 或 `private` 。 +1. JDK 动态代理是官方的,它要求被代理的类必须实现接口。它的原理是动态生成一个接口的实现类来作为代理。CGLIB 是第三方的,它不需要接口。它的原理是动态生成一个被代理类的子类来作为代理。但也正因为是继承,所以它不能代理 `final` 的类,被代理的方法也不能是 `final` 或 `private`。 2. 就二者的效率来说,大部分情况都是 JDK 动态代理更优秀,随着 JDK 版本的升级,这个优势更加明显。 -### ⭐️介绍一下动态代理在框架中的实际应用场景 +### ⭐️ 介绍一下动态代理在框架中的实际应用场景 动态代理最典型的应用场景就是**Spring AOP**。 -AOP(Aspect-Oriented Programming:面向切面编程)能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。 +AOP(Aspect-Oriented Programming:面向切面编程)能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。 Spring AOP 就是基于动态代理的,如果要代理的对象,实现了某个接口,那么 Spring AOP 会使用 **JDK Proxy**,去创建代理对象,而对于没有实现接口的对象,就无法使用 JDK Proxy 去进行代理了,这时候 Spring AOP 会使用 **Cglib** 生成一个被代理对象的子类来作为代理,如下图所示: @@ -446,9 +446,9 @@ Spring AOP 就是基于动态代理的,如果要代理的对象,实现了某 ### 何谓注解? -`Annotation` (注解) 是 Java5 开始引入的新特性,可以看作是一种特殊的注释,主要用于修饰类、方法或者变量,提供某些信息供程序在编译或者运行时使用。 +`Annotation`(注解) 是 Java5 开始引入的新特性,可以看作是一种特殊的注释,主要用于修饰类、方法或者变量,提供某些信息供程序在编译或者运行时使用。 -注解本质是一个继承了`Annotation` 的特殊接口: +注解本质是一个继承了 `Annotation` 的特殊接口: ```java @Target(ElementType.METHOD) @@ -468,16 +468,16 @@ JDK 提供了很多内置的注解(比如 `@Override`、`@Deprecated`),同 注解只有被解析之后才会生效,常见的解析方法有两种: -- **编译期直接扫描**:编译器在编译 Java 代码的时候扫描对应的注解并处理,比如某个方法使用`@Override` 注解,编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。 +- **编译期直接扫描**:编译器在编译 Java 代码的时候扫描对应的注解并处理,比如某个方法使用 `@Override` 注解,编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。 - **运行期通过反射处理**:像框架中自带的注解(比如 Spring 框架的 `@Value`、`@Component`)都是通过反射来进行处理的。 -## ⭐️SPI +## ⭐️ SPI -关于 SPI 的详细解读,请看这篇文章 [Java SPI 机制详解](https://javaguide.cn/java/basis/spi.html) 。 +关于 SPI 的详细解读,请看这篇文章 [Java SPI 机制详解](https://javaguide.cn/java/basis/spi.html)。 ### 何谓 SPI? -SPI 即 Service Provider Interface ,字面意思就是:“服务提供者的接口”,我的理解是:专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。 +SPI 即 Service Provider Interface,字面意思就是:“服务提供者的接口”,我的理解是:专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。 SPI 将服务接口和具体的服务实现分离开来,将服务调用方和服务实现者解耦,能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。 @@ -496,7 +496,7 @@ SPI 将服务接口和具体的服务实现分离开来,将服务调用方和 一般模块之间都是通过接口进行通讯,因此我们在服务调用方和服务实现方(也称服务提供者)之间引入一个“接口”。 - 当实现方提供了接口和实现,我们可以通过调用实现方的接口从而拥有实现方给我们提供的能力,这就是 **API**。这种情况下,接口和实现都是放在实现方的包中。调用方通过接口调用实现方的功能,而不需要关心具体的实现细节。 -- 当接口存在于调用方这边时,这就是 **SPI** 。由接口调用方确定接口规则,然后由不同的厂商根据这个规则对这个接口进行实现,从而提供服务。 +- 当接口存在于调用方这边时,这就是 **SPI**。由接口调用方确定接口规则,然后由不同的厂商根据这个规则对这个接口进行实现,从而提供服务。 举个通俗易懂的例子:公司 H 是一家科技公司,新设计了一款芯片,然后现在需要量产了,而市面上有好几家芯片制造业公司,这个时候,只要 H 公司指定好了这芯片生产的标准(定义好了接口标准),那么这些合作的芯片公司(服务提供者)就按照标准交付自家特色的芯片(提供不同方案的实现,但是给出来的结果是一样的)。 @@ -507,11 +507,11 @@ SPI 将服务接口和具体的服务实现分离开来,将服务调用方和 - 需要遍历加载所有的实现类,不能做到按需加载,这样效率还是相对较低的。 - 当多个 `ServiceLoader` 同时 `load` 时,会有并发问题。 -## ⭐️序列化和反序列化 +## ⭐️ 序列化和反序列化 -关于序列化和反序列化的详细解读,请看这篇文章 [Java 序列化详解](https://javaguide.cn/java/basis/serialization.html) ,里面涉及到的知识点和面试题更全面。 +关于序列化和反序列化的详细解读,请看这篇文章 [Java 序列化详解](https://javaguide.cn/java/basis/serialization.html),里面涉及到的知识点和面试题更全面。 -### 什么是序列化?什么是反序列化? +### 什么是序列化?什么是反序列化? 如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中,或者在网络传输 Java 对象,这些场景都需要用到序列化。 @@ -520,7 +520,7 @@ SPI 将服务接口和具体的服务实现分离开来,将服务调用方和 - **序列化**:将数据结构或对象转换成可以存储或传输的形式,通常是二进制字节流,也可以是 JSON, XML 等文本格式 - **反序列化**:将在序列化过程中所生成的数据转换为原始数据结构或者对象的过程 -对于 Java 这种面向对象编程语言来说,我们序列化的都是对象(Object)也就是实例化后的类(Class),但是在 C++这种半面向对象的语言中,struct(结构体)定义的是数据结构类型,而 class 对应的是对象类型。 +对于 Java 这种面向对象编程语言来说,我们序列化的都是对象(Object)也就是实例化后的类(Class),但是在 C++这种半面向对象的语言中,struct(结构体)定义的是数据结构类型,而 class 对应的是对象类型。 下面是序列化和反序列化常见应用场景: @@ -568,7 +568,7 @@ SPI 将服务接口和具体的服务实现分离开来,将服务调用方和 ### 常见序列化协议有哪些? -JDK 自带的序列化方式一般不会用 ,因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff,这些都是基于二进制的序列化协议。 +JDK 自带的序列化方式一般不会用,因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff,这些都是基于二进制的序列化协议。 像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好,但是性能较差,一般不会选择。 @@ -578,7 +578,7 @@ JDK 自带的序列化方式一般不会用 ,因为序列化效率低并且存 - **不支持跨语言调用** : 如果调用的是其他语言开发的服务的时候就不支持了。 - **性能差**:相比于其他序列化框架性能更低,主要原因是序列化之后的字节数组体积较大,导致传输成本加大。 -- **存在安全问题**:序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制,那么攻击者即可通过构造恶意输入,让反序列化产生非预期的对象,在此过程中执行构造的任意代码。相关阅读:[应用安全:JAVA 反序列化漏洞之殇](https://cryin.github.io/blog/secure-development-java-deserialization-vulnerability/) 。 +- **存在安全问题**:序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制,那么攻击者即可通过构造恶意输入,让反序列化产生非预期的对象,在此过程中执行构造的任意代码。相关阅读:[应用安全:JAVA 反序列化漏洞之殇](https://cryin.github.io/blog/secure-development-java-deserialization-vulnerability/)。 ## I/O @@ -597,7 +597,7 @@ Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来 - `InputStream`/`Reader`: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。 - `OutputStream`/`Writer`: 所有输出流的基类,前者是字节输出流,后者是字符输出流。 -### I/O 流为什么要分为字节流和字符流呢? +### I/O 流为什么要分为字节流和字符流呢? 问题本质想问:**不管是文件读写还是网络发送接收,信息的最小存储单元都是字节,那为什么 I/O 流操作要分为字节流操作和字符流操作呢?** @@ -610,7 +610,7 @@ Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来 参考答案:[Java IO 设计模式总结](https://javaguide.cn/java/io/io-design-patterns.html) -### ⭐️BIO、NIO 和 AIO 的区别? +### ⭐️ BIO、NIO 和 AIO 的区别? 参考答案:[Java IO 模型详解](https://javaguide.cn/java/io/io-model.html) @@ -629,12 +629,12 @@ for (String s : strs) { } ``` -不过,JVM 其实并不能识别语法糖,Java 语法糖要想被正确执行,需要先通过编译器进行解糖,也就是在程序编译阶段将其转换成 JVM 认识的基本语法。这也侧面说明,Java 中真正支持语法糖的是 Java 编译器而不是 JVM。如果你去看`com.sun.tools.javac.main.JavaCompiler`的源码,你会发现在`compile()`中有一个步骤就是调用`desugar()`,这个方法就是负责解语法糖的实现的。 +不过,JVM 其实并不能识别语法糖,Java 语法糖要想被正确执行,需要先通过编译器进行解糖,也就是在程序编译阶段将其转换成 JVM 认识的基本语法。这也侧面说明,Java 中真正支持语法糖的是 Java 编译器而不是 JVM。如果你去看 `com.sun.tools.javac.main.JavaCompiler` 的源码,你会发现在 `compile()` 中有一个步骤就是调用 `desugar()`,这个方法就是负责解语法糖的实现的。 ### Java 中有哪些常见的语法糖? Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等。 -关于这些语法糖的详细解读,请看这篇文章 [Java 语法糖详解](./syntactic-sugar.md) 。 +关于这些语法糖的详细解读,请看这篇文章 [Java 语法糖详解](./syntactic-sugar.md)。 diff --git a/docs/java/basis/java-keyword-summary.md b/docs/java/basis/java-keyword-summary.md index fc53950e5e7..edea0842938 100644 --- a/docs/java/basis/java-keyword-summary.md +++ b/docs/java/basis/java-keyword-summary.md @@ -14,7 +14,7 @@ head: ## final 关键字 -**final 关键字,意思是最终的、不可修改的,最见不得变化 ,用来修饰类、方法和变量,具有以下特点:** +**final 关键字,意思是最终的、不可修改的,最见不得变化,用来修饰类、方法和变量,具有以下特点:** 1. final 修饰的类不能被继承,final 类中的所有成员方法都会被隐式的指定为 final 方法; @@ -32,9 +32,9 @@ head: **static 关键字主要有以下四种使用场景:** 1. **修饰成员变量和成员方法:** 被 static 修饰的成员属于类,不属于单个这个类的某个对象,被类中所有对象共享,可以并且建议通过类名调用。被 static 声明的成员变量属于静态成员变量,静态变量 存放在 Java 内存区域的方法区。调用格式:`类名.静态变量名` `类名.静态方法名()` -2. **静态代码块:** 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象,静态代码块只执行一次. +2. **静态代码块:** 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象,静态代码块只执行一次. 3. **静态内部类(static 修饰类的话只能修饰内部类):** 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用,该引用是指向创建它的外围类,但是静态内部类却没有。没有这个引用就意味着:1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非 static 成员变量和方法。 -4. **静态导包(用来导入类中的静态资源,1.5 之后的新特性):** 格式为:`import static` 这两个关键字连用可以指定导入某个类中的指定静态资源,并且不需要使用类名调用类中静态成员,可以直接使用类中静态成员变量和成员方法。 +4. **静态导包(用来导入类中的静态资源,1.5 之后的新特性):** 格式为:`import static` 这两个关键字连用可以指定导入某个类中的指定静态资源,并且不需要使用类名调用类中静态成员,可以直接使用类中静态成员变量和成员方法。 ## this 关键字 @@ -100,10 +100,10 @@ public class Sub extends Super { 1. 修饰成员变量和成员方法 2. 静态代码块 -3. 修饰类(只能修饰内部类) -4. 静态导包(用来导入类中的静态资源,1.5 之后的新特性) +3. 修饰类(只能修饰内部类) +4. 静态导包(用来导入类中的静态资源,1.5 之后的新特性) -### 修饰成员变量和成员方法(常用) +### 修饰成员变量和成员方法(常用) 被 static 修饰的成员属于类,不属于单个这个类的某个对象,被类中所有对象共享,可以并且建议通过类名调用。被 static 声明的成员变量属于静态成员变量,静态变量 存放在 Java 内存区域的方法区。 @@ -158,7 +158,7 @@ public class StaticDemo { ### 静态代码块 -静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块 —> 非静态代码块 —> 构造方法)。 该类不管创建多少对象,静态代码块只执行一次. +静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块 —> 非静态代码块 —> 构造方法)。 该类不管创建多少对象,静态代码块只执行一次. 静态代码块的格式是 @@ -198,7 +198,7 @@ public class Singleton { } ``` -当 Singleton 类加载时,静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()`方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载,此时初始化 INSTANCE 实例,并且 JVM 能确保 INSTANCE 只被实例化一次。 +当 Singleton 类加载时,静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载,此时初始化 INSTANCE 实例,并且 JVM 能确保 INSTANCE 只被实例化一次。 这种方式不仅具有延迟初始化的好处,而且由 JVM 提供了对线程安全的支持。 @@ -255,14 +255,14 @@ bar.method2(); - 在外部调用静态方法时,可以使用“类名.方法名”的方式,也可以使用“对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。 - 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制 -### `static{}`静态代码块与`{}`非静态代码块(构造代码块) +### `static{}` 静态代码块与 `{}` 非静态代码块(构造代码块) 相同点:都是在 JVM 加载类时且在构造方法执行之前执行,在类中都可以定义多个,定义多个时按定义的顺序执行,一般在代码块中对一些 static 变量进行赋值。 -不同点:静态代码块在非静态代码块之前执行(静态代码块 -> 非静态代码块 -> 构造方法)。静态代码块只在第一次 new 执行一次,之后不再执行,而非静态代码块在每 new 一次就执行一次。 非静态代码块可在普通方法中定义(不过作用不大);而静态代码块不行。 +不同点:静态代码块在非静态代码块之前执行(静态代码块 -> 非静态代码块 -> 构造方法)。静态代码块只在第一次 new 执行一次,之后不再执行,而非静态代码块在每 new 一次就执行一次。 非静态代码块可在普通方法中定义(不过作用不大);而静态代码块不行。 -> **🐛 修正(参见:[issue #677](https://github.com/Snailclimb/JavaGuide/issues/677))**:静态代码块可能在第一次 new 对象的时候执行,但不一定只在第一次 new 的时候执行。比如通过 `Class.forName("ClassDemo")`创建 Class 对象的时候也会执行,即 new 或者 `Class.forName("ClassDemo")` 都会执行静态代码块。 -> 一般情况下,如果有些代码比如一些项目最常用的变量或对象必须在项目启动的时候就执行,需要使用静态代码块,这种代码是主动执行的。如果我们想要设计不需要创建对象就可以调用类中的方法,例如:`Arrays` 类,`Character` 类,`String` 类等,就需要使用静态方法, 两者的区别是 静态代码块是自动执行的而静态方法是被调用的时候才执行的. +> **🐛 修正(参见:[issue #677](https://github.com/Snailclimb/JavaGuide/issues/677))**:静态代码块可能在第一次 new 对象的时候执行,但不一定只在第一次 new 的时候执行。比如通过 `Class.forName("ClassDemo")` 创建 Class 对象的时候也会执行,即 new 或者 `Class.forName("ClassDemo")` 都会执行静态代码块。 +> 一般情况下,如果有些代码比如一些项目最常用的变量或对象必须在项目启动的时候就执行,需要使用静态代码块,这种代码是主动执行的。如果我们想要设计不需要创建对象就可以调用类中的方法,例如:`Arrays` 类,`Character` 类,`String` 类等,就需要使用静态方法, 两者的区别是 静态代码块是自动执行的而静态方法是被调用的时候才执行的. Example: diff --git a/docs/java/basis/proxy.md b/docs/java/basis/proxy.md index 1882d0f8c4e..19ab0b0fe79 100644 --- a/docs/java/basis/proxy.md +++ b/docs/java/basis/proxy.md @@ -100,11 +100,11 @@ send message:java after method send() ``` -可以输出结果看出,我们已经增加了 `SmsServiceImpl` 的`send()`方法。 +可以输出结果看出,我们已经增加了 `SmsServiceImpl` 的 `send()` 方法。 ## 3. 动态代理 -相比于静态代理来说,动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类,并且也不需要我们必须实现接口,我们可以直接代理实现类( CGLIB 动态代理机制)。 +相比于静态代理来说,动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类,并且也不需要我们必须实现接口,我们可以直接代理实现类(CGLIB 动态代理机制)。 **从 JVM 角度来说,动态代理是在运行时动态生成类字节码,并加载到 JVM 中的。** @@ -116,7 +116,7 @@ after method send() [guide-rpc-framework](https://github.com/Snailclimb/guide-rpc-framework) 使用的是 JDK 动态代理,我们先来看看 JDK 动态代理的使用。 -另外,虽然 [guide-rpc-framework](https://github.com/Snailclimb/guide-rpc-framework) 没有用到 **CGLIB 动态代理** ,我们这里还是简单介绍一下其使用以及和**JDK 动态代理**的对比。 +另外,虽然 [guide-rpc-framework](https://github.com/Snailclimb/guide-rpc-framework) 没有用到 **CGLIB 动态代理**,我们这里还是简单介绍一下其使用以及和**JDK 动态代理**的对比。 ### 3.1. JDK 动态代理机制 @@ -124,7 +124,7 @@ after method send() **在 Java 动态代理机制中 `InvocationHandler` 接口和 `Proxy` 类是核心。** -`Proxy` 类中使用频率最高的方法是:`newProxyInstance()` ,这个方法主要用来生成一个代理对象。 +`Proxy` 类中使用频率最高的方法是:`newProxyInstance()`,这个方法主要用来生成一个代理对象。 ```java public static Object newProxyInstance(ClassLoader loader, @@ -142,7 +142,7 @@ after method send() 2. **interfaces** : 被代理类实现的一些接口; 3. **h** : 实现了 `InvocationHandler` 接口的对象; -要实现动态代理的话,还必须需要实现`InvocationHandler` 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时,这个方法的调用就会被转发到实现`InvocationHandler` 接口类的 `invoke` 方法来调用。 +要实现动态代理的话,还必须需要实现 `InvocationHandler` 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时,这个方法的调用就会被转发到实现 `InvocationHandler` 接口类的 `invoke` 方法来调用。 ```java public interface InvocationHandler { @@ -161,12 +161,12 @@ public interface InvocationHandler { 2. **method** : 与代理类对象调用的方法相对应 3. **args** : 当前 method 方法的参数 -也就是说:**你通过`Proxy` 类的 `newProxyInstance()` 创建的代理对象在调用方法的时候,实际会调用到实现`InvocationHandler` 接口的类的 `invoke()`方法。** 你可以在 `invoke()` 方法中自定义处理逻辑,比如在方法执行前后做什么事情。 +也就是说:**你通过 `Proxy` 类的 `newProxyInstance()` 创建的代理对象在调用方法的时候,实际会调用到实现 `InvocationHandler` 接口的类的 `invoke()` 方法。** 你可以在 `invoke()` 方法中自定义处理逻辑,比如在方法执行前后做什么事情。 #### 3.1.2. JDK 动态代理类使用步骤 1. 定义一个接口及其实现类; -2. 自定义 `InvocationHandler` 并重写`invoke`方法,在 `invoke` 方法中我们会调用原生方法(被代理类的方法)并自定义一些处理逻辑; +2. 自定义 `InvocationHandler` 并重写 `invoke` 方法,在 `invoke` 方法中我们会调用原生方法(被代理类的方法)并自定义一些处理逻辑; 3. 通过 `Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)` 方法创建代理对象; #### 3.1.3. 代码示例 @@ -242,7 +242,7 @@ public class JdkProxyFactory { } ``` -`getProxy()`:主要通过`Proxy.newProxyInstance()`方法获取某个类的代理对象 +`getProxy()`:主要通过 `Proxy.newProxyInstance()` 方法获取某个类的代理对象 **5.实际使用** @@ -287,13 +287,13 @@ extends Callback{ 3. **args** : 方法入参 4. **proxy** : 用于调用原始方法 -你可以通过 `Enhancer`类来动态获取被代理类,当代理类调用方法的时候,实际调用的是 `MethodInterceptor` 中的 `intercept` 方法。 +你可以通过 `Enhancer` 类来动态获取被代理类,当代理类调用方法的时候,实际调用的是 `MethodInterceptor` 中的 `intercept` 方法。 #### 3.2.2. CGLIB 动态代理类使用步骤 1. 定义一个类; 2. 自定义 `MethodInterceptor` 并重写 `intercept` 方法,`intercept` 用于拦截增强被代理类的方法,和 JDK 动态代理中的 `invoke` 方法类似; -3. 通过 `Enhancer` 类的 `create()`创建代理类; +3. 通过 `Enhancer` 类的 `create()` 创建代理类; #### 3.2.3. 代码示例 @@ -392,12 +392,12 @@ after method send ### 3.3. JDK 动态代理和 CGLIB 动态代理对比 -1. JDK 动态代理是官方的,它要求被代理的类必须实现接口。它的原理是动态生成一个接口的实现类来作为代理。CGLIB 是第三方的,它不需要接口。它的原理是动态生成一个被代理类的子类来作为代理。但也正因为是继承,所以它不能代理 `final` 的类,被代理的方法也不能是 `final` 或 `private` 。 +1. JDK 动态代理是官方的,它要求被代理的类必须实现接口。它的原理是动态生成一个接口的实现类来作为代理。CGLIB 是第三方的,它不需要接口。它的原理是动态生成一个被代理类的子类来作为代理。但也正因为是继承,所以它不能代理 `final` 的类,被代理的方法也不能是 `final` 或 `private`。 2. 就二者的效率来说,大部分情况都是 JDK 动态代理更优秀,随着 JDK 版本的升级,这个优势更加明显。 ## 4. 静态代理和动态代理的对比 -静态代理和动态代理的核心差异在于 **代理关系的确定时机、实现灵活性及维护成本** 。 +静态代理和动态代理的核心差异在于 **代理关系的确定时机、实现灵活性及维护成本**。 | 对比维度 | 静态代理 (Static Proxy) | 动态代理 (Dynamic Proxy) | | ---------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | @@ -412,6 +412,6 @@ after method send 这篇文章中主要介绍了代理模式的两种实现:静态代理以及动态代理。涵盖了静态代理和动态代理实战、静态代理和动态代理的区别、JDK 动态代理和 Cglib 动态代理区别等内容。 -文中涉及到的所有源码,你可以在这里找到:[https://github.com/Snailclimb/guide-rpc-framework-learning/tree/master/src/main/java/github/javaguide/proxy](https://github.com/Snailclimb/guide-rpc-framework-learning/tree/master/src/main/java/github/javaguide/proxy) 。 +文中涉及到的所有源码,你可以在这里找到:[https://github.com/Snailclimb/guide-rpc-framework-learning/tree/master/src/main/java/github/javaguide/proxy](https://github.com/Snailclimb/guide-rpc-framework-learning/tree/master/src/main/java/github/javaguide/proxy)。 diff --git a/docs/java/basis/reflection.md b/docs/java/basis/reflection.md index c4a233e908f..3948a4793e6 100644 --- a/docs/java/basis/reflection.md +++ b/docs/java/basis/reflection.md @@ -52,7 +52,7 @@ public class DebugInvocationHandler implements InvocationHandler { 另外,像 Java 中的一大利器 **注解** 的实现也用到了反射。 -为什么你使用 Spring 的时候 ,一个`@Component`注解就声明了一个类为 Spring Bean 呢?为什么你通过一个 `@Value`注解就读取到配置文件中的值呢?究竟是怎么起作用的呢? +为什么你使用 Spring 的时候,一个 `@Component` 注解就声明了一个类为 Spring Bean 呢?为什么你通过一个 `@Value` 注解就读取到配置文件中的值呢?究竟是怎么起作用的呢? 这些都是因为你可以基于反射分析类,然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后,就可以做进一步的处理。 @@ -76,20 +76,20 @@ Class alunbarClass = TargetObject.class; 但是我们一般是不知道具体类的,基本都是通过遍历包下面的类来获取 Class 对象,通过此方式获取 Class 对象不会进行初始化 -**2. 通过 `Class.forName()`传入类的全路径获取:** +**2. 通过 `Class.forName()` 传入类的全路径获取:** ```java Class alunbarClass1 = Class.forName("cn.javaguide.TargetObject"); ``` -**3. 通过对象实例`instance.getClass()`获取:** +**3. 通过对象实例 `instance.getClass()` 获取:** ```java TargetObject o = new TargetObject(); Class alunbarClass2 = o.getClass(); ``` -**4. 通过类加载器`xxxClassLoader.loadClass()`传入类路径获取:** +**4. 通过类加载器 `xxxClassLoader.loadClass()` 传入类路径获取:** ```java ClassLoader.getSystemClassLoader().loadClass("cn.javaguide.TargetObject"); @@ -182,7 +182,7 @@ I love JavaGuide value is JavaGuide ``` -**注意** : 有读者提到上面代码运行会抛出 `ClassNotFoundException` 异常,具体原因是你没有下面把这段代码的包名替换成自己创建的 `TargetObject` 所在的包 。 +**注意** : 有读者提到上面代码运行会抛出 `ClassNotFoundException` 异常,具体原因是你没有下面把这段代码的包名替换成自己创建的 `TargetObject` 所在的包。 可以参考: 这篇文章。 ```java diff --git a/docs/java/basis/serialization.md b/docs/java/basis/serialization.md index 254032b9ef7..a66d117a689 100644 --- a/docs/java/basis/serialization.md +++ b/docs/java/basis/serialization.md @@ -10,7 +10,7 @@ head: content: Java序列化,反序列化,Serializable接口,transient关键字,serialVersionUID,序列化协议,对象持久化 --- -## 什么是序列化和反序列化? +## 什么是序列化和反序列化? 如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中,或者在网络传输 Java 对象,这些场景都需要用到序列化。 @@ -19,7 +19,7 @@ head: - **序列化**:将数据结构或对象转换成可以存储或传输的形式,通常是二进制字节流,也可以是 JSON, XML 等文本格式 - **反序列化**:将在序列化过程中所生成的数据转换为原始数据结构或者对象的过程 -对于 Java 这种面向对象编程语言来说,我们序列化的都是对象(Object)也就是实例化后的类(Class),但是在 C++这种半面向对象的语言中,struct(结构体)定义的是数据结构类型,而 class 对应的是对象类型。 +对于 Java 这种面向对象编程语言来说,我们序列化的都是对象(Object)也就是实例化后的类(Class),但是在 C++这种半面向对象的语言中,struct(结构体)定义的是数据结构类型,而 class 对应的是对象类型。 下面是序列化和反序列化常见应用场景: @@ -55,13 +55,13 @@ head: ## 常见序列化协议有哪些? -JDK 自带的序列化方式一般不会用 ,因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff,这些都是基于二进制的序列化协议。 +JDK 自带的序列化方式一般不会用,因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff,这些都是基于二进制的序列化协议。 像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好,但是性能较差,一般不会选择。 ### JDK 自带的序列化方式 -JDK 自带的序列化,只需实现 `java.io.Serializable`接口即可。 +JDK 自带的序列化,只需实现 `java.io.Serializable` 接口即可。 ```java @AllArgsConstructor @@ -98,7 +98,7 @@ public class RpcRequest implements Serializable { > A serializable class can declare its own serialVersionUID explicitly by declaring a field named `"serialVersionUID"` that must be `static`, `final`, and of type `long`; > -> 如果想显式指定 `serialVersionUID` ,则需要在类中使用 `static` 和 `final` 关键字来修饰一个 `long` 类型的变量,变量名字必须为 `"serialVersionUID"` 。 +> 如果想显式指定 `serialVersionUID`,则需要在类中使用 `static` 和 `final` 关键字来修饰一个 `long` 类型的变量,变量名字必须为 `"serialVersionUID"`。 也就是说,`serialVersionUID` 本身(作为 static 变量)确实不作为对象状态被序列化。但是,它的值被 Java 序列化机制特殊处理了——作为一个版本标识符被读取并写入序列化流中,用于在反序列化时进行版本兼容性检查。 @@ -181,7 +181,7 @@ public class KryoSerializer implements Serializer { } ``` -GitHub 地址:[https://github.com/EsotericSoftware/kryo](https://github.com/EsotericSoftware/kryo) 。 +GitHub 地址:[https://github.com/EsotericSoftware/kryo](https://github.com/EsotericSoftware/kryo)。 ### Protobuf diff --git a/docs/java/basis/spi.md b/docs/java/basis/spi.md index 7392d0f3168..cd4b2452124 100644 --- a/docs/java/basis/spi.md +++ b/docs/java/basis/spi.md @@ -10,17 +10,17 @@ head: content: Java SPI,SPI机制,ServiceLoader,服务发现,插件化,JDBC驱动加载,Dubbo扩展,SPI应用 --- -> 本文来自 [Kingshion](https://github.com/jjx0708) 投稿。欢迎更多朋友参与到 JavaGuide 的维护工作,这是一件非常有意义的事情。详细信息请看:[JavaGuide 贡献指南](https://javaguide.cn/javaguide/contribution-guideline.html) 。 +> 本文来自 [Kingshion](https://github.com/jjx0708) 投稿。欢迎更多朋友参与到 JavaGuide 的维护工作,这是一件非常有意义的事情。详细信息请看:[JavaGuide 贡献指南](https://javaguide.cn/javaguide/contribution-guideline.html)。 面向对象设计鼓励模块间基于接口而非具体实现编程,以降低模块间的耦合,遵循依赖倒置原则,并支持开闭原则(对扩展开放,对修改封闭)。然而,直接依赖具体实现会导致在替换实现时需要修改代码,违背了开闭原则。为了解决这个问题,SPI 应运而生,它提供了一种服务发现机制,允许在程序外部动态指定具体实现。这与控制反转(IoC)的思想相似,将组件装配的控制权移交给了程序之外。 -SPI 机制也解决了 Java 类加载体系中双亲委派模型带来的限制。[双亲委派模型](https://javaguide.cn/java/jvm/classloader.html)虽然保证了核心库的安全性和一致性,但也限制了核心库或扩展库加载应用程序类路径上的类(通常由第三方实现)。SPI 允许核心或扩展库定义服务接口,第三方开发者提供并部署实现,SPI 服务加载机制则在运行时动态发现并加载这些实现。例如,JDBC 4.0 及之后版本利用 SPI 自动发现和加载数据库驱动,开发者只需将驱动 JAR 包放置在类路径下即可,无需使用`Class.forName()`显式加载驱动类。 +SPI 机制也解决了 Java 类加载体系中双亲委派模型带来的限制。[双亲委派模型](https://javaguide.cn/java/jvm/classloader.html)虽然保证了核心库的安全性和一致性,但也限制了核心库或扩展库加载应用程序类路径上的类(通常由第三方实现)。SPI 允许核心或扩展库定义服务接口,第三方开发者提供并部署实现,SPI 服务加载机制则在运行时动态发现并加载这些实现。例如,JDBC 4.0 及之后版本利用 SPI 自动发现和加载数据库驱动,开发者只需将驱动 JAR 包放置在类路径下即可,无需使用 `Class.forName()` 显式加载驱动类。 ## SPI 介绍 ### 何谓 SPI? -SPI 即 Service Provider Interface ,字面意思就是:“服务提供者的接口”,我的理解是:专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。 +SPI 即 Service Provider Interface,字面意思就是:“服务提供者的接口”,我的理解是:专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。 SPI 将服务接口和具体的服务实现分离开来,将服务调用方和服务实现者解耦,能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。 @@ -39,13 +39,13 @@ SPI 将服务接口和具体的服务实现分离开来,将服务调用方和 一般模块之间都是通过接口进行通讯,因此我们在服务调用方和服务实现方(也称服务提供者)之间引入一个“接口”。 - 当实现方提供了接口和实现,我们可以通过调用实现方的接口从而拥有实现方给我们提供的能力,这就是 **API**。这种情况下,接口和实现都是放在实现方的包中。调用方通过接口调用实现方的功能,而不需要关心具体的实现细节。 -- 当接口存在于调用方这边时,这就是 **SPI** 。由接口调用方确定接口规则,然后由不同的厂商根据这个规则对这个接口进行实现,从而提供服务。 +- 当接口存在于调用方这边时,这就是 **SPI**。由接口调用方确定接口规则,然后由不同的厂商根据这个规则对这个接口进行实现,从而提供服务。 举个通俗易懂的例子:公司 H 是一家科技公司,新设计了一款芯片,然后现在需要量产了,而市面上有好几家芯片制造业公司,这个时候,只要 H 公司指定好了这芯片生产的标准(定义好了接口标准),那么这些合作的芯片公司(服务提供者)就按照标准交付自家特色的芯片(提供不同方案的实现,但是给出来的结果是一样的)。 ## 实战演示 -SLF4J (Simple Logging Facade for Java)是 Java 的一个日志门面(接口),其具体实现有几种,比如:Logback、Log4j、Log4j2 等等,而且还可以切换,在切换日志具体实现的时候我们是不需要更改项目代码的,只需要在 Maven 依赖里面修改一些 pom 依赖就好了。 +SLF4J(Simple Logging Facade for Java)是 Java 的一个日志门面(接口),其具体实现有几种,比如:Logback、Log4j、Log4j2 等等,而且还可以切换,在切换日志具体实现的时候我们是不需要更改项目代码的,只需要在 Maven 依赖里面修改一些 pom 依赖就好了。 ![](https://oss.javaguide.cn/github/javaguide/java/basis/spi/image-20220723213306039-165858318917813.png) @@ -74,7 +74,7 @@ SLF4J (Simple Logging Facade for Java)是 Java 的一个日志门面(接 Main.class ``` -新建 `Logger` 接口,这个就是 SPI , 服务提供者接口,后面的服务提供者就要针对这个接口进行实现。 +新建 `Logger` 接口,这个就是 SPI, 服务提供者接口,后面的服务提供者就要针对这个接口进行实现。 ```java package edu.jiangxuan.up.spi; @@ -221,13 +221,13 @@ public class Logback implements Logger { ![](https://oss.javaguide.cn/github/javaguide/java/basis/spi/523d5e25198444d3b112baf68ce49daetplv-k3u1fbpfcp-watermark.png) -再点击 OK 。 +再点击 OK。 ![](https://oss.javaguide.cn/github/javaguide/java/basis/spi/f4ba0aa71e9b4d509b9159892a220850tplv-k3u1fbpfcp-watermark.png) 接下来就可以在项目中导入 jar 包里面的一些类和方法了,就像 JDK 工具类导包一样的。 -实现 `Logger` 接口,在 `src` 目录下新建 `META-INF/services` 文件夹,然后新建文件 `edu.jiangxuan.up.spi.Logger` (SPI 的全类名),文件里面的内容是:`edu.jiangxuan.up.spi.service.Logback` (Logback 的全类名,即 SPI 的实现类的包名 + 类名)。 +实现 `Logger` 接口,在 `src` 目录下新建 `META-INF/services` 文件夹,然后新建文件 `edu.jiangxuan.up.spi.Logger`(SPI 的全类名),文件里面的内容是:`edu.jiangxuan.up.spi.service.Logback`(Logback 的全类名,即 SPI 的实现类的包名 + 类名)。 **这是 JDK SPI 机制 ServiceLoader 约定好的标准。** @@ -277,7 +277,7 @@ public class TestJavaSPI { 如果某一天需求变更了,此时需要将日志输出到消息队列,或者做一些别的操作,这个时候完全不需要更改 Logback 的实现,只需要新增一个服务实现(service-provider)可以通过在本项目里面新增实现也可以从外部引入新的服务实现 jar 包。我们可以在服务(LoggerService)中选择一个具体的 服务实现(service-provider) 来完成我们需要的操作。 -那么接下来我们具体来说说 Java SPI 工作的重点原理—— **ServiceLoader** 。 +那么接下来我们具体来说说 Java SPI 工作的重点原理—— **ServiceLoader**。 ## ServiceLoader @@ -285,7 +285,7 @@ public class TestJavaSPI { 想要使用 Java 的 SPI 机制是需要依赖 `ServiceLoader` 来实现的,那么我们接下来看看 `ServiceLoader` 具体是怎么做的: -`ServiceLoader` 是 JDK 提供的一个工具类, 位于`package java.util;`包下。 +`ServiceLoader` 是 JDK 提供的一个工具类, 位于 `package java.util;` 包下。 ```plain A facility to load implementations of a service. diff --git a/docs/java/basis/syntactic-sugar.md b/docs/java/basis/syntactic-sugar.md index 3bd74b9fb0e..b0ac0b3d2bd 100644 --- a/docs/java/basis/syntactic-sugar.md +++ b/docs/java/basis/syntactic-sugar.md @@ -32,7 +32,7 @@ head: 前面提到过,语法糖的存在主要是方便开发人员使用。但其实, **Java 虚拟机并不支持这些语法糖。这些语法糖在编译阶段就会被还原成简单的基础语法结构,这个过程就是解语法糖。** -说到编译,大家肯定都知道,Java 语言中,`javac`命令可以将后缀名为`.java`的源文件编译为后缀名为`.class`的可以运行于 Java 虚拟机的字节码。如果你去看`com.sun.tools.javac.main.JavaCompiler`的源码,你会发现在`compile()`中有一个步骤就是调用`desugar()`,这个方法就是负责解语法糖的实现的。 +说到编译,大家肯定都知道,Java 语言中,`javac` 命令可以将后缀名为 `.java` 的源文件编译为后缀名为 `.class` 的可以运行于 Java 虚拟机的字节码。如果你去看 `com.sun.tools.javac.main.JavaCompiler` 的源码,你会发现在 `compile()` 中有一个步骤就是调用 `desugar()`,这个方法就是负责解语法糖的实现的。 Java 中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。本文主要来分析下这些语法糖背后的原理。一步一步剥去糖衣,看看其本质。 @@ -40,11 +40,11 @@ Java 中最常用的语法糖主要有泛型、变长参数、条件编译、自 ### switch 支持 String 与枚举 -前面提到过,从 Java 7 开始,Java 语言中的语法糖在逐渐丰富,其中一个比较重要的就是 Java 7 中`switch`开始支持`String`。 +前面提到过,从 Java 7 开始,Java 语言中的语法糖在逐渐丰富,其中一个比较重要的就是 Java 7 中 `switch` 开始支持 `String`。 -在开始之前先科普下,Java 中的`switch`自身原本就支持基本类型。比如`int`、`char`等。对于`int`类型,直接进行数值的比较。对于`char`类型则是比较其 ascii 码。所以,对于编译器来说,`switch`中其实只能使用整型,任何类型的比较都要转换成整型。比如`byte`。`short`,`char`(ascii 码是整型)以及`int`。 +在开始之前先科普下,Java 中的 `switch` 自身原本就支持基本类型。比如 `int`、`char` 等。对于 `int` 类型,直接进行数值的比较。对于 `char` 类型则是比较其 ascii 码。所以,对于编译器来说,`switch` 中其实只能使用整型,任何类型的比较都要转换成整型。比如 `byte`。`short`,`char`(ascii 码是整型)以及 `int`。 -那么接下来看下`switch`对`String`的支持,有以下代码: +那么接下来看下 `switch` 对 `String` 的支持,有以下代码: ```java public class switchDemoString { @@ -93,17 +93,17 @@ public class switchDemoString } ``` -看到这个代码,你知道原来 **字符串的 switch 是通过`equals()`和`hashCode()`方法来实现的。** 还好`hashCode()`方法返回的是`int`,而不是`long`。 +看到这个代码,你知道原来 **字符串的 switch 是通过 `equals()` 和 `hashCode()` 方法来实现的。** 还好 `hashCode()` 方法返回的是 `int`,而不是 `long`。 -仔细看下可以发现,进行`switch`的实际是哈希值,然后通过使用`equals`方法比较进行安全检查,这个检查是必要的,因为哈希可能会发生碰撞。因此它的性能是不如使用枚举进行 `switch` 或者使用纯整数常量,但这也不是很差。 +仔细看下可以发现,进行 `switch` 的实际是哈希值,然后通过使用 `equals` 方法比较进行安全检查,这个检查是必要的,因为哈希可能会发生碰撞。因此它的性能是不如使用枚举进行 `switch` 或者使用纯整数常量,但这也不是很差。 ### 泛型 -我们都知道,很多语言都是支持泛型的,但是很多人不知道的是,不同的编译器对于泛型的处理方式是不同的,通常情况下,一个编译器处理泛型有两种方式:`Code specialization`和`Code sharing`。C++和 C#是使用`Code specialization`的处理机制,而 Java 使用的是`Code sharing`的机制。 +我们都知道,很多语言都是支持泛型的,但是很多人不知道的是,不同的编译器对于泛型的处理方式是不同的,通常情况下,一个编译器处理泛型有两种方式:`Code specialization` 和 `Code sharing`。C++和 C#是使用 `Code specialization` 的处理机制,而 Java 使用的是 `Code sharing` 的机制。 > Code sharing 方式为每个泛型类型创建唯一的字节码表示,并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除(`type erasure`)实现的。 -也就是说,**对于 Java 虚拟机来说,他根本不认识`Map map`这样的语法。需要在编译阶段通过类型擦除的方式进行解语法糖。** +也就是说,**对于 Java 虚拟机来说,他根本不认识 `Map map` 这样的语法。需要在编译阶段通过类型擦除的方式进行解语法糖。** 类型擦除的主要过程如下:1.将所有的泛型参数用其最左边界(最顶级的父类型)类型替换。 2.移除所有的类型参数。 @@ -156,7 +156,7 @@ public static > A max(Collection xs) { } ``` -**虚拟机中没有泛型,只有普通类和普通方法,所有泛型类的类型参数在编译时都会被擦除,泛型类并没有自己独有的`Class`类对象。比如并不存在`List.class`或是`List.class`,而只有`List.class`。** +**虚拟机中没有泛型,只有普通类和普通方法,所有泛型类的类型参数在编译时都会被擦除,泛型类并没有自己独有的 `Class` 类对象。比如并不存在 `List.class` 或是 `List.class`,而只有 `List.class`。** ### 自动装箱与拆箱 @@ -201,7 +201,7 @@ public static void main(String args[]) } ``` -从反编译得到内容可以看出,在装箱的时候自动调用的是`Integer`的`valueOf(int)`方法。而在拆箱的时候自动调用的是`Integer`的`intValue`方法。 +从反编译得到内容可以看出,在装箱的时候自动调用的是 `Integer` 的 `valueOf(int)` 方法。而在拆箱的时候自动调用的是 `Integer` 的 `intValue` 方法。 所以,**装箱过程是通过调用包装器的 valueOf 方法实现的,而拆箱过程是通过调用包装器的 xxxValue 方法实现的。** @@ -248,9 +248,9 @@ public static transient void print(String strs[]) ### 枚举 -Java SE5 提供了一种新的类型-Java 的枚举类型,关键字`enum`可以将一组具名的值的有限集合创建为一种新的类型,而这些具名的值可以作为常规的程序组件使用,这是一种非常有用的功能。 +Java SE5 提供了一种新的类型-Java 的枚举类型,关键字 `enum` 可以将一组具名的值的有限集合创建为一种新的类型,而这些具名的值可以作为常规的程序组件使用,这是一种非常有用的功能。 -要想看源码,首先得有一个类吧,那么枚举类型到底是什么类呢?是`enum`吗?答案很明显不是,`enum`就和`class`一样,只是一个关键字,他并不是一个类,那么枚举是由什么类维护的呢,我们简单的写一个枚举: +要想看源码,首先得有一个类吧,那么枚举类型到底是什么类呢?是 `enum` 吗?答案很明显不是,`enum` 就和 `class` 一样,只是一个关键字,他并不是一个类,那么枚举是由什么类维护的呢,我们简单的写一个枚举: ```java public enum t { @@ -296,15 +296,15 @@ public final class T extends Enum } ``` -通过反编译后代码我们可以看到,`public final class T extends Enum`,说明,该类是继承了`Enum`类的,同时`final`关键字告诉我们,这个类也是不能被继承的。 +通过反编译后代码我们可以看到,`public final class T extends Enum`,说明,该类是继承了 `Enum` 类的,同时 `final` 关键字告诉我们,这个类也是不能被继承的。 -**当我们使用`enum`来定义一个枚举类型的时候,编译器会自动帮我们创建一个`final`类型的类继承`Enum`类,所以枚举类型不能被继承。** +**当我们使用 `enum` 来定义一个枚举类型的时候,编译器会自动帮我们创建一个 `final` 类型的类继承 `Enum` 类,所以枚举类型不能被继承。** ### 内部类 内部类又称为嵌套类,可以把内部类理解为外部类的一个普通成员。 -**内部类之所以也是语法糖,是因为它仅仅是一个编译时的概念,`outer.java`里面定义了一个内部类`inner`,一旦编译成功,就会生成两个完全不同的`.class`文件了,分别是`outer.class`和`outer$inner.class`。所以内部类的名字完全可以和它的外部类名字相同。** +**内部类之所以也是语法糖,是因为它仅仅是一个编译时的概念,`outer.java` 里面定义了一个内部类 `inner`,一旦编译成功,就会生成两个完全不同的 `.class` 文件了,分别是 `outer.class` 和 `outer$inner.class`。所以内部类的名字完全可以和它的外部类名字相同。** ```java public class OuterClass { @@ -336,7 +336,7 @@ public class OuterClass { } ``` -以上代码编译后会生成两个 class 文件:`OuterClass$InnerClass.class`、`OuterClass.class` 。当我们尝试对`OuterClass.class`文件进行反编译的时候,命令行会打印以下内容:`Parsing OuterClass.class...Parsing inner class OuterClass$InnerClass.class... Generating OuterClass.jad` 。他会把两个文件全部进行反编译,然后一起生成一个`OuterClass.jad`文件。文件内容如下: +以上代码编译后会生成两个 class 文件:`OuterClass$InnerClass.class`、`OuterClass.class`。当我们尝试对 `OuterClass.class` 文件进行反编译的时候,命令行会打印以下内容:`Parsing OuterClass.class...Parsing inner class OuterClass$InnerClass.class... Generating OuterClass.jad`。他会把两个文件全部进行反编译,然后一起生成一个 `OuterClass.jad` 文件。文件内容如下: ```java public class OuterClass @@ -410,7 +410,7 @@ class OuterClass$InnerClass { ``` -实际上,在编译完成之后,inner 实例内部会有指向 outer 实例的引用`this$0`,但是简单的`outer.name`是无法访问 private 属性的。从反编译的结果可以看到,outer 中会有一个桥方法`static String access$000(OuterClass)`,恰好返回 String 类型,即 userName 属性。正是通过这个方法实现内部类访问外部类私有属性。所以反编译后的`printOut()`方法大致如下: +实际上,在编译完成之后,inner 实例内部会有指向 outer 实例的引用 `this$0`,但是简单的 `outer.name` 是无法访问 private 属性的。从反编译的结果可以看到,outer 中会有一个桥方法 `static String access$000(OuterClass)`,恰好返回 String 类型,即 userName 属性。正是通过这个方法实现内部类访问外部类私有属性。所以反编译后的 `printOut()` 方法大致如下: ```java public void printOut() { @@ -421,7 +421,7 @@ public void printOut() { 补充: 1. 匿名内部类、局部内部类、静态内部类也是通过桥方法来获取 private 属性。 -2. 静态内部类没有`this$0`的引用 +2. 静态内部类没有 `this$0` 的引用 3. 匿名内部类、局部内部类通过复制使用局部变量,该变量初始化之后就不能被修改。以下是一个案例: ```java @@ -497,13 +497,13 @@ public class ConditionalCompilation } ``` -首先,我们发现,在反编译后的代码中没有`System.out.println("Hello, ONLINE!");`,这其实就是条件编译。当`if(ONLINE)`为 false 的时候,编译器就没有对其内的代码进行编译。 +首先,我们发现,在反编译后的代码中没有 `System.out.println("Hello, ONLINE!");`,这其实就是条件编译。当 `if(ONLINE)` 为 false 的时候,编译器就没有对其内的代码进行编译。 所以,**Java 语法的条件编译,是通过判断条件为常量的 if 语句实现的。其原理也是 Java 语言的语法糖。根据 if 判断条件的真假,编译器直接把分支为 false 的代码块消除。通过该方式实现的条件编译,必须在方法体内实现,而无法在整个 Java 类的结构或者类的属性上进行条件编译,这与 C/C++的条件编译相比,确实更有局限性。在 Java 语言设计之初并没有引入条件编译的功能,虽有局限,但是总比没有更强。** ### 断言 -在 Java 中,`assert`关键字是从 JAVA SE 1.4 引入的,为了避免和老版本的 Java 代码中使用了`assert`关键字导致错误,Java 在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都将忽略!),如果要开启断言检查,则需要用开关`-enableassertions`或`-ea`来开启。 +在 Java 中,`assert` 关键字是从 JAVA SE 1.4 引入的,为了避免和老版本的 Java 代码中使用了 `assert` 关键字导致错误,Java 在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都将忽略!),如果要开启断言检查,则需要用开关 `-enableassertions` 或 `-ea` 来开启。 看一段包含断言的代码: @@ -549,7 +549,7 @@ static final boolean $assertionsDisabled = !com/hollis/suguar/AssertTest.desired } ``` -很明显,反编译之后的代码要比我们自己的代码复杂的多。所以,使用了 assert 这个语法糖我们节省了很多代码。**其实断言的底层实现就是 if 语言,如果断言结果为 true,则什么都不做,程序继续执行,如果断言结果为 false,则程序抛出 AssertError 来打断程序的执行。**`-enableassertions`会设置\$assertionsDisabled 字段的值。 +很明显,反编译之后的代码要比我们自己的代码复杂的多。所以,使用了 assert 这个语法糖我们节省了很多代码。**其实断言的底层实现就是 if 语言,如果断言结果为 true,则什么都不做,程序继续执行,如果断言结果为 false,则程序抛出 AssertError 来打断程序的执行。**`-enableassertions` 会设置\$assertionsDisabled 字段的值。 ### 数值字面量 @@ -579,7 +579,7 @@ public class Test } ``` -反编译后就是把`_`删除了。也就是说 **编译器并不认识在数字字面量中的`_`,需要在编译阶段把他去掉。** +反编译后就是把 `_` 删除了。也就是说 **编译器并不认识在数字字面量中的 `_`,需要在编译阶段把他去掉。** ### for-each @@ -628,7 +628,7 @@ public static transient void main(String args[]) Java 里,对于文件操作 IO 流、数据库连接等开销非常昂贵的资源,用完之后必须及时通过 close 方法将其关闭,否则资源会一直处于打开状态,可能会导致内存泄露等问题。 -关闭资源的常用方式就是在`finally`块里是释放,即调用`close`方法。比如,我们经常会写这样的代码: +关闭资源的常用方式就是在 `finally` 块里是释放,即调用 `close` 方法。比如,我们经常会写这样的代码: ```java public static void main(String[] args) { @@ -653,7 +653,7 @@ public static void main(String[] args) { } ``` -从 Java 7 开始,jdk 提供了一种更好的方式关闭资源,使用`try-with-resources`语句,改写一下上面的代码,效果如下: +从 Java 7 开始,jdk 提供了一种更好的方式关闭资源,使用 `try-with-resources` 语句,改写一下上面的代码,效果如下: ```java public static void main(String... args) { @@ -668,7 +668,7 @@ public static void main(String... args) { } ``` -看,这简直是一大福音啊,虽然我之前一般使用`IOUtils`去关闭流,并不会使用在`finally`中写很多代码的方式,但是这种新的语法糖看上去好像优雅很多呢。看下他的背后: +看,这简直是一大福音啊,虽然我之前一般使用 `IOUtils` 去关闭流,并不会使用在 `finally` 中写很多代码的方式,但是这种新的语法糖看上去好像优雅很多呢。看下他的背后: ```java public static transient void main(String args[]) @@ -738,7 +738,7 @@ private static /* synthetic */ void lambda$main$0(String s) { } ``` -可以看到,在`forEach`方法中,其实是调用了`java.lang.invoke.LambdaMetafactory#metafactory`方法,该方法的第四个参数 `implMethod` 指定了方法实现。可以看到这里其实是调用了一个`lambda$main$0`方法进行了输出。 +可以看到,在 `forEach` 方法中,其实是调用了 `java.lang.invoke.LambdaMetafactory#metafactory` 方法,该方法的第四个参数 `implMethod` 指定了方法实现。可以看到这里其实是调用了一个 `lambda$main$0` 方法进行了输出。 再来看一个稍微复杂一点的,先对 List 进行过滤,然后再输出: @@ -770,7 +770,7 @@ private static /* synthetic */ boolean lambda$main$0(String string) { } ``` -两个 lambda 表达式分别调用了`lambda$main$1`和`lambda$main$0`两个方法。 +两个 lambda 表达式分别调用了 `lambda$main$1` 和 `lambda$main$0` 两个方法。 **所以,lambda 表达式的实现其实是依赖了一些底层的 api,在编译阶段,编译器会把 lambda 表达式进行解糖,转换成调用内部 api 的方式。** @@ -793,11 +793,11 @@ public class GenericTypes { } ``` -上面这段代码,有两个重载的函数,因为他们的参数类型不同,一个是`List`另一个是`List` ,但是,这段代码是编译通不过的。因为我们前面讲过,参数`List`和`List`编译之后都被擦除了,变成了一样的原生类型 List,擦除动作导致这两个方法的特征签名变得一模一样。 +上面这段代码,有两个重载的函数,因为他们的参数类型不同,一个是 `List` 另一个是 `List`,但是,这段代码是编译通不过的。因为我们前面讲过,参数 `List` 和 `List` 编译之后都被擦除了,变成了一样的原生类型 List,擦除动作导致这两个方法的特征签名变得一模一样。 **二、当泛型遇到 catch** -泛型的类型参数不能用在 Java 异常处理的 catch 语句中。因为异常处理是由 JVM 在运行时刻来进行的。由于类型信息被擦除,JVM 是无法区分两个异常类型`MyException`和`MyException`的 +泛型的类型参数不能用在 Java 异常处理的 catch 语句中。因为异常处理是由 JVM 在运行时刻来进行的。由于类型信息被擦除,JVM 是无法区分两个异常类型 `MyException` 和 `MyException` 的 **三、当泛型内包含静态变量** @@ -820,7 +820,7 @@ class GT{ 以上代码输出结果为:2! 有些同学可能会误认为泛型类是不同的类,对应不同的字节码,其实 -由于经过类型擦除,所有的泛型类实例都关联到同一份字节码上,泛型类的静态变量是共享的。上面例子里的`GT.var`和`GT.var`其实是一个变量。 +由于经过类型擦除,所有的泛型类实例都关联到同一份字节码上,泛型类的静态变量是共享的。上面例子里的 `GT.var` 和 `GT.var` 其实是一个变量。 ### 自动装箱与拆箱 @@ -859,11 +859,11 @@ for (Student stu : students) { } ``` -会抛出`ConcurrentModificationException`异常。 +会抛出 `ConcurrentModificationException` 异常。 -这里涉及集合的 **fail-fast(快速失败)** 机制。以 `ArrayList` 为例,其内部维护了一个 `modCount` 计数器,每次对集合结构进行修改(如添加、删除)时都会递增该计数器。当创建 `Iterator` 时,会将当前的 `modCount` 记录为 `expectedModCount`。在每次调用 `next()` 时,`Iterator` 都会检查 `modCount` 是否等于 `expectedModCount`,如果不等,说明集合在遍历期间被其他方式修改了,就会抛出`java.util.ConcurrentModificationException`异常。 +这里涉及集合的 **fail-fast(快速失败)** 机制。以 `ArrayList` 为例,其内部维护了一个 `modCount` 计数器,每次对集合结构进行修改(如添加、删除)时都会递增该计数器。当创建 `Iterator` 时,会将当前的 `modCount` 记录为 `expectedModCount`。在每次调用 `next()` 时,`Iterator` 都会检查 `modCount` 是否等于 `expectedModCount`,如果不等,说明集合在遍历期间被其他方式修改了,就会抛出 `java.util.ConcurrentModificationException` 异常。 -所以 `Iterator` 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 `Iterator` 本身的方法`remove()`来删除对象,`Iterator.remove()` 方法会在删除元素后同步更新 `expectedModCount`,从而避免触发该异常。 +所以 `Iterator` 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 `Iterator` 本身的方法 `remove()` 来删除对象,`Iterator.remove()` 方法会在删除元素后同步更新 `expectedModCount`,从而避免触发该异常。 ## 总结 diff --git a/docs/java/basis/unsafe.md b/docs/java/basis/unsafe.md index 46a537feecb..4e0d1ad8c9b 100644 --- a/docs/java/basis/unsafe.md +++ b/docs/java/basis/unsafe.md @@ -61,7 +61,7 @@ public final class Unsafe { } ``` -`Unsafe` 类为一单例实现,提供静态方法 `getUnsafe` 获取 `Unsafe`实例。这个看上去貌似可以用来获取 `Unsafe` 实例。但是,当我们直接调用这个静态方法的时候,会抛出 `SecurityException` 异常: +`Unsafe` 类为一单例实现,提供静态方法 `getUnsafe` 获取 `Unsafe` 实例。这个看上去貌似可以用来获取 `Unsafe` 实例。但是,当我们直接调用这个静态方法的时候,会抛出 `SecurityException` 异常: ```bash Exception in thread "main" java.lang.SecurityException: Unsafe @@ -71,7 +71,7 @@ Exception in thread "main" java.lang.SecurityException: Unsafe **为什么 `public static` 方法无法被直接调用呢?** -这是因为在`getUnsafe`方法中,会对调用者的`classLoader`进行检查,判断当前类是否由`Bootstrap classLoader`加载,如果不是的话那么就会抛出一个`SecurityException`异常。也就是说,只有启动类加载器加载的类才能够调用 Unsafe 类中的方法,来防止这些方法在不可信的代码中被调用。 +这是因为在 `getUnsafe` 方法中,会对调用者的 `classLoader` 进行检查,判断当前类是否由 `Bootstrap classLoader` 加载,如果不是的话那么就会抛出一个 `SecurityException` 异常。也就是说,只有启动类加载器加载的类才能够调用 Unsafe 类中的方法,来防止这些方法在不可信的代码中被调用。 **为什么要对 Unsafe 类进行这么谨慎的使用限制呢?** @@ -81,7 +81,7 @@ Exception in thread "main" java.lang.SecurityException: Unsafe 这里介绍两个可行的方案。 -1、利用反射获得 Unsafe 类中已经实例化完成的单例对象 `theUnsafe` 。 +1、利用反射获得 Unsafe 类中已经实例化完成的单例对象 `theUnsafe`。 ```java private static Unsafe reflectGetUnsafe() { @@ -96,7 +96,7 @@ private static Unsafe reflectGetUnsafe() { } ``` -2、从`getUnsafe`方法的使用限制条件出发,通过 Java 命令行命令`-Xbootclasspath/a`把调用 Unsafe 相关方法的类 A 所在 jar 包路径追加到默认的 bootstrap 路径中,使得 A 被引导类加载器加载,从而通过`Unsafe.getUnsafe`方法安全的获取 Unsafe 实例。 +2、从 `getUnsafe` 方法的使用限制条件出发,通过 Java 命令行命令 `-Xbootclasspath/a` 把调用 Unsafe 相关方法的类 A 所在 jar 包路径追加到默认的 bootstrap 路径中,使得 A 被引导类加载器加载,从而通过 `Unsafe.getUnsafe` 方法安全的获取 Unsafe 实例。 ```bash java -Xbootclasspath/a: ${path} // 其中path为调用Unsafe相关方法的类所在jar包路径 @@ -206,7 +206,7 @@ Value at newAddr (full 8 bytes): 144680345659310337 **第四步:读取完整数据** -- `unsafe.getLong(newAddr)` 从起始地址读取一个 long 值(8 字节)。此时内存中的 8 字节内容为 `0x01010101` (低地址) 和 `0x02020202` (高地址) 的拼接。 +- `unsafe.getLong(newAddr)` 从起始地址读取一个 long 值(8 字节)。此时内存中的 8 字节内容为 `0x01010101`(低地址) 和 `0x02020202`(高地址) 的拼接。 - 在小端字节序(Little-Endian)的机器上,这 8 字节在内存中会被解释为十六进制数 `0x0202020201010101`。 - 这个十六进制数转换为十进制,结果正是 `144680345659310337`。这完美地解释了最终的输出结果。 @@ -276,9 +276,9 @@ public native void storeFence(); public native void fullFence(); ``` -内存屏障可以看做对内存随机访问的操作中的一个同步点,使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作。以`loadFence`方法为例,它会禁止读操作重排序,保证在这个屏障之前的所有读操作都已经完成,并且将缓存数据设为无效,重新从主存中进行加载。 +内存屏障可以看做对内存随机访问的操作中的一个同步点,使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作。以 `loadFence` 方法为例,它会禁止读操作重排序,保证在这个屏障之前的所有读操作都已经完成,并且将缓存数据设为无效,重新从主存中进行加载。 -看到这估计很多小伙伴们会想到`volatile`关键字了,如果在字段上添加了`volatile`关键字,就能够实现字段在多线程下的可见性。基于读内存屏障,我们也能实现相同的功能。下面定义一个线程方法,在线程中去修改`flag`标志位,注意这里的`flag`是没有被`volatile`修饰的: +看到这估计很多小伙伴们会想到 `volatile` 关键字了,如果在字段上添加了 `volatile` 关键字,就能够实现字段在多线程下的可见性。基于读内存屏障,我们也能实现相同的功能。下面定义一个线程方法,在线程中去修改 `flag` 标志位,注意这里的 `flag` 是没有被 `volatile` 修饰的: ```java @Getter @@ -297,7 +297,7 @@ class ChangeThread implements Runnable{ } ``` -在主线程的`while`循环中,加入内存屏障,测试是否能够感知到`flag`的修改变化: +在主线程的 `while` 循环中,加入内存屏障,测试是否能够感知到 `flag` 的修改变化: ```java public static void main(String[] args){ @@ -323,7 +323,7 @@ detected flag changed main thread end ``` -而如果删掉上面代码中的`loadFence`方法,那么主线程将无法感知到`flag`发生的变化,会一直在`while`中循环。可以用图来表示上面的过程: +而如果删掉上面代码中的 `loadFence` 方法,那么主线程将无法感知到 `flag` 发生的变化,会一直在 `while` 中循环。可以用图来表示上面的过程: ![](https://oss.javaguide.cn/github/javaguide/java/basis/unsafe/image-20220717144703446.png) @@ -391,7 +391,7 @@ value after putInt: 42 **对象属性** -对象成员属性的内存偏移量获取,以及字段属性值的修改,在上面的例子中我们已经测试过了。除了前面的`putInt`、`getInt`方法外,Unsafe 提供了全部 8 种基础数据类型以及`Object`的`put`和`get`方法,并且所有的`put`方法都可以越过访问权限,直接修改内存中的数据。阅读 openJDK 源码中的注释发现,基础数据类型和`Object`的读写稍有不同,基础数据类型是直接操作的属性值(`value`),而`Object`的操作则是基于引用值(`reference value`)。下面是`Object`的读写方法: +对象成员属性的内存偏移量获取,以及字段属性值的修改,在上面的例子中我们已经测试过了。除了前面的 `putInt`、`getInt` 方法外,Unsafe 提供了全部 8 种基础数据类型以及 `Object` 的 `put` 和 `get` 方法,并且所有的 `put` 方法都可以越过访问权限,直接修改内存中的数据。阅读 openJDK 源码中的注释发现,基础数据类型和 `Object` 的读写稍有不同,基础数据类型是直接操作的属性值(`value`),而 `Object` 的操作则是基于引用值(`reference value`)。下面是 `Object` 的读写方法: ```java //在对象的指定偏移地址获取一个对象引用 @@ -400,7 +400,7 @@ public native Object getObject(Object o, long offset); public native void putObject(Object o, long offset, Object x); ``` -除了对象属性的普通读写外,`Unsafe` 还提供了 **volatile 读写**和**有序写入**方法。`volatile`读写方法的覆盖范围与普通读写相同,包含了全部基础数据类型和`Object`类型,以`int`类型为例: +除了对象属性的普通读写外,`Unsafe` 还提供了 **volatile 读写**和**有序写入**方法。`volatile` 读写方法的覆盖范围与普通读写相同,包含了全部基础数据类型和 `Object` 类型,以 `int` 类型为例: ```java //在对象的指定偏移地址处读取一个int值,支持volatile load语义 @@ -409,7 +409,7 @@ public native int getIntVolatile(Object o, long offset); public native void putIntVolatile(Object o, long offset, int x); ``` -相对于普通读写来说,`volatile`读写具有更高的成本,因为它需要保证可见性和有序性。在执行`get`操作时,会强制从主存中获取属性值,在使用`put`方法设置属性值时,会强制将值更新到主存中,从而保证这些变更对其他线程是可见的。 +相对于普通读写来说,`volatile` 读写具有更高的成本,因为它需要保证可见性和有序性。在执行 `get` 操作时,会强制从主存中获取属性值,在使用 `put` 方法设置属性值时,会强制将值更新到主存中,从而保证这些变更对其他线程是可见的。 有序写入的方法有以下三个: @@ -419,18 +419,18 @@ public native void putOrderedInt(Object o, long offset, int x); public native void putOrderedLong(Object o, long offset, long x); ``` -有序写入的成本相对`volatile`较低,因为它只保证写入时的有序性,而不保证可见性,也就是一个线程写入的值不能保证其他线程立即可见。为了解决这里的差异性,需要对内存屏障的知识点再进一步进行补充,首先需要了解两个指令的概念: +有序写入的成本相对 `volatile` 较低,因为它只保证写入时的有序性,而不保证可见性,也就是一个线程写入的值不能保证其他线程立即可见。为了解决这里的差异性,需要对内存屏障的知识点再进一步进行补充,首先需要了解两个指令的概念: - `Load`:将主内存中的数据拷贝到处理器的缓存中 - `Store`:将处理器缓存的数据刷新到主内存中 -顺序写入与`volatile`写入的差别在于,在顺序写时加入的内存屏障类型为`StoreStore`类型,而在`volatile`写入时加入的内存屏障是`StoreLoad`类型,如下图所示: +顺序写入与 `volatile` 写入的差别在于,在顺序写时加入的内存屏障类型为 `StoreStore` 类型,而在 `volatile` 写入时加入的内存屏障是 `StoreLoad` 类型,如下图所示: ![](https://oss.javaguide.cn/github/javaguide/java/basis/unsafe/image-20220717144834132.png) -在有序写入方法中,使用的是`StoreStore`屏障,该屏障确保`Store1`立刻刷新数据到内存,这一操作先于`Store2`以及后续的存储指令操作。而在`volatile`写入中,使用的是`StoreLoad`屏障,该屏障确保`Store1`立刻刷新数据到内存,这一操作先于`Load2`及后续的装载指令,并且,`StoreLoad`屏障会使该屏障之前的所有内存访问指令,包括存储指令和访问指令全部完成之后,才执行该屏障之后的内存访问指令。 +在有序写入方法中,使用的是 `StoreStore` 屏障,该屏障确保 `Store1` 立刻刷新数据到内存,这一操作先于 `Store2` 以及后续的存储指令操作。而在 `volatile` 写入中,使用的是 `StoreLoad` 屏障,该屏障确保 `Store1` 立刻刷新数据到内存,这一操作先于 `Load2` 及后续的装载指令,并且,`StoreLoad` 屏障会使该屏障之前的所有内存访问指令,包括存储指令和访问指令全部完成之后,才执行该屏障之后的内存访问指令。 -综上所述,在上面的三类写入方法中,在写入效率方面,按照`put`、`putOrder`、`putVolatile`的顺序效率逐渐降低。 +综上所述,在上面的三类写入方法中,在写入效率方面,按照 `put`、`putOrder`、`putVolatile` 的顺序效率逐渐降低。 **对象实例化** @@ -459,7 +459,7 @@ public void objTest() throws Exception{ } ``` -打印结果分别为 1、1、0,说明通过`allocateInstance`方法创建对象过程中,不会调用类的构造方法。使用这种方式创建对象时,只用到了`Class`对象,所以说如果想要跳过对象的初始化阶段或者跳过构造器的安全检查,就可以使用这种方法。在上面的例子中,如果将 A 类的构造函数改为`private`类型,将无法通过构造函数和反射创建对象(可以通过构造函数对象 setAccessible 后创建对象),但`allocateInstance`方法仍然有效。 +打印结果分别为 1、1、0,说明通过 `allocateInstance` 方法创建对象过程中,不会调用类的构造方法。使用这种方式创建对象时,只用到了 `Class` 对象,所以说如果想要跳过对象的初始化阶段或者跳过构造器的安全检查,就可以使用这种方法。在上面的例子中,如果将 A 类的构造函数改为 `private` 类型,将无法通过构造函数和反射创建对象(可以通过构造函数对象 setAccessible 后创建对象),但 `allocateInstance` 方法仍然有效。 #### 典型应用 @@ -481,7 +481,7 @@ public native int arrayIndexScale(Class arrayClass); #### 典型应用 -这两个与数据操作相关的方法,在 `java.util.concurrent.atomic` 包下的 `AtomicIntegerArray`(可以实现对 `Integer` 数组中每个元素的原子性操作)中有典型的应用,如下图 `AtomicIntegerArray` 源码所示,通过 `Unsafe` 的 `arrayBaseOffset`、`arrayIndexScale` 分别获取数组首元素的偏移地址 `base` 及单个元素大小因子 `scale` 。后续相关原子性操作,均依赖于这两个值进行数组中元素的定位,如下图二所示的 `getAndAdd` 方法即通过 `checkedByteOffset` 方法获取某数组元素的偏移地址,而后通过 CAS 实现原子性操作。 +这两个与数据操作相关的方法,在 `java.util.concurrent.atomic` 包下的 `AtomicIntegerArray`(可以实现对 `Integer` 数组中每个元素的原子性操作)中有典型的应用,如下图 `AtomicIntegerArray` 源码所示,通过 `Unsafe` 的 `arrayBaseOffset`、`arrayIndexScale` 分别获取数组首元素的偏移地址 `base` 及单个元素大小因子 `scale`。后续相关原子性操作,均依赖于这两个值进行数组中元素的定位,如下图二所示的 `getAndAdd` 方法即通过 `checkedByteOffset` 方法获取某数组元素的偏移地址,而后通过 CAS 实现原子性操作。 ![](https://oss.javaguide.cn/github/javaguide/java/basis/unsafe/image-20220717144927257.png) @@ -507,17 +507,17 @@ public final native boolean compareAndSwapInt(Object o, long offset, int expecte public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update); ``` -**什么是 CAS?** CAS 即比较并替换(Compare And Swap),是实现并发算法时常用到的一种技术。CAS 操作包含三个操作数——内存位置、预期原值及新值。执行 CAS 操作的时候,将内存位置的值与预期原值比较,如果相匹配,那么处理器会自动将该位置值更新为新值,否则,处理器不做任何操作。我们都知道,CAS 是一条 CPU 的原子指令(cmpxchg 指令),不会造成所谓的数据不一致问题,`Unsafe` 提供的 CAS 方法(如 `compareAndSwapXXX`)底层实现即为 CPU 指令 `cmpxchg` 。 +**什么是 CAS?** CAS 即比较并替换(Compare And Swap),是实现并发算法时常用到的一种技术。CAS 操作包含三个操作数——内存位置、预期原值及新值。执行 CAS 操作的时候,将内存位置的值与预期原值比较,如果相匹配,那么处理器会自动将该位置值更新为新值,否则,处理器不做任何操作。我们都知道,CAS 是一条 CPU 的原子指令(cmpxchg 指令),不会造成所谓的数据不一致问题,`Unsafe` 提供的 CAS 方法(如 `compareAndSwapXXX`)底层实现即为 CPU 指令 `cmpxchg`。 #### 典型应用 -在 JUC 包的并发工具类中大量地使用了 CAS 操作,像在前面介绍`synchronized`和`AQS`的文章中也多次提到了 CAS,其作为乐观锁在并发工具类中广泛发挥了作用。在 `Unsafe` 类中,提供了`compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong`方法来实现的对`Object`、`int`、`long`类型的 CAS 操作。以`compareAndSwapInt`方法为例: +在 JUC 包的并发工具类中大量地使用了 CAS 操作,像在前面介绍 `synchronized` 和 `AQS` 的文章中也多次提到了 CAS,其作为乐观锁在并发工具类中广泛发挥了作用。在 `Unsafe` 类中,提供了 `compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong` 方法来实现的对 `Object`、`int`、`long` 类型的 CAS 操作。以 `compareAndSwapInt` 方法为例: ```java public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x); ``` -参数中`o`为需要更新的对象,`offset`是对象`o`中整形字段的偏移量,如果这个字段的值与`expected`相同,则将字段的值设为`x`这个新值,并且此更新是不可被中断的,也就是一个原子操作。下面是一个使用`compareAndSwapInt`的例子: +参数中 `o` 为需要更新的对象,`offset` 是对象 `o` 中整形字段的偏移量,如果这个字段的值与 `expected` 相同,则将字段的值设为 `x` 这个新值,并且此更新是不可被中断的,也就是一个原子操作。下面是一个使用 `compareAndSwapInt` 的例子: ```java private volatile int a; @@ -579,11 +579,12 @@ private void incrementAndPrint(int targetValue) { } } ``` + 在上述例子中,我们创建了两个线程,它们都尝试修改共享变量 a。每个线程在调用 `incrementAndPrint(targetValue)` 方法时: 1. 会先读取 a 的当前值 `currentValue`。 -2. 检查 `currentValue` 是否等于 `targetValue - 1` (即期望的前一个值)。 -3. 如果条件满足,则调用`unsafe.compareAndSwapInt()` 尝试将 `a` 从 `currentValue` 更新到 `targetValue`。 +2. 检查 `currentValue` 是否等于 `targetValue - 1`(即期望的前一个值)。 +3. 如果条件满足,则调用 `unsafe.compareAndSwapInt()` 尝试将 `a` 从 `currentValue` 更新到 `targetValue`。 4. 如果 CAS 操作成功(返回 true),则打印 `targetValue` 并退出循环。 5. 如果 CAS 操作失败,说明有其他线程同时竞争,此时会重新读取 `currentValue` 并重试,直到成功为止。 @@ -602,7 +603,7 @@ private void incrementAndPrint(int targetValue) { #### 介绍 -`Unsafe` 类中提供了`park`、`unpark`、`monitorEnter`、`monitorExit`、`tryMonitorEnter`方法进行线程调度。 +`Unsafe` 类中提供了 `park`、`unpark`、`monitorEnter`、`monitorExit`、`tryMonitorEnter` 方法进行线程调度。 ```java //取消阻塞线程 @@ -622,7 +623,7 @@ public native boolean tryMonitorEnter(Object o); 方法 `park`、`unpark` 即可实现线程的挂起与恢复,将一个线程进行挂起是通过 `park` 方法实现的,调用 `park` 方法后,线程将一直阻塞直到超时或者中断等条件出现;`unpark` 可以终止一个挂起的线程,使其恢复正常。 -此外,`Unsafe` 源码中`monitor`相关的三个方法已经被标记为`deprecated`,不建议被使用: +此外,`Unsafe` 源码中 `monitor` 相关的三个方法已经被标记为 `deprecated`,不建议被使用: ```java //获得对象锁 @@ -636,11 +637,11 @@ public native void monitorExit(Object var1); public native boolean tryMonitorEnter(Object var1); ``` -`monitorEnter`方法用于获得对象锁,`monitorExit`用于释放对象锁,如果对一个没有被`monitorEnter`加锁的对象执行此方法,会抛出`IllegalMonitorStateException`异常。`tryMonitorEnter`方法尝试获取对象锁,如果成功则返回`true`,反之返回`false`。 +`monitorEnter` 方法用于获得对象锁,`monitorExit` 用于释放对象锁,如果对一个没有被 `monitorEnter` 加锁的对象执行此方法,会抛出 `IllegalMonitorStateException` 异常。`tryMonitorEnter` 方法尝试获取对象锁,如果成功则返回 `true`,反之返回 `false`。 #### 典型应用 -Java 锁和同步器框架的核心类 `AbstractQueuedSynchronizer` (AQS),就是通过调用`LockSupport.park()`和`LockSupport.unpark()`实现线程的阻塞和唤醒的,而 `LockSupport` 的 `park`、`unpark` 方法实际是调用 `Unsafe` 的 `park`、`unpark` 方式实现的。 +Java 锁和同步器框架的核心类 `AbstractQueuedSynchronizer` (AQS),就是通过调用 `LockSupport.park()` 和 `LockSupport.unpark()` 实现线程的阻塞和唤醒的,而 `LockSupport` 的 `park`、`unpark` 方法实际是调用 `Unsafe` 的 `park`、`unpark` 方式实现的。 ```java public static void park(Object blocker) { @@ -655,7 +656,7 @@ public static void unpark(Thread thread) { } ``` -`LockSupport` 的`park`方法调用了 `Unsafe` 的`park`方法来阻塞当前线程,此方法将线程阻塞后就不会继续往后执行,直到有其他线程调用`unpark`方法唤醒当前线程。下面的例子对 `Unsafe` 的这两个方法进行测试: +`LockSupport` 的 `park` 方法调用了 `Unsafe` 的 `park` 方法来阻塞当前线程,此方法将线程阻塞后就不会继续往后执行,直到有其他线程调用 `unpark` 方法唤醒当前线程。下面的例子对 `Unsafe` 的这两个方法进行测试: ```java public static void main(String[] args) { @@ -684,7 +685,7 @@ subThread try to unpark mainThread unpark mainThread success ``` -程序运行的流程也比较容易看懂,子线程开始运行后先进行睡眠,确保主线程能够调用`park`方法阻塞自己,子线程在睡眠 5 秒后,调用`unpark`方法唤醒主线程,使主线程能继续向下执行。整个流程如下图所示: +程序运行的流程也比较容易看懂,子线程开始运行后先进行睡眠,确保主线程能够调用 `park` 方法阻塞自己,子线程在睡眠 5 秒后,调用 `unpark` 方法唤醒主线程,使主线程能继续向下执行。整个流程如下图所示: ![](https://oss.javaguide.cn/github/javaguide/java/basis/unsafe/image-20220717144950116.png) @@ -692,7 +693,7 @@ unpark mainThread success #### 介绍 -`Unsafe` 对`Class`的相关操作主要包括类加载和静态变量的操作方法。 +`Unsafe` 对 `Class` 的相关操作主要包括类加载和静态变量的操作方法。 **静态属性读取相关的方法** @@ -736,16 +737,16 @@ false Hydra ``` -在 `Unsafe` 的对象操作中,我们学习了通过`objectFieldOffset`方法获取对象属性偏移量并基于它对变量的值进行存取,但是它不适用于类中的静态属性,这时候就需要使用`staticFieldOffset`方法。在上面的代码中,只有在获取`Field`对象的过程中依赖到了`Class`,而获取静态变量的属性时不再依赖于`Class`。 +在 `Unsafe` 的对象操作中,我们学习了通过 `objectFieldOffset` 方法获取对象属性偏移量并基于它对变量的值进行存取,但是它不适用于类中的静态属性,这时候就需要使用 `staticFieldOffset` 方法。在上面的代码中,只有在获取 `Field` 对象的过程中依赖到了 `Class`,而获取静态变量的属性时不再依赖于 `Class`。 -在上面的代码中首先创建一个`User`对象,这是因为如果一个类没有被初始化,那么它的静态属性也不会被初始化,最后获取的字段属性将是`null`。所以在获取静态属性前,需要调用`shouldBeInitialized`方法,判断在获取前是否需要初始化这个类。如果删除创建 User 对象的语句,运行结果会变为: +在上面的代码中首先创建一个 `User` 对象,这是因为如果一个类没有被初始化,那么它的静态属性也不会被初始化,最后获取的字段属性将是 `null`。所以在获取静态属性前,需要调用 `shouldBeInitialized` 方法,判断在获取前是否需要初始化这个类。如果删除创建 User 对象的语句,运行结果会变为: ```plain true null ``` -**使用`defineClass`方法允许程序在运行时动态地创建一个类** +**使用 `defineClass` 方法允许程序在运行时动态地创建一个类** ```java public native Class defineClass(String name, byte[] b, int off, int len, ClassLoader loader,ProtectionDomain protectionDomain); @@ -770,17 +771,17 @@ private static void defineTest() { } ``` -在上面的代码中,首先读取了一个`class`文件并通过文件流将它转化为字节数组,之后使用`defineClass`方法动态的创建了一个类,并在后续完成了它的实例化工作,流程如下图所示,并且通过这种方式创建的类,会跳过 JVM 的所有安全检查。 +在上面的代码中,首先读取了一个 `class` 文件并通过文件流将它转化为字节数组,之后使用 `defineClass` 方法动态的创建了一个类,并在后续完成了它的实例化工作,流程如下图所示,并且通过这种方式创建的类,会跳过 JVM 的所有安全检查。 ![](https://oss.javaguide.cn/github/javaguide/java/basis/unsafe/image-20220717145000710.png) -除了`defineClass`方法外,Unsafe 还提供了一个`defineAnonymousClass`方法: +除了 `defineClass` 方法外,Unsafe 还提供了一个 `defineAnonymousClass` 方法: ```java public native Class defineAnonymousClass(Class hostClass, byte[] data, Object[] cpPatches); ``` -使用该方法可以用来动态的创建一个匿名类,在`Lambda`表达式中就是使用 ASM 动态生成字节码,然后利用该方法定义实现相应的函数式接口的匿名类。在 JDK 15 发布的新特性中,在隐藏类(`Hidden classes`)一条中,指出将在未来的版本中弃用 `Unsafe` 的`defineAnonymousClass`方法。 +使用该方法可以用来动态的创建一个匿名类,在 `Lambda` 表达式中就是使用 ASM 动态生成字节码,然后利用该方法定义实现相应的函数式接口的匿名类。在 JDK 15 发布的新特性中,在隐藏类(`Hidden classes`)一条中,指出将在未来的版本中弃用 `Unsafe` 的 `defineAnonymousClass` 方法。 #### 典型应用 @@ -801,7 +802,7 @@ public native int pageSize(); #### 典型应用 -这两个方法的应用场景比较少,在`java.nio.Bits`类中,在使用`pageCount`计算所需的内存页的数量时,调用了`pageSize`方法获取内存页的大小。另外,在使用`copySwapMemory`方法拷贝内存时,调用了`addressSize`方法,检测 32 位系统的情况。 +这两个方法的应用场景比较少,在 `java.nio.Bits` 类中,在使用 `pageCount` 计算所需的内存页的数量时,调用了 `pageSize` 方法获取内存页的大小。另外,在使用 `copySwapMemory` 方法拷贝内存时,调用了 `addressSize` 方法,检测 32 位系统的情况。 ## 总结 diff --git a/docs/java/basis/why-there-only-value-passing-in-java.md b/docs/java/basis/why-there-only-value-passing-in-java.md index 18cc70caee8..0fdedcf2795 100644 --- a/docs/java/basis/why-there-only-value-passing-in-java.md +++ b/docs/java/basis/why-there-only-value-passing-in-java.md @@ -117,7 +117,7 @@ num2 = 20 实际上,并不是的,这里传递的还是值,不过,这个值是实参的地址罢了! -也就是说 `change` 方法的参数拷贝的是 `arr` (实参)的地址,因此,它和 `arr` 指向的是同一个数组对象。这也就说明了为什么方法内部对形参的修改会影响到实参。 +也就是说 `change` 方法的参数拷贝的是 `arr`(实参)的地址,因此,它和 `arr` 指向的是同一个数组对象。这也就说明了为什么方法内部对形参的修改会影响到实参。 为了更强有力地反驳 Java 对引用类型的参数采用的不是引用传递,我们再来看下面这个案例! @@ -159,7 +159,7 @@ xiaoLi:小李 怎么回事???两个引用类型的形参互换并没有影响实参啊! -`swap` 方法的参数 `person1` 和 `person2` 只是拷贝的实参 `xiaoZhang` 和 `xiaoLi` 的地址。因此, `person1` 和 `person2` 的互换只是拷贝的两个地址的互换罢了,并不会影响到实参 `xiaoZhang` 和 `xiaoLi` 。 +`swap` 方法的参数 `person1` 和 `person2` 只是拷贝的实参 `xiaoZhang` 和 `xiaoLi` 的地址。因此, `person1` 和 `person2` 的互换只是拷贝的两个地址的互换罢了,并不会影响到实参 `xiaoZhang` 和 `xiaoLi`。 ![](https://oss.javaguide.cn/github/javaguide/java/basis/java-value-passing-03.png) diff --git a/docs/java/collection/arrayblockingqueue-source-code.md b/docs/java/collection/arrayblockingqueue-source-code.md index 24631e5954b..854a79c2714 100644 --- a/docs/java/collection/arrayblockingqueue-source-code.md +++ b/docs/java/collection/arrayblockingqueue-source-code.md @@ -20,9 +20,9 @@ Java 阻塞队列的历史可以追溯到 JDK1.5 版本,当时 Java 平台增 随着 Java 的不断发展,JDK 后续的几个版本又对阻塞队列进行了不少的更新和完善: -1. JDK1.6 版本:增加 `SynchronousQueue`,一个不存储元素的阻塞队列。 -2. JDK1.7 版本:增加 `TransferQueue`,一个支持更多操作的阻塞队列。 -3. JDK1.8 版本:增加 `DelayQueue`,一个支持延迟获取元素的阻塞队列。 +1. JDK1.6 版本:增加 `SynchronousQueue`,一个不存储元素的阻塞队列。 +2. JDK1.7 版本:增加 `TransferQueue`,一个支持更多操作的阻塞队列。 +3. JDK1.8 版本:增加 `DelayQueue`,一个支持延迟获取元素的阻塞队列。 ### 阻塞队列的思想 @@ -35,7 +35,7 @@ Java 阻塞队列的历史可以追溯到 JDK1.5 版本,当时 Java 平台增 总结一下:阻塞队列就说基于非空和非满两个条件实现生产者和消费者之间的交互,尽管这些交互流程和等待通知的机制实现非常复杂,好在 Doug Lea 的操刀之下已将阻塞队列的细节屏蔽,我们只需调用 `put`、`take`、`offer`、`poll` 等 API 即可实现多线程之间的生产和消费。 -这也使得阻塞队列在多线程开发中有着广泛的运用,最常见的例子无非是我们的线程池,从源码中我们就能看出当核心线程无法及时处理任务时,这些任务都会扔到 `workQueue` 中。 +这也使得阻塞队列在多线程开发中有着广泛的运用,最常见的例子无非是我们的线程池,从源码中我们就能看出当核心线程无法及时处理任务时,这些任务都会扔到 `workQueue` 中。 ```java public ThreadPoolExecutor(int corePoolSize, @@ -339,7 +339,7 @@ public ArrayBlockingQueue(int capacity, boolean fair) { } ``` -这个构造方法里面有两个比较核心的成员变量 `notEmpty`(非空) 和 `notFull` (非满) ,需要我们格外留意,它们是实现生产者和消费者有序工作的关键所在,这一点笔者会在后续的源码解析中详细说明,这里我们只需初步了解一下阻塞队列的构造即可。 +这个构造方法里面有两个比较核心的成员变量 `notEmpty`(非空) 和 `notFull`(非满),需要我们格外留意,它们是实现生产者和消费者有序工作的关键所在,这一点笔者会在后续的源码解析中详细说明,这里我们只需初步了解一下阻塞队列的构造即可。 另外两个构造方法都是基于上述的构造方法,默认情况下,我们会使用下面这个构造方法,该构造方法就意味着 `ArrayBlockingQueue` 用的是非公平锁,即各个生产者或者消费者线程收到通知后,对于锁的争抢是随机的。 @@ -389,9 +389,9 @@ public ArrayBlockingQueue(int capacity, boolean fair, `ArrayBlockingQueue` 阻塞式获取和新增元素的方法为: - `put(E e)`:将元素插入队列中,如果队列已满,则该方法会一直阻塞,直到队列有空间可用或者线程被中断。 -- `take()` :获取并移除队列头部的元素,如果队列为空,则该方法会一直阻塞,直到队列非空或者线程被中断。 +- `take()`:获取并移除队列头部的元素,如果队列为空,则该方法会一直阻塞,直到队列非空或者线程被中断。 -这两个方法实现的关键就是在于两个条件对象 `notEmpty`(非空) 和 `notFull` (非满),这个我们在上文的构造方法中有提到。 +这两个方法实现的关键就是在于两个条件对象 `notEmpty`(非空) 和 `notFull`(非满),这个我们在上文的构造方法中有提到。 接下来笔者就通过两张图让大家了解一下这两个条件是如何在阻塞队列中运用的。 @@ -427,7 +427,7 @@ public void put(E e) throws InterruptedException { } ``` -`put`方法内部调用了 `enqueue` 方法来实现元素入队,我们继续深入查看一下 `enqueue` 方法的实现细节: +`put` 方法内部调用了 `enqueue` 方法来实现元素入队,我们继续深入查看一下 `enqueue` 方法的实现细节: ```java private void enqueue(E x) { @@ -473,9 +473,9 @@ public E take() throws InterruptedException { } ``` -理解了 `put` 方法再看`take` 方法就很简单了,其核心逻辑和`put` 方法正好是相反的,比如`put` 方法在队列满的时候等待队列非满时插入元素(非满条件),而`take` 方法等待队列非空时获取并移除元素(非空条件)。 +理解了 `put` 方法再看 `take` 方法就很简单了,其核心逻辑和 `put` 方法正好是相反的,比如 `put` 方法在队列满的时候等待队列非满时插入元素(非满条件),而 `take` 方法等待队列非空时获取并移除元素(非空条件)。 -`take`方法内部调用了 `dequeue` 方法来实现元素出队,其核心逻辑和 `enqueue` 方法也是相反的。 +`take` 方法内部调用了 `dequeue` 方法来实现元素出队,其核心逻辑和 `enqueue` 方法也是相反的。 ```java private E dequeue() { @@ -499,9 +499,9 @@ private E dequeue() { } ``` -由于`dequeue` 方法(出队)和上面介绍的 `enqueue` 方法(入队)的步骤大致类似,这里就不重复介绍了。 +由于 `dequeue` 方法(出队)和上面介绍的 `enqueue` 方法(入队)的步骤大致类似,这里就不重复介绍了。 -为了帮助理解,我专门画了一张图来展示 `notEmpty`(非空) 和 `notFull` (非满)这两个条件对象是如何控制 `ArrayBlockingQueue` 的存和取的。 +为了帮助理解,我专门画了一张图来展示 `notEmpty`(非空) 和 `notFull`(非满)这两个条件对象是如何控制 `ArrayBlockingQueue` 的存和取的。 ![ArrayBlockingQueue 非空非满](https://oss.javaguide.cn/github/javaguide/java/collection/ArrayBlockingQueue-notEmpty-notFull.png) @@ -613,7 +613,7 @@ final E itemAt(int i) { ### 指定超时时间内阻塞式获取和新增元素 -在 `offer(E e)` 和 `poll()` 非阻塞获取和新增元素的基础上,设计者提供了带有等待时间的 `offer(E e, long timeout, TimeUnit unit)` 和 `poll(long timeout, TimeUnit unit)` ,用于在指定的超时时间内阻塞式地添加和获取元素。 +在 `offer(E e)` 和 `poll()` 非阻塞获取和新增元素的基础上,设计者提供了带有等待时间的 `offer(E e, long timeout, TimeUnit unit)` 和 `poll(long timeout, TimeUnit unit)`,用于在指定的超时时间内阻塞式地添加和获取元素。 ```java public boolean offer(E e, long timeout, TimeUnit unit) @@ -699,7 +699,7 @@ public boolean contains(Object o) { ## ArrayBlockingQueue 获取和新增元素的方法对比 -为了帮助理解 `ArrayBlockingQueue` ,我们再来对比一下上面提到的这些获取和新增元素的方法。 +为了帮助理解 `ArrayBlockingQueue`,我们再来对比一下上面提到的这些获取和新增元素的方法。 新增元素: @@ -730,7 +730,7 @@ public boolean contains(Object o) { `ArrayBlockingQueue` 的容量有限,一旦创建,容量不能改变。 -为了保证线程安全,`ArrayBlockingQueue` 的并发控制采用可重入锁 `ReentrantLock` ,不管是插入操作还是读取操作,都需要获取到锁才能进行操作。并且,它还支持公平和非公平两种方式的锁访问机制,默认是非公平锁。 +为了保证线程安全,`ArrayBlockingQueue` 的并发控制采用可重入锁 `ReentrantLock`,不管是插入操作还是读取操作,都需要获取到锁才能进行操作。并且,它还支持公平和非公平两种方式的锁访问机制,默认是非公平锁。 `ArrayBlockingQueue` 虽名为阻塞队列,但也支持非阻塞获取和新增元素(例如 `poll()` 和 `offer(E e)` 方法),只是队列满时添加元素会抛出异常,队列为空时获取的元素为 null,一般不会使用。 @@ -739,9 +739,9 @@ public boolean contains(Object o) { `ArrayBlockingQueue` 和 `LinkedBlockingQueue` 是 Java 并发包中常用的两种阻塞队列实现,它们都是线程安全的。不过,不过它们之间也存在下面这些区别: - 底层实现:`ArrayBlockingQueue` 基于数组实现,而 `LinkedBlockingQueue` 基于链表实现。 -- 是否有界:`ArrayBlockingQueue` 是有界队列,必须在创建时指定容量大小。`LinkedBlockingQueue` 创建时可以不指定容量大小,默认是`Integer.MAX_VALUE`,也就是无界的。但也可以指定队列大小,从而成为有界的。 -- 锁是否分离: `ArrayBlockingQueue`中的锁是没有分离的,即生产和消费用的是同一个锁;`LinkedBlockingQueue`中的锁是分离的,即生产用的是`putLock`,消费是`takeLock`,这样可以防止生产者和消费者线程之间的锁争夺。 -- 内存占用:`ArrayBlockingQueue` 需要提前分配数组内存,而 `LinkedBlockingQueue` 则是动态分配链表节点内存。这意味着,`ArrayBlockingQueue` 在创建时就会占用一定的内存空间,且往往申请的内存比实际所用的内存更大,而`LinkedBlockingQueue` 则是根据元素的增加而逐渐占用内存空间。 +- 是否有界:`ArrayBlockingQueue` 是有界队列,必须在创建时指定容量大小。`LinkedBlockingQueue` 创建时可以不指定容量大小,默认是 `Integer.MAX_VALUE`,也就是无界的。但也可以指定队列大小,从而成为有界的。 +- 锁是否分离: `ArrayBlockingQueue` 中的锁是没有分离的,即生产和消费用的是同一个锁;`LinkedBlockingQueue` 中的锁是分离的,即生产用的是 `putLock`,消费是 `takeLock`,这样可以防止生产者和消费者线程之间的锁争夺。 +- 内存占用:`ArrayBlockingQueue` 需要提前分配数组内存,而 `LinkedBlockingQueue` 则是动态分配链表节点内存。这意味着,`ArrayBlockingQueue` 在创建时就会占用一定的内存空间,且往往申请的内存比实际所用的内存更大,而 `LinkedBlockingQueue` 则是根据元素的增加而逐渐占用内存空间。 ### ArrayBlockingQueue 和 ConcurrentLinkedQueue 有什么区别? @@ -762,13 +762,13 @@ public boolean contains(Object o) { 这里再详细介绍一下线程间的等待和唤醒具体的实现(不需要记具体的方法,面试中回答要点即可): - 当队列已满时,生产者线程会调用 `notFull.await()` 方法让生产者进行等待,等待队列非满时插入(非满条件)。 -- 当队列为空时,消费者线程会调用 `notEmpty.await()`方法让消费者进行等待,等待队列非空时消费(非空条件)。 -- 当有新的元素被添加时,生产者线程会调用 `notEmpty.signal()`方法唤醒正在等待消费的消费者线程。 -- 当队列中有元素被取出时,消费者线程会调用 `notFull.signal()`方法唤醒正在等待插入元素的生产者线程。 +- 当队列为空时,消费者线程会调用 `notEmpty.await()` 方法让消费者进行等待,等待队列非空时消费(非空条件)。 +- 当有新的元素被添加时,生产者线程会调用 `notEmpty.signal()` 方法唤醒正在等待消费的消费者线程。 +- 当队列中有元素被取出时,消费者线程会调用 `notFull.signal()` 方法唤醒正在等待插入元素的生产者线程。 -关于 `Condition`接口的补充: +关于 `Condition` 接口的补充: -> `Condition`是 JDK1.5 之后才有的,它具有很好的灵活性,比如可以实现多路通知功能也就是在一个`Lock`对象中可以创建多个`Condition`实例(即对象监视器),**线程对象可以注册在指定的`Condition`中,从而可以有选择性的进行线程通知,在调度线程上更加灵活。 在使用`notify()/notifyAll()`方法进行通知时,被通知的线程是由 JVM 选择的,用`ReentrantLock`类结合`Condition`实例可以实现“选择性通知”** ,这个功能非常重要,而且是 `Condition` 接口默认提供的。而`synchronized`关键字就相当于整个 `Lock` 对象中只有一个`Condition`实例,所有的线程都注册在它一个身上。如果执行`notifyAll()`方法的话就会通知所有处于等待状态的线程,这样会造成很大的效率问题。而`Condition`实例的`signalAll()`方法,只会唤醒注册在该`Condition`实例中的所有等待线程。 +> `Condition` 是 JDK1.5 之后才有的,它具有很好的灵活性,比如可以实现多路通知功能也就是在一个 `Lock` 对象中可以创建多个 `Condition` 实例(即对象监视器),**线程对象可以注册在指定的 `Condition` 中,从而可以有选择性的进行线程通知,在调度线程上更加灵活。 在使用 `notify()/notifyAll()` 方法进行通知时,被通知的线程是由 JVM 选择的,用 `ReentrantLock` 类结合 `Condition` 实例可以实现“选择性通知”**,这个功能非常重要,而且是 `Condition` 接口默认提供的。而 `synchronized` 关键字就相当于整个 `Lock` 对象中只有一个 `Condition` 实例,所有的线程都注册在它一个身上。如果执行 `notifyAll()` 方法的话就会通知所有处于等待状态的线程,这样会造成很大的效率问题。而 `Condition` 实例的 `signalAll()` 方法,只会唤醒注册在该 `Condition` 实例中的所有等待线程。 ## 参考文献 diff --git a/docs/java/collection/arraylist-source-code.md b/docs/java/collection/arraylist-source-code.md index 4279d51a995..bbb1c8c5cf6 100644 --- a/docs/java/collection/arraylist-source-code.md +++ b/docs/java/collection/arraylist-source-code.md @@ -12,9 +12,9 @@ head: ## ArrayList 简介 -`ArrayList` 的底层是数组队列,相当于动态数组。与 Java 中的数组相比,它的容量能动态增长。在添加大量元素前,应用程序可以使用`ensureCapacity`操作来增加 `ArrayList` 实例的容量。这可以减少递增式再分配的数量。 +`ArrayList` 的底层是数组队列,相当于动态数组。与 Java 中的数组相比,它的容量能动态增长。在添加大量元素前,应用程序可以使用 `ensureCapacity` 操作来增加 `ArrayList` 实例的容量。这可以减少递增式再分配的数量。 -`ArrayList` 继承于 `AbstractList` ,实现了 `List`, `RandomAccess`, `Cloneable`, `java.io.Serializable` 这些接口。 +`ArrayList` 继承于 `AbstractList`,实现了 `List`, `RandomAccess`, `Cloneable`, `java.io.Serializable` 这些接口。 ```java @@ -25,20 +25,20 @@ public class ArrayList extends AbstractList ``` - `List` : 表明它是一个列表,支持添加、删除、查找等操作,并且可以通过下标进行访问。 -- `RandomAccess` :这是一个标志接口,表明实现这个接口的 `List` 集合是支持 **快速随机访问** 的。在 `ArrayList` 中,我们就可以通过元素的序号快速获取元素对象,这就是快速随机访问。 -- `Cloneable` :表明它具有拷贝能力,可以进行深拷贝或浅拷贝操作。 +- `RandomAccess`:这是一个标志接口,表明实现这个接口的 `List` 集合是支持 **快速随机访问** 的。在 `ArrayList` 中,我们就可以通过元素的序号快速获取元素对象,这就是快速随机访问。 +- `Cloneable`:表明它具有拷贝能力,可以进行深拷贝或浅拷贝操作。 - `Serializable` : 表明它可以进行序列化操作,也就是可以将对象转换为字节流进行持久化存储或网络传输,非常方便。 ![ArrayList 类图](https://oss.javaguide.cn/github/javaguide/java/collection/arraylist-class-diagram.png) ### ArrayList 和 Vector 的区别?(了解即可) -- `ArrayList` 是 `List` 的主要实现类,底层使用 `Object[]`存储,适用于频繁的查找工作,线程不安全 。 -- `Vector` 是 `List` 的古老实现类,底层使用`Object[]` 存储,线程安全。 +- `ArrayList` 是 `List` 的主要实现类,底层使用 `Object[]` 存储,适用于频繁的查找工作,线程不安全。 +- `Vector` 是 `List` 的古老实现类,底层使用 `Object[]` 存储,线程安全。 ### ArrayList 可以添加 null 值吗? -`ArrayList` 中可以存储任何类型的对象,包括 `null` 值。不过,不建议向`ArrayList` 中添加 `null` 值, `null` 值无意义,会让代码难以维护比如忘记做判空处理就会导致空指针异常。 +`ArrayList` 中可以存储任何类型的对象,包括 `null` 值。不过,不建议向 `ArrayList` 中添加 `null` 值, `null` 值无意义,会让代码难以维护比如忘记做判空处理就会导致空指针异常。 示例代码: @@ -55,14 +55,14 @@ System.out.println(listOfStrings); [null, java] ``` -### Arraylist 与 LinkedList 区别? +### Arraylist 与 LinkedList 区别? - **是否保证线程安全:** `ArrayList` 和 `LinkedList` 都是不同步的,也就是不保证线程安全; - **底层数据结构:** `ArrayList` 底层使用的是 **`Object` 数组**;`LinkedList` 底层使用的是 **双向链表** 数据结构(JDK1.6 之前为循环链表,JDK1.7 取消了循环。注意双向链表和双向循环链表的区别,下面有介绍到!) - **插入和删除是否受元素位置的影响:** - - `ArrayList` 采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比如:执行`add(E e)`方法的时候, `ArrayList` 会默认在将指定的元素追加到此列表的末尾,这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话(`add(int index, E element)`),时间复杂度就为 O(n)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 - - `LinkedList` 采用链表存储,所以在头尾插入或者删除元素不受元素位置的影响(`add(E e)`、`addFirst(E e)`、`addLast(E e)`、`removeFirst()`、 `removeLast()`),时间复杂度为 O(1),如果是要在指定位置 `i` 插入和删除元素的话(`add(int index, E element)`,`remove(Object o)`,`remove(int index)`), 时间复杂度为 O(n) ,因为需要先移动到指定位置再插入和删除。 -- **是否支持快速随机访问:** `LinkedList` 不支持高效的随机元素访问,而 `ArrayList`(实现了 `RandomAccess` 接口) 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index)`方法)。 + - `ArrayList` 采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比如:执行 `add(E e)` 方法的时候, `ArrayList` 会默认在将指定的元素追加到此列表的末尾,这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话(`add(int index, E element)`),时间复杂度就为 O(n)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 + - `LinkedList` 采用链表存储,所以在头尾插入或者删除元素不受元素位置的影响(`add(E e)`、`addFirst(E e)`、`addLast(E e)`、`removeFirst()`、 `removeLast()`),时间复杂度为 O(1),如果是要在指定位置 `i` 插入和删除元素的话(`add(int index, E element)`,`remove(Object o)`,`remove(int index)`), 时间复杂度为 O(n),因为需要先移动到指定位置再插入和删除。 +- **是否支持快速随机访问:** `LinkedList` 不支持高效的随机元素访问,而 `ArrayList`(实现了 `RandomAccess` 接口) 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于 `get(int index)` 方法)。 - **内存空间占用:** `ArrayList` 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间,而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间(因为要存放直接后继和直接前驱以及数据)。 ## ArrayList 核心源码解读 @@ -635,7 +635,7 @@ public ArrayList(Collection c) { 细心的同学一定会发现:**以无参数构造方法创建 `ArrayList` 时,实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时,才真正分配容量。即向数组中添加第一个元素时,数组容量扩为 10。** 下面在我们分析 `ArrayList` 扩容时会讲到这一点内容! -> 补充:JDK6 new 无参构造的 `ArrayList` 对象时,直接创建了长度是 10 的 `Object[]` 数组 `elementData` 。 +> 补充:JDK6 new 无参构造的 `ArrayList` 对象时,直接创建了长度是 10 的 `Object[]` 数组 `elementData`。 ### 一步一步分析 ArrayList 扩容机制 @@ -692,11 +692,11 @@ private void ensureExplicitCapacity(int minCapacity) { 我们来仔细分析一下: -- 当我们要 `add` 进第 1 个元素到 `ArrayList` 时,`elementData.length` 为 0 (因为还是一个空的 list),因为执行了 `ensureCapacityInternal()` 方法 ,所以 `minCapacity` 此时为 10。此时,`minCapacity - elementData.length > 0`成立,所以会进入 `grow(minCapacity)` 方法。 -- 当 `add` 第 2 个元素时,`minCapacity` 为 2,此时 `elementData.length`(容量)在添加第一个元素后扩容成 `10` 了。此时,`minCapacity - elementData.length > 0` 不成立,所以不会进入 (执行)`grow(minCapacity)` 方法。 +- 当我们要 `add` 进第 1 个元素到 `ArrayList` 时,`elementData.length` 为 0(因为还是一个空的 list),因为执行了 `ensureCapacityInternal()` 方法,所以 `minCapacity` 此时为 10。此时,`minCapacity - elementData.length > 0` 成立,所以会进入 `grow(minCapacity)` 方法。 +- 当 `add` 第 2 个元素时,`minCapacity` 为 2,此时 `elementData.length`(容量)在添加第一个元素后扩容成 `10` 了。此时,`minCapacity - elementData.length > 0` 不成立,所以不会进入(执行)`grow(minCapacity)` 方法。 - 添加第 3、4···到第 10 个元素时,依然不会执行 grow 方法,数组容量都为 10。 -直到添加第 11 个元素,`minCapacity`(为 11)比 `elementData.length`(为 10)要大。进入 `grow` 方法进行扩容。 +直到添加第 11 个元素,`minCapacity`(为 11)比 `elementData.length`(为 10)要大。进入 `grow` 方法进行扩容。 #### grow 方法 @@ -732,23 +732,23 @@ private void grow(int minCapacity) { **`int newCapacity = oldCapacity + (oldCapacity >> 1)`,所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右(oldCapacity 为偶数就是 1.5 倍,否则是 1.5 倍左右)!** 奇偶不同,比如:10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数. -> ">>"(移位运算符):>>1 右移一位相当于除 2,右移 n 位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了 1 位所以相当于 oldCapacity /2。对于大数据的 2 进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源 +> ">>"(移位运算符):>>1 右移一位相当于除 2,右移 n 位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了 1 位所以相当于 oldCapacity /2。对于大数据的 2 进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源 -**我们再来通过例子探究一下`grow()` 方法:** +**我们再来通过例子探究一下 `grow()` 方法:** -- 当 `add` 第 1 个元素时,`oldCapacity` 为 0,经比较后第一个 if 判断成立,`newCapacity = minCapacity`(为 10)。但是第二个 if 判断不会成立,即 `newCapacity` 不比 `MAX_ARRAY_SIZE` 大,则不会进入 `hugeCapacity` 方法。数组容量为 10,`add` 方法中 return true,size 增为 1。 +- 当 `add` 第 1 个元素时,`oldCapacity` 为 0,经比较后第一个 if 判断成立,`newCapacity = minCapacity`(为 10)。但是第二个 if 判断不会成立,即 `newCapacity` 不比 `MAX_ARRAY_SIZE` 大,则不会进入 `hugeCapacity` 方法。数组容量为 10,`add` 方法中 return true,size 增为 1。 - 当 `add` 第 11 个元素进入 `grow` 方法时,`newCapacity` 为 15,比 `minCapacity`(为 11)大,第一个 if 判断不成立。新容量没有大于数组最大 size,不会进入 `hugeCapacity` 方法。数组容量扩为 15,add 方法中 return true,size 增为 11。 - 以此类推······ **这里补充一点比较重要,但是容易被忽视掉的知识点:** -- Java 中的 `length`属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性. -- Java 中的 `length()` 方法是针对字符串说的,如果想看这个字符串的长度则用到 `length()` 这个方法. -- Java 中的 `size()` 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看! +- Java 中的 `length` 属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性. +- Java 中的 `length()` 方法是针对字符串说的,如果想看这个字符串的长度则用到 `length()` 这个方法. +- Java 中的 `size()` 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看! #### hugeCapacity() 方法 -从上面 `grow()` 方法源码我们知道:如果新容量大于 `MAX_ARRAY_SIZE`,进入(执行) `hugeCapacity()` 方法来比较 `minCapacity` 和 `MAX_ARRAY_SIZE`,如果 `minCapacity` 大于最大容量,则新容量则为`Integer.MAX_VALUE`,否则,新容量大小则为 `MAX_ARRAY_SIZE` 即为 `Integer.MAX_VALUE - 8`。 +从上面 `grow()` 方法源码我们知道:如果新容量大于 `MAX_ARRAY_SIZE`,进入(执行) `hugeCapacity()` 方法来比较 `minCapacity` 和 `MAX_ARRAY_SIZE`,如果 `minCapacity` 大于最大容量,则新容量则为 `Integer.MAX_VALUE`,否则,新容量大小则为 `MAX_ARRAY_SIZE` 即为 `Integer.MAX_VALUE - 8`。 ```java private static int hugeCapacity(int minCapacity) { @@ -764,9 +764,9 @@ private static int hugeCapacity(int minCapacity) { } ``` -### `System.arraycopy()` 和 `Arrays.copyOf()`方法 +### `System.arraycopy()` 和 `Arrays.copyOf()` 方法 -阅读源码的话,我们就会发现 `ArrayList` 中大量调用了这两个方法。比如:我们上面讲的扩容操作以及`add(int index, E element)`、`toArray()` 等方法中都用到了该方法! +阅读源码的话,我们就会发现 `ArrayList` 中大量调用了这两个方法。比如:我们上面讲的扩容操作以及 `add(int index, E element)`、`toArray()` 等方法中都用到了该方法! #### `System.arraycopy()` 方法 @@ -835,7 +835,7 @@ public class ArraycopyTest { 0 1 99 2 3 0 0 0 0 0 ``` -#### `Arrays.copyOf()`方法 +#### `Arrays.copyOf()` 方法 源码: @@ -862,7 +862,7 @@ public class ArraycopyTest { } ``` -个人觉得使用 `Arrays.copyOf()`方法主要是为了给原有数组扩容,测试代码如下: +个人觉得使用 `Arrays.copyOf()` 方法主要是为了给原有数组扩容,测试代码如下: ```java public class ArrayscopyOfTest { @@ -888,13 +888,13 @@ public class ArrayscopyOfTest { **联系:** -看两者源代码可以发现 `copyOf()`内部实际调用了 `System.arraycopy()` 方法 +看两者源代码可以发现 `copyOf()` 内部实际调用了 `System.arraycopy()` 方法 **区别:** `arraycopy()` 需要目标数组,将原数组拷贝到你自己定义的数组里或者原数组,而且可以选择拷贝的起点和长度以及放入新数组中的位置 `copyOf()` 是系统自动在内部新建一个数组,并返回该数组。 -### `ensureCapacity`方法 +### `ensureCapacity` 方法 `ArrayList` 源码中有一个 `ensureCapacity` 方法不知道大家注意到没有,这个方法 `ArrayList` 内部没有被调用过,所以很显然是提供给用户调用的,那么这个方法有什么作用呢? @@ -967,6 +967,6 @@ public class EnsureCapacityTest { 使用ensureCapacity方法后:1773 ``` -通过运行结果,我们可以看出向 `ArrayList` 添加大量元素之前使用`ensureCapacity` 方法可以提升性能。不过,这个性能差距几乎可以忽略不计。而且,实际项目根本也不可能往 `ArrayList` 里面添加这么多元素。 +通过运行结果,我们可以看出向 `ArrayList` 添加大量元素之前使用 `ensureCapacity` 方法可以提升性能。不过,这个性能差距几乎可以忽略不计。而且,实际项目根本也不可能往 `ArrayList` 里面添加这么多元素。 diff --git a/docs/java/collection/concurrent-hash-map-source-code.md b/docs/java/collection/concurrent-hash-map-source-code.md index e33099a979b..28d4327b748 100644 --- a/docs/java/collection/concurrent-hash-map-source-code.md +++ b/docs/java/collection/concurrent-hash-map-source-code.md @@ -10,9 +10,9 @@ head: content: ConcurrentHashMap源码,线程安全Map,分段锁Segment,CAS操作,并发容器,JDK7与JDK8区别 --- -> 本文来自末读代码投稿: ,JavaGuide 对原文进行了大篇幅改进优化。 +> 本文来自末读代码投稿:,JavaGuide 对原文进行了大篇幅改进优化。 -上一篇文章介绍了 HashMap 源码,反响不错,也有很多同学发表了自己的观点,这次又来了,这次是 `ConcurrentHashMap` 了,作为线程安全的 HashMap ,它的使用频率也是很高。那么它的存储结构和实现原理是怎么样的呢? +上一篇文章介绍了 HashMap 源码,反响不错,也有很多同学发表了自己的观点,这次又来了,这次是 `ConcurrentHashMap` 了,作为线程安全的 HashMap,它的使用频率也是很高。那么它的存储结构和实现原理是怎么样的呢? ## 1. ConcurrentHashMap 1.7 @@ -255,7 +255,7 @@ final V put(K key, int hash, V value, boolean onlyIfAbsent) { 1. `tryLock()` 获取锁,获取不到使用 **`scanAndLockForPut`** 方法继续获取。 -2. 计算 put 的数据要放入的 index 位置,然后获取这个位置上的 `HashEntry` 。 +2. 计算 put 的数据要放入的 index 位置,然后获取这个位置上的 `HashEntry`。 3. 遍历 put 新元素,为什么要遍历?因为这里获取的 `HashEntry` 可能是一个空元素,也可能是链表已存在,所以要区别对待。 @@ -381,7 +381,7 @@ private void rehash(HashEntry node) { > > The nodes they replace will be garbage collectable as soon as they are no longer referenced by any reader thread that may be in the midst of concurrently traversing table -为什么需要再使用一个 `for` 循环找到 `lastRun` ,其实是为了减少对象创建的次数,正如注解中所说的: +为什么需要再使用一个 `for` 循环找到 `lastRun`,其实是为了减少对象创建的次数,正如注解中所说的: > 从统计上看,在默认的阈值下,当表容量加倍时,只有大约六分之一的节点需要被克隆。 > @@ -418,7 +418,7 @@ public V get(Object key) { ## 2. ConcurrentHashMap 1.8 -总的来说 ,`ConcurrentHashMap` 在 Java8 中相对于 Java7 来说变化还是挺大的, +总的来说,`ConcurrentHashMap` 在 Java8 中相对于 Java7 来说变化还是挺大的, ### 1. 存储结构 @@ -458,7 +458,7 @@ private final Node[] initTable() { } ``` -从源码中可以发现 `ConcurrentHashMap` 的初始化是通过**自旋和 CAS** 操作完成的。里面需要注意的是变量 `sizeCtl` (sizeControl 的缩写),它的值决定着当前的初始化状态。 +从源码中可以发现 `ConcurrentHashMap` 的初始化是通过**自旋和 CAS** 操作完成的。里面需要注意的是变量 `sizeCtl`(sizeControl 的缩写),它的值决定着当前的初始化状态。 1. -1 说明正在初始化,其他线程需要自旋等待 2. -N 说明 table 正在进行扩容,高 16 位表示扩容的标识戳,低 16 位减 1 为正在进行扩容的线程数 @@ -547,7 +547,7 @@ final V putVal(K key, V value, boolean onlyIfAbsent) { } ``` -1. 根据 key 计算出 hashcode 。 +1. 根据 key 计算出 hashcode。 2. 判断是否需要进行初始化。 @@ -594,7 +594,7 @@ public V get(Object key) { 1. 根据 hash 值计算位置。 2. 查找到指定位置,如果头节点就是要找的,直接返回它的 value. -3. 如果头节点 hash 值小于 0 ,说明正在扩容或者是红黑树,查找之。 +3. 如果头节点 hash 值小于 0,说明正在扩容或者是红黑树,查找之。 4. 如果是链表,遍历查找之。 ### 5. size 计数 @@ -660,7 +660,7 @@ public V get(Object key) { Java7 中 `ConcurrentHashMap` 使用的分段锁,也就是每一个 Segment 上同时只有一个线程可以操作,每一个 `Segment` 都是一个类似 `HashMap` 数组的结构,它可以扩容,它的冲突会转化为链表。但是 `Segment` 的个数一但初始化就不能改变。 -Java8 中的 `ConcurrentHashMap` 使用的 `Synchronized` 锁加 CAS 的机制。结构也由 Java7 中的 **`Segment` 数组 + `HashEntry` 数组 + 链表** 进化成了 **Node 数组 + 链表 / 红黑树**,Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时`TREEIFY_THRESHOLD = 8`会转化成红黑树,在冲突小于一定数量时`UNTREEIFY_THRESHOLD = 6`又退回链表。 +Java8 中的 `ConcurrentHashMap` 使用的 `Synchronized` 锁加 CAS 的机制。结构也由 Java7 中的 **`Segment` 数组 + `HashEntry` 数组 + 链表** 进化成了 **Node 数组 + 链表 / 红黑树**,Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时 `TREEIFY_THRESHOLD = 8` 会转化成红黑树,在冲突小于一定数量时 `UNTREEIFY_THRESHOLD = 6` 又退回链表。 有些同学可能对 `Synchronized` 的性能存在疑问,其实 `Synchronized` 锁自从引入锁升级策略后,性能不再是问题,有兴趣的同学可以自己了解下 `Synchronized` 的**锁升级**。 diff --git a/docs/java/collection/copyonwritearraylist-source-code.md b/docs/java/collection/copyonwritearraylist-source-code.md index 8c5ec08be89..15c28ebdc71 100644 --- a/docs/java/collection/copyonwritearraylist-source-code.md +++ b/docs/java/collection/copyonwritearraylist-source-code.md @@ -14,7 +14,7 @@ head: 在 JDK1.5 之前,如果想要使用并发安全的 `List` 只能选择 `Vector`。而 `Vector` 是一种老旧的集合,已经被淘汰。`Vector` 对于增删改查等方法基本都加了 `synchronized`,这种方式虽然能够保证同步,但这相当于对整个 `Vector` 加上了一把大锁,使得每个方法执行的时候都要去获得锁,导致性能非常低下。 -JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线程安全且并发性能良好的容器,其中唯一的线程安全 `List` 实现就是 `CopyOnWriteArrayList` 。关于`java.util.concurrent` 包下常见并发容器的总结,可以看我写的这篇文章:[Java 常见并发容器总结](https://javaguide.cn/java/concurrent/java-concurrent-collections.html) 。 +JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线程安全且并发性能良好的容器,其中唯一的线程安全 `List` 实现就是 `CopyOnWriteArrayList`。关于 `java.util.concurrent` 包下常见并发容器的总结,可以看我写的这篇文章:[Java 常见并发容器总结](https://javaguide.cn/java/concurrent/java-concurrent-collections.html)。 ### CopyOnWriteArrayList 到底有什么厉害之处? @@ -26,13 +26,13 @@ JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线 ### Copy-On-Write 的思想是什么? -`CopyOnWriteArrayList`名字中的“Copy-On-Write”即写时复制,简称 COW。 +`CopyOnWriteArrayList` 名字中的“Copy-On-Write”即写时复制,简称 COW。 下面是维基百科对 Copy-On-Write 的介绍,介绍的挺不错: > 写入时复制(英语:Copy-on-write,简称 COW)是一种计算机程序设计领域的优化策略。其核心思想是,如果有多个调用者(callers)同时请求相同资源(如内存或磁盘上的数据存储),他们会共同获取相同的指针指向相同的资源,直到某个调用者试图修改资源的内容时,系统才会真正复制一份专用副本(private copy)给该调用者,而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的。此作法主要的优点是如果调用者没有修改该资源,就不会有副本(private copy)被创建,因此多个调用者只是读取操作时可以共享同一份资源。 -这里再以 `CopyOnWriteArrayList`为例介绍:当需要修改( `add`,`set`、`remove` 等操作) `CopyOnWriteArrayList` 的内容时,不会直接修改原数组,而是会先创建底层数组的副本,对副本数组进行修改,修改完之后再将修改后的数组赋值回去,这样就可以保证写操作不会影响读操作了。 +这里再以 `CopyOnWriteArrayList` 为例介绍:当需要修改(`add`,`set`、`remove` 等操作) `CopyOnWriteArrayList` 的内容时,不会直接修改原数组,而是会先创建底层数组的副本,对副本数组进行修改,修改完之后再将修改后的数组赋值回去,这样就可以保证写操作不会影响读操作了。 可以看出,写时复制机制非常适合读多写少的并发场景,能够极大地提高系统的并发性能。 @@ -61,8 +61,8 @@ implements List, RandomAccess, Cloneable, Serializable `CopyOnWriteArrayList` 实现了以下接口: - `List` : 表明它是一个列表,支持添加、删除、查找等操作,并且可以通过下标进行访问。 -- `RandomAccess` :这是一个标志接口,表明实现这个接口的 `List` 集合是支持 **快速随机访问** 的。 -- `Cloneable` :表明它具有拷贝能力,可以进行深拷贝或浅拷贝操作。 +- `RandomAccess`:这是一个标志接口,表明实现这个接口的 `List` 集合是支持 **快速随机访问** 的。 +- `Cloneable`:表明它具有拷贝能力,可以进行深拷贝或浅拷贝操作。 - `Serializable` : 表明它可以进行序列化操作,也就是可以将对象转换为字节流进行持久化存储或网络传输,非常方便。 ![CopyOnWriteArrayList 类图](https://oss.javaguide.cn/github/javaguide/java/collection/copyonwritearraylist-class-diagram.png) @@ -99,13 +99,13 @@ public CopyOnWriteArrayList(E[] toCopyIn) { ### 插入元素 -`CopyOnWriteArrayList` 的 `add()`方法有三个版本: +`CopyOnWriteArrayList` 的 `add()` 方法有三个版本: - `add(E e)`:在 `CopyOnWriteArrayList` 的尾部插入元素。 - `add(int index, E element)`:在 `CopyOnWriteArrayList` 的指定位置插入元素。 - `addIfAbsent(E e)`:如果指定元素不存在,那么添加该元素。如果成功添加元素则返回 true。 -这里以`add(E e)`为例进行介绍: +这里以 `add(E e)` 为例进行介绍: ```java // 插入元素到 CopyOnWriteArrayList 的尾部 @@ -134,7 +134,7 @@ public boolean add(E e) { 从上面的源码可以看出: -- `add`方法内部用到了 `ReentrantLock` 加锁,保证了同步,避免了多线程写的时候会复制出多个副本出来。锁被修饰保证了锁的内存地址肯定不会被修改,并且,释放锁的逻辑放在 `finally` 中,可以保证锁能被释放。 +- `add` 方法内部用到了 `ReentrantLock` 加锁,保证了同步,避免了多线程写的时候会复制出多个副本出来。锁被修饰保证了锁的内存地址肯定不会被修改,并且,释放锁的逻辑放在 `finally` 中,可以保证锁能被释放。 - `CopyOnWriteArrayList` 通过复制底层数组的方式实现写操作,即先创建一个新的数组来容纳新添加的元素,然后在新数组中进行写操作,最后将新数组赋值给底层数组的引用,替换掉旧的数组。这也就证明了我们前面说的:`CopyOnWriteArrayList` 线程安全的核心在于其采用了 **写时复制(Copy-On-Write)** 的策略。 - 每次写操作都需要通过 `Arrays.copyOf` 复制底层数组,时间复杂度是 O(n) 的,且会占用额外的内存空间。因此,`CopyOnWriteArrayList` 适用于读多写少的场景,在写操作不频繁且内存资源充足的情况下,可以提升系统的性能表现。 - `CopyOnWriteArrayList` 中并没有类似于 `ArrayList` 的 `grow()` 方法扩容的操作。 @@ -162,17 +162,17 @@ private E get(Object[] a, int index) { } ``` -不过,`get`方法是弱一致性的,在某些情况下可能读到旧的元素值。 +不过,`get` 方法是弱一致性的,在某些情况下可能读到旧的元素值。 -`get(int index)`方法是分两步进行的: +`get(int index)` 方法是分两步进行的: -1. 通过`getArray()`获取当前数组的引用; +1. 通过 `getArray()` 获取当前数组的引用; 2. 直接从数组中获取下标为 index 的元素。 这个过程并没有加锁,所以在并发环境下可能出现如下情况: -1. 线程 1 调用`get(int index)`方法获取值,内部通过`getArray()`方法获取到了 array 属性值; -2. 线程 2 调用`CopyOnWriteArrayList`的`add`、`set`、`remove` 等修改方法时,内部通过`setArray`方法修改了`array`属性的值; +1. 线程 1 调用 `get(int index)` 方法获取值,内部通过 `getArray()` 方法获取到了 array 属性值; +2. 线程 2 调用 `CopyOnWriteArrayList` 的 `add`、`set`、`remove` 等修改方法时,内部通过 `setArray` 方法修改了 `array` 属性的值; 3. 线程 1 还是从旧的 `array` 数组中取值。 ### 获取列表中元素的个数 @@ -183,18 +183,18 @@ public int size() { } ``` -`CopyOnWriteArrayList`中的`array`数组每次复制都刚好能够容纳下所有元素,并不像`ArrayList`那样会预留一定的空间。因此,`CopyOnWriteArrayList`中并没有`size`属性`CopyOnWriteArrayList`的底层数组的长度就是元素个数,因此`size()`方法只要返回数组长度就可以了。 +`CopyOnWriteArrayList` 中的 `array` 数组每次复制都刚好能够容纳下所有元素,并不像 `ArrayList` 那样会预留一定的空间。因此,`CopyOnWriteArrayList` 中并没有 `size` 属性 `CopyOnWriteArrayList` 的底层数组的长度就是元素个数,因此 `size()` 方法只要返回数组长度就可以了。 ### 删除元素 -`CopyOnWriteArrayList`删除元素相关的方法一共有 4 个: +`CopyOnWriteArrayList` 删除元素相关的方法一共有 4 个: 1. `remove(int index)`:移除此列表中指定位置上的元素。将任何后续元素向左移动(从它们的索引中减去 1)。 2. `boolean remove(Object o)`:删除此列表中首次出现的指定元素,如果不存在该元素则返回 false。 3. `boolean removeAll(Collection c)`:从此列表中删除指定集合中包含的所有元素。 4. `void clear()`:移除此列表中的所有元素。 -这里以`remove(int index)`为例进行介绍: +这里以 `remove(int index)` 为例进行介绍: ```java public E remove(int index) { @@ -234,7 +234,7 @@ public E remove(int index) { ### 判断元素是否存在 -`CopyOnWriteArrayList`提供了两个用于判断指定元素是否在列表中的方法: +`CopyOnWriteArrayList` 提供了两个用于判断指定元素是否在列表中的方法: - `contains(Object o)`:判断是否包含指定元素。 - `containsAll(Collection c)`:判断是否保证指定集合的全部元素。 diff --git a/docs/java/collection/delayqueue-source-code.md b/docs/java/collection/delayqueue-source-code.md index 9c5f0712c2e..9563605ef8b 100644 --- a/docs/java/collection/delayqueue-source-code.md +++ b/docs/java/collection/delayqueue-source-code.md @@ -12,11 +12,11 @@ head: ## DelayQueue 简介 -`DelayQueue` 是 JUC 包(`java.util.concurrent)`为我们提供的延迟队列,用于实现延时任务比如订单下单 15 分钟未支付直接取消。它是 `BlockingQueue` 的一种,底层是一个基于 `PriorityQueue` 实现的一个无界队列,是线程安全的。关于`PriorityQueue`可以参考笔者编写的这篇文章:[PriorityQueue 源码分析](./priorityqueue-source-code.md) 。 +`DelayQueue` 是 JUC 包(`java.util.concurrent)` 为我们提供的延迟队列,用于实现延时任务比如订单下单 15 分钟未支付直接取消。它是 `BlockingQueue` 的一种,底层是一个基于 `PriorityQueue` 实现的一个无界队列,是线程安全的。关于 `PriorityQueue` 可以参考笔者编写的这篇文章:[PriorityQueue 源码分析](./priorityqueue-source-code.md)。 ![BlockingQueue 的实现类](https://oss.javaguide.cn/github/javaguide/java/collection/blocking-queue-hierarchy.png) -`DelayQueue` 中存放的元素必须实现 `Delayed` 接口,并且需要重写 `getDelay()`方法(计算是否到期)。 +`DelayQueue` 中存放的元素必须实现 `Delayed` 接口,并且需要重写 `getDelay()` 方法(计算是否到期)。 ```java public interface Delayed extends Comparable { @@ -24,7 +24,7 @@ public interface Delayed extends Comparable { } ``` -默认情况下, `DelayQueue` 会按照到期时间升序编排任务。只有当元素过期时(`getDelay()`方法返回值小于等于 0),才能从队列中取出。 +默认情况下, `DelayQueue` 会按照到期时间升序编排任务。只有当元素过期时(`getDelay()` 方法返回值小于等于 0),才能从队列中取出。 ## DelayQueue 发展史 @@ -42,7 +42,7 @@ public interface Delayed extends Comparable { ![延迟任务](https://oss.javaguide.cn/github/javaguide/java/collection/delayed-task.png) -对此我们可以使用 `DelayQueue` 来实现,所以我们首先需要继承 `Delayed` 实现 `DelayedTask`,实现 `getDelay` 方法以及优先级比较 `compareTo`。 +对此我们可以使用 `DelayQueue` 来实现,所以我们首先需要继承 `Delayed` 实现 `DelayedTask`,实现 `getDelay` 方法以及优先级比较 `compareTo`。 ```java /** @@ -152,13 +152,13 @@ private final Condition available = lock.newCondition(); ``` - `lock` : 我们都知道 `DelayQueue` 存取是线程安全的,所以为了保证存取元素时线程安全,我们就需要在存取时上锁,而 `DelayQueue` 就是基于 `ReentrantLock` 独占锁确保存取操作的线程安全。 -- `q` : 延迟队列要求元素按照到期时间进行升序排列,所以元素添加时势必需要进行优先级排序,所以 `DelayQueue` 底层元素的存取都是通过这个优先队列 `PriorityQueue` 的成员变量 `q` 来管理的。 -- `leader` : 延迟队列的任务只有到期之后才会执行,对于没有到期的任务只有等待,为了确保优先级最高的任务到期后可以即刻被执行,设计者就用 `leader` 来管理延迟任务,只有 `leader` 所指向的线程才具备定时等待任务到期执行的权限,而其他那些优先级低的任务只能无限期等待,直到 `leader` 线程执行完手头的延迟任务后唤醒它。 +- `q` : 延迟队列要求元素按照到期时间进行升序排列,所以元素添加时势必需要进行优先级排序,所以 `DelayQueue` 底层元素的存取都是通过这个优先队列 `PriorityQueue` 的成员变量 `q` 来管理的。 +- `leader` : 延迟队列的任务只有到期之后才会执行,对于没有到期的任务只有等待,为了确保优先级最高的任务到期后可以即刻被执行,设计者就用 `leader` 来管理延迟任务,只有 `leader` 所指向的线程才具备定时等待任务到期执行的权限,而其他那些优先级低的任务只能无限期等待,直到 `leader` 线程执行完手头的延迟任务后唤醒它。 - `available` : 上文讲述 `leader` 线程时提到的等待唤醒操作的交互就是通过 `available` 实现的,假如线程 1 尝试在空的 `DelayQueue` 获取任务时,`available` 就会将其放入等待队列中。直到有一个线程添加一个延迟任务后通过 `available` 的 `signal` 方法将其唤醒。 ### 构造方法 -相较于其他的并发容器,延迟队列的构造方法比较简单,它只有两个构造方法,因为所有成员变量在类加载时都已经初始完成了,所以默认构造方法什么也没做。还有一个传入 `Collection` 对象的构造方法,它会将调用 `addAll()`方法将集合元素存到优先队列 `q` 中。 +相较于其他的并发容器,延迟队列的构造方法比较简单,它只有两个构造方法,因为所有成员变量在类加载时都已经初始完成了,所以默认构造方法什么也没做。还有一个传入 `Collection` 对象的构造方法,它会将调用 `addAll()` 方法将集合元素存到优先队列 `q` 中。 ```java public DelayQueue() {} @@ -174,9 +174,9 @@ public DelayQueue(Collection c) { `offer` 方法的整体逻辑为: -1. 尝试获取 `lock` 。 -2. 如果上锁成功,则调 `q` 的 `offer` 方法将元素存放到优先队列中。 -3. 调用 `peek` 方法看看当前队首元素是否就是本次入队的元素,如果是则说明当前这个元素是即将到期的任务(即优先级最高的元素),于是将 `leader` 设置为空,通知因为队列为空时调用 `take` 等方法导致阻塞的线程来争抢元素。 +1. 尝试获取 `lock`。 +2. 如果上锁成功,则调 `q` 的 `offer` 方法将元素存放到优先队列中。 +3. 调用 `peek` 方法看看当前队首元素是否就是本次入队的元素,如果是则说明当前这个元素是即将到期的任务(即优先级最高的元素),于是将 `leader` 设置为空,通知因为队列为空时调用 `take` 等方法导致阻塞的线程来争抢元素。 4. 上述步骤执行完成,释放 `lock`。 5. 返回 true。 @@ -229,9 +229,9 @@ public boolean offer(E e) { ![](https://oss.javaguide.cn/github/javaguide/java/collection/delayqueue-take-2.png) -如果元素不为空,则判断当前任务是否到期,如果元素到期,则直接返回出去。如果元素未到期,则判断当前 `leader` 线程(`DelayQueue` 中唯一一个可以等待并获取元素的线程引用)是否为空,若不为空,则说明当前 `leader` 正在等待执行一个优先级比当前元素还高的元素到期,故当前线程 t1 只能调用 `await` 进入无限期等待,等到 `leader` 取得元素后唤醒。反之,若 `leader` 线程为空,则将当前线程设置为 leader 并进入有限期等待,到期后取出元素并返回。 +如果元素不为空,则判断当前任务是否到期,如果元素到期,则直接返回出去。如果元素未到期,则判断当前 `leader` 线程(`DelayQueue` 中唯一一个可以等待并获取元素的线程引用)是否为空,若不为空,则说明当前 `leader` 正在等待执行一个优先级比当前元素还高的元素到期,故当前线程 t1 只能调用 `await` 进入无限期等待,等到 `leader` 取得元素后唤醒。反之,若 `leader` 线程为空,则将当前线程设置为 leader 并进入有限期等待,到期后取出元素并返回。 -自此我们阻塞式获取元素的逻辑都已完成后,源码如下,读者可自行参阅: +自此我们阻塞式获取元素的逻辑都已完成后,源码如下,读者可自行参阅: ```java public E take() throws InterruptedException { @@ -281,15 +281,15 @@ public E take() throws InterruptedException { } ``` -我们再来看看非阻塞的获取元素方法 `poll` ,逻辑比较简单,整体步骤如下: +我们再来看看非阻塞的获取元素方法 `poll`,逻辑比较简单,整体步骤如下: 1. 尝试获取可重入锁。 -2. 查看队列第一个元素,判断元素是否为空。 +2. 查看队列第一个元素,判断元素是否为空。 3. 若元素为空,或者元素未到期,则直接返回空。 4. 若元素不为空且到期了,直接调用 `poll` 返回出去。 -5. 释放可重入锁 `lock` 。 +5. 释放可重入锁 `lock`。 -源码如下,读者可自行参阅源码及注释: +源码如下,读者可自行参阅源码及注释: ```java public E poll() { @@ -346,7 +346,7 @@ public E peek() { ### DelayQueue 的使用场景有哪些? -`DelayQueue` 通常用于实现定时任务调度和缓存过期删除等场景。在定时任务调度中,需要将需要执行的任务封装成延迟任务对象,并将其添加到 `DelayQueue` 中,`DelayQueue` 会自动按照剩余延迟时间进行升序排序(默认情况),以保证任务能够按照时间先后顺序执行。对于缓存过期这个场景而言,在数据被缓存到内存之后,我们可以将缓存的 key 封装成一个延迟的删除任务,并将其添加到 `DelayQueue` 中,当数据过期时,拿到这个任务的 key,将这个 key 从内存中移除。 +`DelayQueue` 通常用于实现定时任务调度和缓存过期删除等场景。在定时任务调度中,需要将需要执行的任务封装成延迟任务对象,并将其添加到 `DelayQueue` 中,`DelayQueue` 会自动按照剩余延迟时间进行升序排序(默认情况),以保证任务能够按照时间先后顺序执行。对于缓存过期这个场景而言,在数据被缓存到内存之后,我们可以将缓存的 key 封装成一个延迟的删除任务,并将其添加到 `DelayQueue` 中,当数据过期时,拿到这个任务的 key,将这个 key 从内存中移除。 ### DelayQueue 中 Delayed 接口的作用是什么? @@ -359,6 +359,6 @@ public E peek() { ## 参考文献 - 《深入理解高并发编程:JDK 核心技术》: -- 一口气说出 Java 6 种延时队列的实现方法(面试官也得服): +- 一口气说出 Java 6 种延时队列的实现方法(面试官也得服): - 图解 DelayQueue 源码(java 8)——延时队列的小九九: diff --git a/docs/java/collection/hashmap-source-code.md b/docs/java/collection/hashmap-source-code.md index 204121bbf32..151acf40c3b 100644 --- a/docs/java/collection/hashmap-source-code.md +++ b/docs/java/collection/hashmap-source-code.md @@ -61,7 +61,7 @@ static int hash(int h) { } ``` -相比于 JDK1.8 的 hash 方法 ,JDK 1.7 的 hash 方法的性能会稍差一点点,因为毕竟扰动了 4 次。 +相比于 JDK1.8 的 hash 方法,JDK 1.7 的 hash 方法的性能会稍差一点点,因为毕竟扰动了 4 次。 所谓 **“拉链法”** 就是:将链表和数组相结合。也就是说创建一个链表数组,数组中每一格就是一个链表。若遇到哈希冲突,则将冲突的值加到链表中即可。 @@ -71,7 +71,7 @@ static int hash(int h) { 相比于之前的版本,JDK1.8 以后在解决哈希冲突时有了较大的变化。 -当链表长度大于阈值(默认为 8)时,会首先调用 `treeifyBin()`方法。这个方法会根据 HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下,才会执行转换红黑树操作,以减少搜索时间。否则,就是只是执行 `resize()` 方法对数组扩容。相关源码这里就不贴了,重点关注 `treeifyBin()`方法即可! +当链表长度大于阈值(默认为 8)时,会首先调用 `treeifyBin()` 方法。这个方法会根据 HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下,才会执行转换红黑树操作,以减少搜索时间。否则,就是只是执行 `resize()` 方法对数组扩容。相关源码这里就不贴了,重点关注 `treeifyBin()` 方法即可! ![jdk1.8之后的内部结构-HashMap](https://oss.javaguide.cn/github/javaguide/java/collection/jdk1.8_hashmap.png) @@ -269,7 +269,7 @@ HashMap 只提供了 put 用于添加元素,putVal 方法只是给 put 方法 **对 putVal 方法添加元素的分析如下:** 1. 如果定位到的数组位置没有元素 就直接插入。 -2. 如果定位到的数组位置有元素就和要插入的 key 比较,如果 key 相同就直接覆盖,如果 key 不相同,就判断 p 是否是一个树节点,如果是就调用`e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value)`将元素添加进入。如果不是就遍历链表插入(插入的是链表尾部)。 +2. 如果定位到的数组位置有元素就和要插入的 key 比较,如果 key 相同就直接覆盖,如果 key 不相同,就判断 p 是否是一个树节点,如果是就调用 `e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value)` 将元素添加进入。如果不是就遍历链表插入(插入的是链表尾部)。 ![ ](https://oss.javaguide.cn/github/javaguide/database/sql/put.png) diff --git a/docs/java/collection/java-collection-precautions-for-use.md b/docs/java/collection/java-collection-precautions-for-use.md index 2214ee59beb..4a8e7f3decc 100644 --- a/docs/java/collection/java-collection-precautions-for-use.md +++ b/docs/java/collection/java-collection-precautions-for-use.md @@ -22,7 +22,7 @@ head: 这是因为 `isEmpty()` 方法的可读性更好,并且时间复杂度为 `O(1)`。 -绝大部分我们使用的集合的 `size()` 方法的时间复杂度也是 `O(1)`,不过,也有很多复杂度不是 `O(1)` 的,比如 `java.util.concurrent` 包下的 `ConcurrentLinkedQueue`。`ConcurrentLinkedQueue` 的 `isEmpty()` 方法通过 `first()` 方法进行判断,其中 `first()` 方法返回的是队列中第一个值不为 `null` 的节点(节点值为`null`的原因是在迭代器中使用的逻辑删除) +绝大部分我们使用的集合的 `size()` 方法的时间复杂度也是 `O(1)`,不过,也有很多复杂度不是 `O(1)` 的,比如 `java.util.concurrent` 包下的 `ConcurrentLinkedQueue`。`ConcurrentLinkedQueue` 的 `isEmpty()` 方法通过 `first()` 方法进行判断,其中 `first()` 方法返回的是队列中第一个值不为 `null` 的节点(节点值为 `null` 的原因是在迭代器中使用的逻辑删除) ```java public boolean isEmpty() { return first() == null; } @@ -43,7 +43,7 @@ Node first() { } ``` -由于在插入与删除元素时,都会执行`updateHead(h, p)`方法,所以该方法的执行的时间复杂度可以近似为`O(1)`。而 `size()` 方法需要遍历整个链表,时间复杂度为`O(n)` +由于在插入与删除元素时,都会执行 `updateHead(h, p)` 方法,所以该方法的执行的时间复杂度可以近似为 `O(1)`。而 `size()` 方法需要遍历整个链表,时间复杂度为 `O(n)` ```java public int size() { @@ -56,7 +56,7 @@ public int size() { } ``` -此外,在`ConcurrentHashMap` 1.7 中 `size()` 方法和 `isEmpty()` 方法的时间复杂度也不太一样。`ConcurrentHashMap` 1.7 将元素数量存储在每个`Segment` 中,`size()` 方法需要统计每个 `Segment` 的数量,而 `isEmpty()` 只需要找到第一个不为空的 `Segment` 即可。但是在`ConcurrentHashMap` 1.8 中的 `size()` 方法和 `isEmpty()` 都需要调用 `sumCount()` 方法,其时间复杂度与 `Node` 数组的大小有关。下面是 `sumCount()` 方法的源码: +此外,在 `ConcurrentHashMap` 1.7 中 `size()` 方法和 `isEmpty()` 方法的时间复杂度也不太一样。`ConcurrentHashMap` 1.7 将元素数量存储在每个 `Segment` 中,`size()` 方法需要统计每个 `Segment` 的数量,而 `isEmpty()` 只需要找到第一个不为空的 `Segment` 即可。但是在 `ConcurrentHashMap` 1.8 中的 `size()` 方法和 `isEmpty()` 都需要调用 `sumCount()` 方法,其时间复杂度与 `Node` 数组的大小有关。下面是 `sumCount()` 方法的源码: ```java final long sumCount() { @@ -70,7 +70,7 @@ final long sumCount() { } ``` -这是因为在并发的环境下,`ConcurrentHashMap` 将每个 `Node` 中节点的数量存储在 `CounterCell[]` 数组中。在 `ConcurrentHashMap` 1.7 中,将元素数量存储在每个`Segment` 中,`size()` 方法需要统计每个 `Segment` 的数量,而 `isEmpty()` 只需要找到第一个不为空的 `Segment` 即可。 +这是因为在并发的环境下,`ConcurrentHashMap` 将每个 `Node` 中节点的数量存储在 `CounterCell[]` 数组中。在 `ConcurrentHashMap` 1.7 中,将元素数量存储在每个 `Segment` 中,`size()` 方法需要统计每个 `Segment` 的数量,而 `isEmpty()` 只需要找到第一个不为空的 `Segment` 即可。 ## 集合转 Map @@ -94,7 +94,7 @@ bookList.stream().collect(Collectors.toMap(Person::getName, Person::getPhoneNumb 下面我们来解释一下原因。 -首先,我们来看 `java.util.stream.Collectors` 类的 `toMap()` 方法 ,可以看到其内部调用了 `Map` 接口的 `merge()` 方法。 +首先,我们来看 `java.util.stream.Collectors` 类的 `toMap()` 方法,可以看到其内部调用了 `Map` 接口的 `merge()` 方法。 ```java public static > @@ -111,7 +111,7 @@ Collector toMap(Function keyMapper, `Map` 接口的 `merge()` 方法如下,这个方法是接口中的默认实现。 -> 如果你还不了解 Java 8 新特性的话,请看这篇文章:[《Java8 新特性总结》](https://mp.weixin.qq.com/s/ojyl7B6PiHaTWADqmUq2rw) 。 +> 如果你还不了解 Java 8 新特性的话,请看这篇文章:[《Java8 新特性总结》](https://mp.weixin.qq.com/s/ojyl7B6PiHaTWADqmUq2rw)。 ```java default V merge(K key, V value, @@ -140,7 +140,7 @@ public static T requireNonNull(T obj) { } ``` -> `Collectors`也提供了无需 mergeFunction 的`toMap()`方法,但此时若出现 key 冲突,则会抛出`duplicateKeyException`异常,因此强烈建议使用`toMap()`方法必填 mergeFunction。 +> `Collectors` 也提供了无需 mergeFunction 的 `toMap()` 方法,但此时若出现 key 冲突,则会抛出 `duplicateKeyException` 异常,因此强烈建议使用 `toMap()` 方法必填 mergeFunction。 ## 集合遍历 @@ -148,15 +148,15 @@ public static T requireNonNull(T obj) { > **不要在 foreach 循环里进行元素的 `remove/add` 操作。remove 元素请使用 `Iterator` 方式,如果并发操作,需要对 `Iterator` 对象加锁。** -通过反编译你会发现 foreach 语法底层其实还是依赖 `Iterator` 。不过, `remove/add` 操作直接调用的是集合自己的方法,而不是 `Iterator` 的 `remove/add`方法 +通过反编译你会发现 foreach 语法底层其实还是依赖 `Iterator`。不过, `remove/add` 操作直接调用的是集合自己的方法,而不是 `Iterator` 的 `remove/add` 方法 -这就导致 `Iterator` 莫名其妙地发现自己有元素被 `remove/add` ,然后,它就会抛出一个 `ConcurrentModificationException` 来提示用户发生了并发修改异常。这就是单线程状态下产生的 **fail-fast 机制**。 +这就导致 `Iterator` 莫名其妙地发现自己有元素被 `remove/add`,然后,它就会抛出一个 `ConcurrentModificationException` 来提示用户发生了并发修改异常。这就是单线程状态下产生的 **fail-fast 机制**。 -> **fail-fast 机制**:多个线程对 fail-fast 集合进行修改的时候,可能会抛出`ConcurrentModificationException`。 即使是单线程下也有可能会出现这种情况,上面已经提到过。 +> **fail-fast 机制**:多个线程对 fail-fast 集合进行修改的时候,可能会抛出 `ConcurrentModificationException`。 即使是单线程下也有可能会出现这种情况,上面已经提到过。 > -> 相关阅读:[什么是 fail-fast](https://www.cnblogs.com/54chensongxia/p/12470446.html) 。 +> 相关阅读:[什么是 fail-fast](https://www.cnblogs.com/54chensongxia/p/12470446.html)。 -Java8 开始,可以使用 `Collection#removeIf()`方法删除满足特定条件的元素,如 +Java8 开始,可以使用 `Collection#removeIf()` 方法删除满足特定条件的元素,如 ```java List list = new ArrayList<>(); @@ -170,7 +170,7 @@ System.out.println(list); /* [1, 3, 5, 7, 9] */ 除了上面介绍的直接使用 `Iterator` 进行遍历操作之外,你还可以: - 使用普通的 for 循环 -- 使用 fail-safe 的集合类。`java.util`包下面的所有的集合类都是 fail-fast 的,而`java.util.concurrent`包下面的所有的类都是 fail-safe 的。 +- 使用 fail-safe 的集合类。`java.util` 包下面的所有的集合类都是 fail-fast 的,而 `java.util.concurrent` 包下面的所有的类都是 fail-safe 的。 - …… ## 集合去重 @@ -249,7 +249,7 @@ public int indexOf(Object o) { > **使用集合转数组的方法,必须使用集合的 `toArray(T[] array)`,传入的是类型完全一致、长度为 0 的空数组。** -`toArray(T[] array)` 方法的参数是一个泛型数组,如果 `toArray` 方法中没有传递任何参数的话返回的是 `Object`类 型数组。 +`toArray(T[] array)` 方法的参数是一个泛型数组,如果 `toArray` 方法中没有传递任何参数的话返回的是 `Object` 类 型数组。 ```java String [] s= new String[]{ @@ -261,7 +261,7 @@ Collections.reverse(list); s=list.toArray(new String[0]); ``` -由于 JVM 优化,`new String[0]`作为`Collection.toArray()`方法的参数现在使用更好,`new String[0]`就是起一个模板的作用,指定了返回数组的类型,0 是为了节省空间,因为它只是为了说明返回的类型。详见: +由于 JVM 优化,`new String[0]` 作为 `Collection.toArray()` 方法的参数现在使用更好,`new String[0]` 就是起一个模板的作用,指定了返回数组的类型,0 是为了节省空间,因为它只是为了说明返回的类型。详见: ## 数组转集合 @@ -271,7 +271,7 @@ s=list.toArray(new String[0]); 我在之前的一个项目中就遇到一个类似的坑。 -`Arrays.asList()`在平时开发中还是比较常见的,我们可以使用它将一个数组转换为一个 `List` 集合。 +`Arrays.asList()` 在平时开发中还是比较常见的,我们可以使用它将一个数组转换为一个 `List` 集合。 ```java String[] myArray = {"Apple", "Banana", "Orange"}; @@ -294,7 +294,7 @@ public static List asList(T... a) { 下面我们来总结一下使用注意事项。 -**1、`Arrays.asList()`是泛型方法,传递的数组必须是对象数组,而不是基本类型。** +**1、`Arrays.asList()` 是泛型方法,传递的数组必须是对象数组,而不是基本类型。** ```java int[] myArray = {1, 2, 3}; @@ -314,7 +314,7 @@ System.out.println(array[0]);//1 Integer[] myArray = {1, 2, 3}; ``` -**2、使用集合的修改方法: `add()`、`remove()`、`clear()`会抛出异常。** +**2、使用集合的修改方法: `add()`、`remove()`、`clear()` 会抛出异常。** ```java List myList = Arrays.asList(1, 2, 3); @@ -323,7 +323,7 @@ myList.remove(1);//运行时报错:UnsupportedOperationException myList.clear();//运行时报错:UnsupportedOperationException ``` -`Arrays.asList()` 方法返回的并不是 `java.util.ArrayList` ,而是 `java.util.Arrays` 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。 +`Arrays.asList()` 方法返回的并不是 `java.util.ArrayList`,而是 `java.util.Arrays` 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。 ```java List myList = Arrays.asList(1, 2, 3); @@ -375,7 +375,7 @@ System.out.println(myList.getClass());//class java.util.Arrays$ArrayList } ``` -我们再看一下`java.util.AbstractList`的 `add/remove/clear` 方法就知道为什么会抛出 `UnsupportedOperationException` 了。 +我们再看一下 `java.util.AbstractList` 的 `add/remove/clear` 方法就知道为什么会抛出 `UnsupportedOperationException` 了。 ```java public E remove(int index) { @@ -427,7 +427,7 @@ System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList List list = new ArrayList<>(Arrays.asList("a", "b", "c")) ``` -3、使用 Java8 的 `Stream`(推荐) +3、使用 Java8 的 `Stream`(推荐) ```java Integer [] myArray = { 1, 2, 3 }; @@ -461,7 +461,7 @@ List list = new ArrayList(); CollectionUtils.addAll(list, str); ``` -6、 使用 Java9 的 `List.of()`方法 +6、 使用 Java9 的 `List.of()` 方法 ```java Integer[] array = {1, 2, 3}; diff --git a/docs/java/collection/java-collection-questions-01.md b/docs/java/collection/java-collection-questions-01.md index ee2d2e04fc2..de3eac3ee7d 100644 --- a/docs/java/collection/java-collection-questions-01.md +++ b/docs/java/collection/java-collection-questions-01.md @@ -16,20 +16,20 @@ head: ### Java 集合概览 -Java 集合,也叫作容器,主要是由两大接口派生而来:一个是 `Collection`接口,主要用于存放单一元素;另一个是 `Map` 接口,主要用于存放键值对。对于`Collection` 接口,下面又有三个主要的子接口:`List`、`Set` 、 `Queue`。 +Java 集合,也叫作容器,主要是由两大接口派生而来:一个是 `Collection` 接口,主要用于存放单一元素;另一个是 `Map` 接口,主要用于存放键值对。对于 `Collection` 接口,下面又有三个主要的子接口:`List`、`Set`、 `Queue`。 Java 集合框架如下图所示: ![Java 集合框架概览](https://oss.javaguide.cn/github/javaguide/java/collection/java-collection-hierarchy.png) -注:图中只列举了主要的继承派生关系,并没有列举所有关系。比方省略了`AbstractList`, `NavigableSet`等抽象类以及其他的一些辅助类,如想深入了解,可自行查看源码。 +注:图中只列举了主要的继承派生关系,并没有列举所有关系。比方省略了 `AbstractList`, `NavigableSet` 等抽象类以及其他的一些辅助类,如想深入了解,可自行查看源码。 -### ⭐️说说 List, Set, Queue, Map 四者的区别? +### ⭐️ 说说 List, Set, Queue, Map 四者的区别? -- `List`(对付顺序的好帮手): 存储的元素是有序的、可重复的。 -- `Set`(注重独一无二的性质): 存储的元素不可重复的。 -- `Queue`(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序,存储的元素是有序的、可重复的。 -- `Map`(用 key 来搜索的专家): 使用键值对(key-value)存储,类似于数学上的函数 y=f(x),"x" 代表 key,"y" 代表 value,key 无序、不可重复,value 无序、可重复,每个键最多映射到一个值。注意,这里的“无序”指的是 `HashMap` 这类实现——键值对之间没有显式的关联顺序。`LinkedHashMap` 和 `TreeMap` 等实现则是有序的,它们通过额外的数据结构(双向链表或红黑树)来维护键值对的顺序。 +- `List`(对付顺序的好帮手): 存储的元素是有序的、可重复的。 +- `Set`(注重独一无二的性质): 存储的元素不可重复的。 +- `Queue`(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序,存储的元素是有序的、可重复的。 +- `Map`(用 key 来搜索的专家): 使用键值对(key-value)存储,类似于数学上的函数 y=f(x),"x" 代表 key,"y" 代表 value,key 无序、不可重复,value 无序、可重复,每个键最多映射到一个值。注意,这里的“无序”指的是 `HashMap` 这类实现——键值对之间没有显式的关联顺序。`LinkedHashMap` 和 `TreeMap` 等实现则是有序的,它们通过额外的数据结构(双向链表或红黑树)来维护键值对的顺序。 ### 集合框架底层数据结构总结 @@ -39,13 +39,13 @@ Java 集合框架如下图所示: - `ArrayList`:`Object[]` 数组。详细可以查看:[ArrayList 源码分析](./arraylist-source-code.md)。 - `Vector`:`Object[]` 数组。 -- `LinkedList`:双向链表(JDK1.6 之前为循环链表,JDK1.7 取消了循环)。详细可以查看:[LinkedList 源码分析](./linkedlist-source-code.md)。 +- `LinkedList`:双向链表(JDK1.6 之前为循环链表,JDK1.7 取消了循环)。详细可以查看:[LinkedList 源码分析](./linkedlist-source-code.md)。 #### Set -- `HashSet`(无序,唯一): 基于 `HashMap` 实现的,底层采用 `HashMap` 来保存元素。 +- `HashSet`(无序,唯一): 基于 `HashMap` 实现的,底层采用 `HashMap` 来保存元素。 - `LinkedHashSet`: `LinkedHashSet` 是 `HashSet` 的子类,并且其内部是通过 `LinkedHashMap` 来实现的。 -- `TreeSet`(有序,唯一): 红黑树(自平衡的排序二叉树)。 +- `TreeSet`(有序,唯一): 红黑树(自平衡的排序二叉树)。 #### Queue @@ -62,12 +62,12 @@ Java 集合框架如下图所示: - `Hashtable`:数组+链表组成的,数组是 `Hashtable` 的主体,链表则是主要为了解决哈希冲突而存在的。 - `TreeMap`:红黑树(自平衡的排序二叉树)。 -### 如何选用集合? +### 如何选用集合? 我们主要根据集合的特点来选择合适的集合。比如: - 我们需要根据键值获取到元素值时就选用 `Map` 接口下的集合,需要排序时选择 `TreeMap`,不需要排序时就选择 `HashMap`,需要保证线程安全就选用 `ConcurrentHashMap`。 -- 我们只需要存放元素值时,就选择实现`Collection` 接口的集合,需要保证元素唯一时选择实现 `Set` 接口的集合比如 `TreeSet` 或 `HashSet`,不需要就选择实现 `List` 接口的比如 `ArrayList` 或 `LinkedList`,然后再根据实现这些接口的集合的特点来选用。 +- 我们只需要存放元素值时,就选择实现 `Collection` 接口的集合,需要保证元素唯一时选择实现 `Set` 接口的集合比如 `TreeSet` 或 `HashSet`,不需要就选择实现 `List` 接口的比如 `ArrayList` 或 `LinkedList`,然后再根据实现这些接口的集合的特点来选用。 ### 为什么要使用集合? @@ -75,15 +75,15 @@ Java 集合框架如下图所示: ## List -### ⭐️ArrayList 和 Array(数组)的区别? +### ⭐️ ArrayList 和 Array(数组)的区别? `ArrayList` 内部基于动态数组实现,比 `Array`(静态数组) 使用起来更加灵活: -- `ArrayList`会根据实际存储的元素动态地扩容或缩容,而 `Array` 被创建之后就不能改变它的长度了。 +- `ArrayList` 会根据实际存储的元素动态地扩容或缩容,而 `Array` 被创建之后就不能改变它的长度了。 - `ArrayList` 允许你使用泛型来确保类型安全,`Array` 则不可以。 - `ArrayList` 中只能存储对象。对于基本类型数据,需要使用其对应的包装类(如 Integer、Double 等)。`Array` 可以直接存储基本类型数据,也可以存储对象。 -- `ArrayList` 支持插入、删除、遍历等常见操作,并且提供了丰富的 API 操作方法,比如 `add()`、`remove()`等。`Array` 只是一个固定长度的数组,只能按照下标访问其中的元素,不具备动态添加、删除元素的能力。 -- `ArrayList`创建时不需要指定大小,而`Array`创建时必须指定大小。 +- `ArrayList` 支持插入、删除、遍历等常见操作,并且提供了丰富的 API 操作方法,比如 `add()`、`remove()` 等。`Array` 只是一个固定长度的数组,只能按照下标访问其中的元素,不具备动态添加、删除元素的能力。 +- `ArrayList` 创建时不需要指定大小,而 `Array` 创建时必须指定大小。 下面是二者使用的简单对比: @@ -103,7 +103,7 @@ Java 集合框架如下图所示: System.out.println(Arrays.toString(stringArr));// [world, !, null] ``` -`ArrayList` : +`ArrayList`: ```java // 初始化一个 String 类型的 ArrayList @@ -121,8 +121,8 @@ Java 集合框架如下图所示: ### ArrayList 和 Vector 的区别?(了解即可) -- `ArrayList` 是 `List` 的主要实现类,底层使用 `Object[]`存储,适用于频繁的查找工作,线程不安全 。 -- `Vector` 是 `List` 的古老实现类,底层使用`Object[]` 存储,线程安全。 +- `ArrayList` 是 `List` 的主要实现类,底层使用 `Object[]` 存储,适用于频繁的查找工作,线程不安全。 +- `Vector` 是 `List` 的古老实现类,底层使用 `Object[]` 存储,线程安全。 ### Vector 和 Stack 的区别?(了解即可) @@ -133,7 +133,7 @@ Java 集合框架如下图所示: ### ArrayList 可以添加 null 值吗? -`ArrayList` 中可以存储任何类型的对象,包括 `null` 值。不过,不建议向`ArrayList` 中添加 `null` 值, `null` 值无意义,会让代码难以维护比如忘记做判空处理就会导致空指针异常。 +`ArrayList` 中可以存储任何类型的对象,包括 `null` 值。不过,不建议向 `ArrayList` 中添加 `null` 值, `null` 值无意义,会让代码难以维护比如忘记做判空处理就会导致空指针异常。 示例代码: @@ -150,7 +150,7 @@ System.out.println(listOfStrings); [null, java] ``` -### ⭐️ArrayList 插入和删除元素的时间复杂度? +### ⭐️ ArrayList 插入和删除元素的时间复杂度? 对于插入: @@ -184,13 +184,13 @@ System.out.println(listOfStrings); 0 1 2 3 4 5 6 7 8 9 ``` -### ⭐️LinkedList 插入和删除元素的时间复杂度? +### ⭐️ LinkedList 插入和删除元素的时间复杂度? - 头部插入/删除:只需要修改头结点的指针即可完成插入/删除操作,因此时间复杂度为 O(1)。 - 尾部插入/删除:只需要修改尾结点的指针即可完成插入/删除操作,因此时间复杂度为 O(1)。 - 指定位置插入/删除:需要先移动到指定位置,再修改指定节点的指针完成插入/删除,不过由于有头尾指针,可以从较近的指针出发,因此需要遍历平均 n/4 个元素,时间复杂度为 O(n)。 -这里简单列举一个例子:假如我们要删除节点 9 的话,需要先遍历链表找到该节点。然后,再执行相应节点指针指向的更改,具体的源码可以参考:[LinkedList 源码分析](https://javaguide.cn/java/collection/linkedlist-source-code.html) 。 +这里简单列举一个例子:假如我们要删除节点 9 的话,需要先遍历链表找到该节点。然后,再执行相应节点指针指向的更改,具体的源码可以参考:[LinkedList 源码分析](https://javaguide.cn/java/collection/linkedlist-source-code.html)。 ![unlink 方法逻辑](https://oss.javaguide.cn/github/javaguide/java/collection/linkedlist-unlink.jpg) @@ -198,21 +198,21 @@ System.out.println(listOfStrings); `RandomAccess` 是一个标记接口,用来表明实现该接口的类支持随机访问(即可以通过索引快速访问元素)。由于 `LinkedList` 底层数据结构是链表,内存地址不连续,只能通过指针来定位,不支持随机快速访问,所以不能实现 `RandomAccess` 接口。 -### ⭐️ArrayList 与 LinkedList 区别? +### ⭐️ ArrayList 与 LinkedList 区别? - **是否保证线程安全:** `ArrayList` 和 `LinkedList` 都是不同步的,也就是不保证线程安全; - **底层数据结构:** `ArrayList` 底层使用的是 **`Object` 数组**;`LinkedList` 底层使用的是 **双向链表** 数据结构(JDK1.6 之前为循环链表,JDK1.7 取消了循环。注意双向链表和双向循环链表的区别,下面有介绍到!) - **插入和删除是否受元素位置的影响:** - - `ArrayList` 采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比如:执行`add(E e)`方法的时候, `ArrayList` 会默认在将指定的元素追加到此列表的末尾,这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话(`add(int index, E element)`),时间复杂度就为 O(n)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 - - `LinkedList` 采用链表存储,所以在头尾插入或者删除元素不受元素位置的影响(`add(E e)`、`addFirst(E e)`、`addLast(E e)`、`removeFirst()`、 `removeLast()`),时间复杂度为 O(1),如果是要在指定位置 `i` 插入和删除元素的话(`add(int index, E element)`,`remove(Object o)`,`remove(int index)`), 时间复杂度为 O(n) ,因为需要先移动到指定位置再插入和删除。 -- **是否支持快速随机访问:** `LinkedList` 不支持高效的随机元素访问,而 `ArrayList`(实现了 `RandomAccess` 接口) 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index)`方法)。 + - `ArrayList` 采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比如:执行 `add(E e)` 方法的时候, `ArrayList` 会默认在将指定的元素追加到此列表的末尾,这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话(`add(int index, E element)`),时间复杂度就为 O(n)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 + - `LinkedList` 采用链表存储,所以在头尾插入或者删除元素不受元素位置的影响(`add(E e)`、`addFirst(E e)`、`addLast(E e)`、`removeFirst()`、 `removeLast()`),时间复杂度为 O(1),如果是要在指定位置 `i` 插入和删除元素的话(`add(int index, E element)`,`remove(Object o)`,`remove(int index)`), 时间复杂度为 O(n),因为需要先移动到指定位置再插入和删除。 +- **是否支持快速随机访问:** `LinkedList` 不支持高效的随机元素访问,而 `ArrayList`(实现了 `RandomAccess` 接口) 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于 `get(int index)` 方法)。 - **内存空间占用:** `ArrayList` 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间,而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间(因为要存放直接后继和直接前驱以及数据)。 -我们在项目中一般是不会使用到 `LinkedList` 的,需要用到 `LinkedList` 的场景几乎都可以使用 `ArrayList` 来代替,并且,性能通常会更好!就连 `LinkedList` 的作者约书亚 · 布洛克(Josh Bloch)自己都说从来不会使用 `LinkedList` 。 +我们在项目中一般是不会使用到 `LinkedList` 的,需要用到 `LinkedList` 的场景几乎都可以使用 `ArrayList` 来代替,并且,性能通常会更好!就连 `LinkedList` 的作者约书亚 · 布洛克(Josh Bloch)自己都说从来不会使用 `LinkedList`。 ![](https://oss.javaguide.cn/github/javaguide/redisimage-20220412110853807.png) -另外,不要下意识地认为 `LinkedList` 作为链表就最适合元素增删的场景。我在上面也说了,`LinkedList` 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1),其他情况增删元素的平均时间复杂度都是 O(n) 。 +另外,不要下意识地认为 `LinkedList` 作为链表就最适合元素增删的场景。我在上面也说了,`LinkedList` 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1),其他情况增删元素的平均时间复杂度都是 O(n)。 #### 补充内容: 双向链表和双向循环链表 @@ -233,7 +233,7 @@ public interface RandomAccess { 查看源码我们发现实际上 `RandomAccess` 接口中什么都没有定义。所以,在我看来 `RandomAccess` 接口不过是一个标识罢了。标识什么? 标识实现这个接口的类具有随机访问功能。 -在 `binarySearch()` 方法中,它要判断传入的 list 是否 `RandomAccess` 的实例,如果是,调用`indexedBinarySearch()`方法,如果不是,那么调用`iteratorBinarySearch()`方法 +在 `binarySearch()` 方法中,它要判断传入的 list 是否 `RandomAccess` 的实例,如果是,调用 `indexedBinarySearch()` 方法,如果不是,那么调用 `iteratorBinarySearch()` 方法 ```java public static @@ -247,21 +247,21 @@ public interface RandomAccess { `ArrayList` 实现了 `RandomAccess` 接口, 而 `LinkedList` 没有实现。为什么呢?我觉得还是和底层数据结构有关!`ArrayList` 底层是数组,而 `LinkedList` 底层是链表。数组天然支持随机访问,时间复杂度为 O(1),所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素,时间复杂度为 O(n),所以不支持快速随机访问。`ArrayList` 实现了 `RandomAccess` 接口,就表明了他具有快速随机访问功能。 `RandomAccess` 接口只是标识,并不是说 `ArrayList` 实现 `RandomAccess` 接口才具有快速随机访问功能的! -### ⭐️说一说 ArrayList 的扩容机制吧 +### ⭐️ 说一说 ArrayList 的扩容机制吧 详见笔主的这篇文章: [ArrayList 扩容机制分析](https://javaguide.cn/java/collection/arraylist-source-code.html#arraylist-扩容机制分析)。 -### ⭐️集合中的 fail-fast 和 fail-safe 是什么? +### ⭐️ 集合中的 fail-fast 和 fail-safe 是什么? -`fail-fast`(快速失败)和 `fail-safe`(安全失败)是Java集合框架在处理并发修改问题时,两种截然不同的设计哲学和容错策略。 +`fail-fast`(快速失败)和 `fail-safe`(安全失败)是 Java 集合框架在处理并发修改问题时,两种截然不同的设计哲学和容错策略。 -关于`fail-fast`引用`medium`中一篇文章关于`fail-fast`和`fail-safe`的说法: +关于 `fail-fast` 引用 `medium` 中一篇文章关于 `fail-fast` 和 `fail-safe` 的说法: > Fail-fast systems are designed to immediately stop functioning upon encountering an unexpected condition. This immediate failure helps to catch errors early, making debugging more straightforward. 快速失败的思想即针对可能发生的异常进行提前表明故障并停止运行,通过尽早的发现和停止错误,降低故障系统级联的风险。 -在`java.util`包下的大部分集合(如 `ArrayList`, `HashMap`)是不支持线程安全的,为了能够提前发现并发操作导致线程安全风险,提出通过维护一个`modCount`记录修改的次数,迭代期间通过比对预期修改次数`expectedModCount`和`modCount`是否一致来判断是否存在并发操作,从而实现快速失败,由此保证在避免在异常时执行非必要的复杂代码。 +在 `java.util` 包下的大部分集合(如 `ArrayList`, `HashMap`)是不支持线程安全的,为了能够提前发现并发操作导致线程安全风险,提出通过维护一个 `modCount` 记录修改的次数,迭代期间通过比对预期修改次数 `expectedModCount` 和 `modCount` 是否一致来判断是否存在并发操作,从而实现快速失败,由此保证在避免在异常时执行非必要的复杂代码。 **ArrayList (fail-fast) 示例:** @@ -323,7 +323,7 @@ Final list state: [0, 2, 3, 4] 程序在线程 t2 修改列表后,线程 t1 的下一次迭代操作立刻就抛出了 `ConcurrentModificationException`。这是因为 ArrayList 的迭代器在每次 `next()` 调用时,都会检查 `modCount` 是否被改变。一旦发现集合在迭代器不知情的情况下被修改,它会立即“快速失败”,以防止在不一致的数据上继续操作导致不可预期的后果。 -对此我们也给出`for`循环底层迭代器获取下一个元素时的`next`方法,可以看到其内部的`checkForComodification`具有针对修改次数比对的逻辑: +对此我们也给出 `for` 循环底层迭代器获取下一个元素时的 `next` 方法,可以看到其内部的 `checkForComodification` 具有针对修改次数比对的逻辑: ```java public E next() { @@ -342,15 +342,15 @@ final void checkForComodification() { ``` -而`fail-safe`也就是安全失败的含义,它旨在即使面对意外情况也能恢复并继续运行,这使得它特别适用于不确定或者不稳定的环境: +而 `fail-safe` 也就是安全失败的含义,它旨在即使面对意外情况也能恢复并继续运行,这使得它特别适用于不确定或者不稳定的环境: > Fail-safe systems take a different approach, aiming to recover and continue even in the face of unexpected conditions. This makes them particularly suited for uncertain or volatile environments. -该思想常运用于并发容器,最经典的实现就是`CopyOnWriteArrayList`的实现,通过写时复制(Copy-On-Write)的思想保证在进行修改操作时复制出一份快照,基于这份快照完成添加或者删除操作后,将`CopyOnWriteArrayList`底层的数组引用指向这个新的数组空间,由此避免迭代时被并发修改所干扰所导致并发操作安全问题,当然这种做法也存在缺点,即进行遍历操作时无法获得实时结果: +该思想常运用于并发容器,最经典的实现就是 `CopyOnWriteArrayList` 的实现,通过写时复制(Copy-On-Write)的思想保证在进行修改操作时复制出一份快照,基于这份快照完成添加或者删除操作后,将 `CopyOnWriteArrayList` 底层的数组引用指向这个新的数组空间,由此避免迭代时被并发修改所干扰所导致并发操作安全问题,当然这种做法也存在缺点,即进行遍历操作时无法获得实时结果: ![](https://oss.javaguide.cn/github/javaguide/java/collection/fail-fast-and-fail-safe-copyonwritearraylist.png) -对应我们也给出`CopyOnWriteArrayList`实现`fail-safe`的核心代码,可以看到它的实现就是通过`getArray`获取数组引用然后通过`Arrays.copyOf`得到一个数组的快照,基于这个快照完成添加操作后,修改底层`array`变量指向的引用地址由此完成写时复制: +对应我们也给出 `CopyOnWriteArrayList` 实现 `fail-safe` 的核心代码,可以看到它的实现就是通过 `getArray` 获取数组引用然后通过 `Arrays.copyOf` 得到一个数组的快照,基于这个快照完成添加操作后,修改底层 `array` 变量指向的引用地址由此完成写时复制: ```java public boolean add(E e) { @@ -379,10 +379,10 @@ public boolean add(E e) { `Comparable` 接口和 `Comparator` 接口都是 Java 中用于排序的接口,它们在实现类对象之间比较大小、排序等方面发挥了重要作用: -- `Comparable` 接口实际上是出自`java.lang`包 它有一个 `compareTo(Object obj)`方法用来排序 -- `Comparator`接口实际上是出自 `java.util` 包它有一个`compare(Object obj1, Object obj2)`方法用来排序 +- `Comparable` 接口实际上是出自 `java.lang` 包 它有一个 `compareTo(Object obj)` 方法用来排序 +- `Comparator` 接口实际上是出自 `java.util` 包它有一个 `compare(Object obj1, Object obj2)` 方法用来排序 -一般我们需要对一个集合使用自定义排序时,我们就要重写`compareTo()`方法或`compare()`方法,当我们需要对某一个集合实现两种排序方式,比如一个 `song` 对象中的歌名和歌手名分别采用一种排序方法的话,我们可以重写`compareTo()`方法和使用自制的`Comparator`方法或者以两个 `Comparator` 来实现歌名排序和歌星名排序,第二种代表我们只能使用两个参数版的 `Collections.sort()`. +一般我们需要对一个集合使用自定义排序时,我们就要重写 `compareTo()` 方法或 `compare()` 方法,当我们需要对某一个集合实现两种排序方式,比如一个 `song` 对象中的歌名和歌手名分别采用一种排序方法的话,我们可以重写 `compareTo()` 方法和使用自制的 `Comparator` 方法或者以两个 `Comparator` 来实现歌名排序和歌星名排序,第二种代表我们只能使用两个参数版的 `Collections.sort()`. #### Comparator 定制排序 @@ -507,8 +507,8 @@ Output: ### 无序性和不可重复性的含义是什么 -- 无序性不等于随机性 ,无序性是指存储的数据在底层数组中并非按照数组索引的顺序添加 ,而是根据数据的哈希值决定的。 -- 不可重复性是指添加的元素按照 `equals()` 判断时 ,返回 false,需要同时重写 `equals()` 方法和 `hashCode()` 方法。 +- 无序性不等于随机性,无序性是指存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的。 +- 不可重复性是指添加的元素按照 `equals()` 判断时,返回 false,需要同时重写 `equals()` 方法和 `hashCode()` 方法。 ### 比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同 @@ -553,7 +553,7 @@ Output: - `ArrayDeque` 不支持存储 `NULL` 数据,但 `LinkedList` 支持。 -- `ArrayDeque` 是在 JDK1.6 才被引入的,而`LinkedList` 早在 JDK1.2 时就已经存在。 +- `ArrayDeque` 是在 JDK1.6 才被引入的,而 `LinkedList` 早在 JDK1.2 时就已经存在。 - `ArrayDeque` 插入时可能存在扩容过程, 不过均摊后的插入操作依然为 O(1)。虽然 `LinkedList` 不需要扩容,但是每次插入数据时均需要申请新的堆空间,均摊性能相比更慢。 @@ -576,7 +576,7 @@ Output: ### 什么是 BlockingQueue? -`BlockingQueue` (阻塞队列)是一个接口,继承自 `Queue`。`BlockingQueue`阻塞的原因是其支持当队列没有元素时一直阻塞,直到有元素;还支持如果队列已满,一直等到队列可以放入新元素时再放入。 +`BlockingQueue`(阻塞队列)是一个接口,继承自 `Queue`。`BlockingQueue` 阻塞的原因是其支持当队列没有元素时一直阻塞,直到有元素;还支持如果队列已满,一直等到队列可以放入新元素时再放入。 ```java public interface BlockingQueue extends Queue { @@ -595,22 +595,22 @@ public interface BlockingQueue extends Queue { Java 中常用的阻塞队列实现类有以下几种: 1. `ArrayBlockingQueue`:使用数组实现的有界阻塞队列。在创建时需要指定容量大小,并支持公平和非公平两种方式的锁访问机制。 -2. `LinkedBlockingQueue`:使用单向链表实现的可选有界阻塞队列。在创建时可以指定容量大小,如果不指定则默认为`Integer.MAX_VALUE`。和`ArrayBlockingQueue`不同的是, 它仅支持非公平的锁访问机制。 -3. `PriorityBlockingQueue`:支持优先级排序的无界阻塞队列。元素必须实现`Comparable`接口或者在构造函数中传入`Comparator`对象,并且不能插入 null 元素。 -4. `SynchronousQueue`:同步队列,是一种不存储元素的阻塞队列。每个插入操作都必须等待对应的删除操作,反之删除操作也必须等待插入操作。因此,`SynchronousQueue`通常用于线程之间的直接传递数据。 +2. `LinkedBlockingQueue`:使用单向链表实现的可选有界阻塞队列。在创建时可以指定容量大小,如果不指定则默认为 `Integer.MAX_VALUE`。和 `ArrayBlockingQueue` 不同的是, 它仅支持非公平的锁访问机制。 +3. `PriorityBlockingQueue`:支持优先级排序的无界阻塞队列。元素必须实现 `Comparable` 接口或者在构造函数中传入 `Comparator` 对象,并且不能插入 null 元素。 +4. `SynchronousQueue`:同步队列,是一种不存储元素的阻塞队列。每个插入操作都必须等待对应的删除操作,反之删除操作也必须等待插入操作。因此,`SynchronousQueue` 通常用于线程之间的直接传递数据。 5. `DelayQueue`:延迟队列,其中的元素只有到了其指定的延迟时间,才能够从队列中出队。 6. …… 日常开发中,这些队列使用的其实都不多,了解即可。 -### ⭐️ArrayBlockingQueue 和 LinkedBlockingQueue 有什么区别? +### ⭐️ ArrayBlockingQueue 和 LinkedBlockingQueue 有什么区别? `ArrayBlockingQueue` 和 `LinkedBlockingQueue` 是 Java 并发包中常用的两种阻塞队列实现,它们都是线程安全的。不过,不过它们之间也存在下面这些区别: - 底层实现:`ArrayBlockingQueue` 基于数组实现,而 `LinkedBlockingQueue` 基于链表实现。 -- 是否有界:`ArrayBlockingQueue` 是有界队列,必须在创建时指定容量大小。`LinkedBlockingQueue` 创建时可以不指定容量大小,默认是`Integer.MAX_VALUE`,也就是无界的。但也可以指定队列大小,从而成为有界的。 -- 锁是否分离: `ArrayBlockingQueue`中的锁是没有分离的,即生产和消费用的是同一个锁;`LinkedBlockingQueue`中的锁是分离的,即生产用的是`putLock`,消费是`takeLock`,这样可以防止生产者和消费者线程之间的锁争夺。 -- 内存占用:`ArrayBlockingQueue` 需要提前分配数组内存,而 `LinkedBlockingQueue` 则是动态分配链表节点内存。这意味着,`ArrayBlockingQueue` 在创建时就会占用一定的内存空间,且往往申请的内存比实际所用的内存更大,而`LinkedBlockingQueue` 则是根据元素的增加而逐渐占用内存空间。 +- 是否有界:`ArrayBlockingQueue` 是有界队列,必须在创建时指定容量大小。`LinkedBlockingQueue` 创建时可以不指定容量大小,默认是 `Integer.MAX_VALUE`,也就是无界的。但也可以指定队列大小,从而成为有界的。 +- 锁是否分离: `ArrayBlockingQueue` 中的锁是没有分离的,即生产和消费用的是同一个锁;`LinkedBlockingQueue` 中的锁是分离的,即生产用的是 `putLock`,消费是 `takeLock`,这样可以防止生产者和消费者线程之间的锁争夺。 +- 内存占用:`ArrayBlockingQueue` 需要提前分配数组内存,而 `LinkedBlockingQueue` 则是动态分配链表节点内存。这意味着,`ArrayBlockingQueue` 在创建时就会占用一定的内存空间,且往往申请的内存比实际所用的内存更大,而 `LinkedBlockingQueue` 则是根据元素的增加而逐渐占用内存空间。 ## 数据结构延伸阅读 diff --git a/docs/java/collection/java-collection-questions-02.md b/docs/java/collection/java-collection-questions-02.md index be5c61d7728..75ff002ad99 100644 --- a/docs/java/collection/java-collection-questions-02.md +++ b/docs/java/collection/java-collection-questions-02.md @@ -14,12 +14,12 @@ head: ## Map(重要) -### ⭐️HashMap 和 Hashtable 的区别 +### ⭐️ HashMap 和 Hashtable 的区别 -- **线程是否安全:** `HashMap` 是非线程安全的,`Hashtable` 是线程安全的,因为 `Hashtable` 内部的方法基本都经过`synchronized` 修饰。(如果你要保证线程安全的话就使用 `ConcurrentHashMap` 吧!); +- **线程是否安全:** `HashMap` 是非线程安全的,`Hashtable` 是线程安全的,因为 `Hashtable` 内部的方法基本都经过 `synchronized` 修饰。(如果你要保证线程安全的话就使用 `ConcurrentHashMap` 吧!); - **效率:** 因为线程安全的问题,`HashMap` 要比 `Hashtable` 效率高一点。另外,`Hashtable` 基本被淘汰,不要在代码中使用它; - **对 Null key 和 Null value 的支持:** `HashMap` 可以存储 null 的 key 和 value,但 null 作为键只能有一个,null 作为值可以有多个;Hashtable 不允许有 null 键和 null 值,否则会抛出 `NullPointerException`。 -- **初始容量大小和每次扩充容量大小的不同:** ① 创建时如果不指定容量初始值,`Hashtable` 默认的初始大小为 11,之后每次扩充,容量变为原来的 2n+1。`HashMap` 默认的初始化大小为 16。之后每次扩充,容量变为原来的 2 倍。② 创建时如果给定了容量初始值,那么 `Hashtable` 会直接使用你给定的大小,而 `HashMap` 会将其扩充为 2 的幂次方大小(`HashMap` 中的`tableSizeFor()`方法保证,下面给出了源代码)。也就是说 `HashMap` 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2 的幂次方。 +- **初始容量大小和每次扩充容量大小的不同:** ① 创建时如果不指定容量初始值,`Hashtable` 默认的初始大小为 11,之后每次扩充,容量变为原来的 2n+1。`HashMap` 默认的初始化大小为 16。之后每次扩充,容量变为原来的 2 倍。② 创建时如果给定了容量初始值,那么 `Hashtable` 会直接使用你给定的大小,而 `HashMap` 会将其扩充为 2 的幂次方大小(`HashMap` 中的 `tableSizeFor()` 方法保证,下面给出了源代码)。也就是说 `HashMap` 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2 的幂次方。 - **底层数据结构:** JDK1.8 以后的 `HashMap` 在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为 8)时,将链表转化为红黑树(将链表转换成红黑树前会判断,如果当前数组的长度小于 64,那么会选择先进行数组扩容,而不是转换为红黑树),以减少搜索时间(后文中我会结合源码对这一过程进行分析)。`Hashtable` 没有这样的机制。 - **哈希函数的实现**:`HashMap` 对哈希值进行了高位和低位的混合扰动处理以减少冲突,而 `Hashtable` 直接使用键的 `hashCode()` 值。 @@ -62,7 +62,7 @@ static final int tableSizeFor(int cap) { ### HashMap 和 HashSet 区别 -如果你看过 `HashSet` 源码的话就应该知道:`HashSet` 底层就是基于 `HashMap` 实现的。(`HashSet` 的源码非常非常少,因为除了 `clone()`、`writeObject()`、`readObject()`是 `HashSet` 自己不得不实现之外,其他方法都是直接调用 `HashMap` 中的方法。 +如果你看过 `HashSet` 源码的话就应该知道:`HashSet` 底层就是基于 `HashMap` 实现的。(`HashSet` 的源码非常非常少,因为除了 `clone()`、`writeObject()`、`readObject()` 是 `HashSet` 自己不得不实现之外,其他方法都是直接调用 `HashMap` 中的方法。 | `HashMap` | `HashSet` | | :------------------------------------: | :----------------------------------------------------------------------------------------------------------------------: | @@ -71,9 +71,9 @@ static final int tableSizeFor(int cap) { | 调用 `put()`向 map 中添加元素 | 调用 `add()`方法向 `Set` 中添加元素 | | `HashMap` 使用键(Key)计算 `hashcode` | `HashSet` 使用成员对象来计算 `hashcode` 值,对于两个对象来说 `hashcode` 可能相同,所以`equals()`方法用来判断对象的相等性 | -### ⭐️HashMap 和 TreeMap 区别 +### ⭐️ HashMap 和 TreeMap 区别 -`TreeMap` 和`HashMap` 都继承自`AbstractMap` ,但是需要注意的是`TreeMap`它还实现了`NavigableMap`接口和`SortedMap` 接口。 +`TreeMap` 和 `HashMap` 都继承自 `AbstractMap`,但是需要注意的是 `TreeMap` 它还实现了 `NavigableMap` 接口和 `SortedMap` 接口。 ![TreeMap 继承关系图](https://oss.javaguide.cn/github/javaguide/java/collection/treemap_hierarchy.png) @@ -81,14 +81,14 @@ static final int tableSizeFor(int cap) { `NavigableMap` 接口提供了丰富的方法来探索和操作键值对: -1. **定向搜索**: `ceilingEntry()`, `floorEntry()`, `higherEntry()`和 `lowerEntry()` 等方法可以用于定位大于等于、小于等于、严格大于、严格小于给定键的最接近的键值对。 -2. **子集操作**: `subMap()`, `headMap()`和 `tailMap()` 方法可以高效地创建原集合的子集视图,而无需复制整个集合。 +1. **定向搜索**: `ceilingEntry()`, `floorEntry()`, `higherEntry()` 和 `lowerEntry()` 等方法可以用于定位大于等于、小于等于、严格大于、严格小于给定键的最接近的键值对。 +2. **子集操作**: `subMap()`, `headMap()` 和 `tailMap()` 方法可以高效地创建原集合的子集视图,而无需复制整个集合。 3. **逆序视图**:`descendingMap()` 方法返回一个逆序的 `NavigableMap` 视图,使得可以反向迭代整个 `TreeMap`。 -4. **边界操作**: `firstEntry()`, `lastEntry()`, `pollFirstEntry()`和 `pollLastEntry()` 等方法可以方便地访问和移除元素。 +4. **边界操作**: `firstEntry()`, `lastEntry()`, `pollFirstEntry()` 和 `pollLastEntry()` 等方法可以方便地访问和移除元素。 这些方法都是基于红黑树数据结构的属性实现的,红黑树保持平衡状态,从而保证了搜索操作的时间复杂度为 O(log n),这让 `TreeMap` 成为了处理有序集合搜索问题的强大工具。 -实现`SortedMap`接口让 `TreeMap` 有了对集合中的元素根据键排序的能力。默认是按 key 的升序排序,不过我们也可以指定排序的比较器。示例代码如下: +实现 `SortedMap` 接口让 `TreeMap` 有了对集合中的元素根据键排序的能力。默认是按 key 的升序排序,不过我们也可以指定排序的比较器。示例代码如下: ```java /** @@ -146,15 +146,15 @@ TreeMap treeMap = new TreeMap<>((person1, person2) -> { }); ``` -**综上,相比于`HashMap`来说, `TreeMap` 主要多了对集合中的元素根据键排序的能力以及对集合内元素的搜索的能力。** +**综上,相比于 `HashMap` 来说, `TreeMap` 主要多了对集合中的元素根据键排序的能力以及对集合内元素的搜索的能力。** -### HashSet 如何检查重复? +### HashSet 如何检查重复? 以下内容摘自我的 Java 启蒙书《Head first java》第二版: -> 当你把对象加入`HashSet`时,`HashSet` 会先计算对象的`hashcode`值来判断对象加入的位置,同时也会与其他加入的对象的 `hashcode` 值作比较,如果没有相符的 `hashcode`,`HashSet` 会假设对象没有重复出现。但是如果发现有相同 `hashcode` 值的对象,这时会调用`equals()`方法来检查 `hashcode` 相等的对象是否真的相同。如果两者相同,`HashSet` 就不会让加入操作成功。 +> 当你把对象加入 `HashSet` 时,`HashSet` 会先计算对象的 `hashcode` 值来判断对象加入的位置,同时也会与其他加入的对象的 `hashcode` 值作比较,如果没有相符的 `hashcode`,`HashSet` 会假设对象没有重复出现。但是如果发现有相同 `hashcode` 值的对象,这时会调用 `equals()` 方法来检查 `hashcode` 相等的对象是否真的相同。如果两者相同,`HashSet` 就不会让加入操作成功。 -在 JDK1.8 中,`HashSet`的`add()`方法只是简单的调用了`HashMap`的`put()`方法,并且判断了一下返回值以确保是否有重复元素。直接看一下`HashSet`中的源码: +在 JDK1.8 中,`HashSet` 的 `add()` 方法只是简单的调用了 `HashMap` 的 `put()` 方法,并且判断了一下返回值以确保是否有重复元素。直接看一下 `HashSet` 中的源码: ```java // Returns: true if this set did not already contain the specified element @@ -164,7 +164,7 @@ public boolean add(E e) { } ``` -而在`HashMap`的`putVal()`方法中也能看到如下说明: +而在 `HashMap` 的 `putVal()` 方法中也能看到如下说明: ```java // Returns : previous value, or null if none @@ -175,9 +175,9 @@ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, } ``` -也就是说,在 JDK1.8 中,实际上无论`HashSet`中是否已经存在了某元素,`HashSet`都会直接插入,只是会在`add()`方法的返回值处告诉我们插入前是否存在相同元素。 +也就是说,在 JDK1.8 中,实际上无论 `HashSet` 中是否已经存在了某元素,`HashSet` 都会直接插入,只是会在 `add()` 方法的返回值处告诉我们插入前是否存在相同元素。 -### ⭐️HashMap 的底层实现 +### ⭐️ HashMap 的底层实现 #### JDK1.8 之前 @@ -212,7 +212,7 @@ static int hash(int h) { } ``` -相比于 JDK1.8 的 hash 方法 ,JDK 1.7 的 hash 方法的性能会稍差一点点,因为毕竟扰动了 4 次。 +相比于 JDK1.8 的 hash 方法,JDK 1.7 的 hash 方法的性能会稍差一点点,因为毕竟扰动了 4 次。 所谓 **“拉链法”** 就是:将链表和数组相结合。也就是说创建一个链表数组,数组中每一格就是一个链表。若遇到哈希冲突,则将冲突的值加到链表中即可。 @@ -243,7 +243,7 @@ static int hash(int h) { **1、 `putVal` 方法中执行链表转红黑树的判断逻辑。** -链表的长度大于 8 的时候,就执行 `treeifyBin` (转换红黑树)的逻辑。 +链表的长度大于 8 的时候,就执行 `treeifyBin`(转换红黑树)的逻辑。 ```java // 遍历链表 @@ -295,9 +295,9 @@ final void treeifyBin(Node[] tab, int hash) { 将链表转换成红黑树前会判断,如果当前数组的长度小于 64,那么会选择先进行数组扩容,而不是转换为红黑树。 -### ⭐️HashMap 的长度为什么是 2 的幂次方 +### ⭐️ HashMap 的长度为什么是 2 的幂次方 -为了让 `HashMap` 存取高效并减少碰撞,我们需要确保数据尽量均匀分布。哈希值在 Java 中通常使用 `int` 表示,其范围是 `-2147483648 ~ 2147483647`前后加起来大概 40 亿的映射空间,只要哈希函数映射得比较均匀松散,一般应用是很难出现碰撞的。但是,问题是一个 40 亿长度的数组,内存是放不下的。所以,这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算,得到的余数才能用来要存放的位置也就是对应的数组下标。 +为了让 `HashMap` 存取高效并减少碰撞,我们需要确保数据尽量均匀分布。哈希值在 Java 中通常使用 `int` 表示,其范围是 `-2147483648 ~ 2147483647` 前后加起来大概 40 亿的映射空间,只要哈希函数映射得比较均匀松散,一般应用是很难出现碰撞的。但是,问题是一个 40 亿长度的数组,内存是放不下的。所以,这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算,得到的余数才能用来要存放的位置也就是对应的数组下标。 **这个算法应该如何设计呢?** @@ -305,8 +305,8 @@ final void treeifyBin(Node[] tab, int hash) { 除了上面所说的位运算比取余效率高之外,我觉得更重要的一个原因是:**长度是 2 的幂次方,可以让 `HashMap` 在扩容的时候更均匀**。例如: -- length = 8 时,length - 1 = 7 的二进制位`0111` -- length = 16 时,length - 1 = 15 的二进制位`1111` +- length = 8 时,length - 1 = 7 的二进制位 `0111` +- length = 16 时,length - 1 = 15 的二进制位 `1111` 这时候原本存在 `HashMap` 中的元素计算新的数组位置时 `hash&(length-1)`,取决 hash 的第四个二进制位(从右数),会出现两种情况: @@ -347,15 +347,15 @@ index = 00001100 (12) 2. 可以更好地保证哈希值的均匀分布:扩容之后,在旧数组元素 hash 值比较均匀的情况下,新数组元素也会被分配的比较均匀,最好的情况是会有一半在新数组的前半部分,一半在新数组后半部分。 3. 扩容机制变得简单和高效:扩容后只需检查哈希值高位的变化来决定元素的新位置,要么位置不变(高位为 0),要么就是移动到新位置(高位为 1,原索引位置+原容量)。 -### ⭐️HashMap 多线程操作导致死循环问题 +### ⭐️ HashMap 多线程操作导致死循环问题 JDK1.7 及之前版本的 `HashMap` 在多线程环境下扩容操作可能存在死循环问题,这是由于当一个桶位中有多个元素需要进行扩容时,多个线程同时对链表进行操作,头插法可能会导致链表中的节点指向错误的位置,从而形成一个环形链表,进而使得查询元素的操作陷入死循环无法结束。 -为了解决这个问题,JDK1.8 版本的 HashMap 采用了尾插法而不是头插法来避免链表倒置,使得插入的节点永远都是放在链表的末尾,避免了链表中的环形结构。但是还是不建议在多线程下使用 `HashMap`,因为多线程下使用 `HashMap` 还是会存在数据覆盖的问题。并发环境下,推荐使用 `ConcurrentHashMap` 。 +为了解决这个问题,JDK1.8 版本的 HashMap 采用了尾插法而不是头插法来避免链表倒置,使得插入的节点永远都是放在链表的末尾,避免了链表中的环形结构。但是还是不建议在多线程下使用 `HashMap`,因为多线程下使用 `HashMap` 还是会存在数据覆盖的问题。并发环境下,推荐使用 `ConcurrentHashMap`。 一般面试中这样介绍就差不多,不需要记各种细节,个人觉得也没必要记。如果想要详细了解 `HashMap` 扩容导致死循环问题,可以看看耗子叔的这篇文章:[Java HashMap 的死循环](https://coolshell.cn/articles/9606.html)。 -### ⭐️HashMap 为什么线程不安全? +### ⭐️ HashMap 为什么线程不安全? `HashMap` 不是线程安全的。在多线程环境下对 `HashMap` 进行并发写操作,可能会导致两种主要问题: @@ -414,13 +414,13 @@ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, } ``` -### HashMap 常见的遍历方式? +### HashMap 常见的遍历方式? [HashMap 的 7 种遍历方式与性能分析!](https://mp.weixin.qq.com/s/zQBN3UvJDhRTKP6SzcZFKw) **🐛 修正(参见:[issue#1411](https://github.com/Snailclimb/JavaGuide/issues/1411))**: -这篇文章对于 parallelStream 遍历方式的性能分析有误,先说结论:**存在阻塞时 parallelStream 性能最高, 非阻塞时 parallelStream 性能最低** 。 +这篇文章对于 parallelStream 遍历方式的性能分析有误,先说结论:**存在阻塞时 parallelStream 性能最高, 非阻塞时 parallelStream 性能最低**。 当遍历不存在阻塞时, parallelStream 的性能是最低的: @@ -432,7 +432,7 @@ Test.lambda avgt 5 221.791 ± 10.198 ns/op Test.parallelStream avgt 5 6919.163 ± 1116.139 ns/op ``` -加入阻塞代码`Thread.sleep(10)`后, parallelStream 的性能才是最高的: +加入阻塞代码 `Thread.sleep(10)` 后, parallelStream 的性能才是最高的: ```plain Benchmark Mode Cnt Score Error Units @@ -442,7 +442,7 @@ Test.lambda avgt 5 1551065180.000 ± 19164407.426 ns/op Test.parallelStream avgt 5 186345456.667 ± 3210435.590 ns/op ``` -### ⭐️ConcurrentHashMap 和 Hashtable 的区别 +### ⭐️ ConcurrentHashMap 和 Hashtable 的区别 `ConcurrentHashMap` 和 `Hashtable` 的区别主要体现在实现线程安全的方式上不同。 @@ -450,7 +450,7 @@ Test.parallelStream avgt 5 186345456.667 ± 3210435.590 ns/op - **实现线程安全的方式(重要):** - 在 JDK1.7 的时候,`ConcurrentHashMap` 对整个桶数组进行了分割分段(`Segment`,分段锁),每一把锁只锁容器其中一部分数据(下面有示意图),多线程访问容器里不同数据段的数据,就不会存在锁竞争,提高并发访问率。 - 到了 JDK1.8 的时候,`ConcurrentHashMap` 已经摒弃了 `Segment` 的概念,而是直接用 `Node` 数组+链表+红黑树的数据结构来实现,并发控制使用 `synchronized` 和 CAS 来操作。(JDK1.6 以后 `synchronized` 锁做了很多优化) 整个看起来就像是优化过且线程安全的 `HashMap`,虽然在 JDK1.8 中还能看到 `Segment` 的数据结构,但是已经简化了属性,只是为了兼容旧版本; - - **`Hashtable`(同一把锁)** :使用 `synchronized` 来保证线程安全,效率非常低下。当一个线程访问同步方法时,其他线程也访问同步方法,可能会进入阻塞或轮询状态,如使用 put 添加元素,另一个线程不能使用 put 添加元素,也不能使用 get,竞争会越来越激烈效率越低。 + - **`Hashtable`(同一把锁)** :使用 `synchronized` 来保证线程安全,效率非常低下。当一个线程访问同步方法时,其他线程也访问同步方法,可能会进入阻塞或轮询状态,如使用 put 添加元素,另一个线程不能使用 put 添加元素,也不能使用 get,竞争会越来越激烈效率越低。 下面,我们再来看看两者底层数据结构的对比图。 @@ -474,7 +474,7 @@ Test.parallelStream avgt 5 186345456.667 ± 3210435.590 ns/op JDK1.8 的 `ConcurrentHashMap` 不再是 **Segment 数组 + HashEntry 数组 + 链表**,而是 **Node 数组 + 链表 / 红黑树**。不过,Node 只能用于链表的情况,红黑树的情况需要使用 **`TreeNode`**。当冲突链表达到一定长度时,链表会转换成红黑树。 -`TreeNode`是存储红黑树节点,被`TreeBin`包装。`TreeBin`通过`root`属性维护红黑树的根结点,因为红黑树在旋转的时候,根结点可能会被它原来的子节点替换掉,在这个时间点,如果有其他线程要写这棵红黑树就会发生线程不安全问题,所以在 `ConcurrentHashMap` 中`TreeBin`通过`waiter`属性维护当前使用这棵红黑树的线程,来防止其他线程的进入。 +`TreeNode` 是存储红黑树节点,被 `TreeBin` 包装。`TreeBin` 通过 `root` 属性维护红黑树的根结点,因为红黑树在旋转的时候,根结点可能会被它原来的子节点替换掉,在这个时间点,如果有其他线程要写这棵红黑树就会发生线程不安全问题,所以在 `ConcurrentHashMap` 中 `TreeBin` 通过 `waiter` 属性维护当前使用这棵红黑树的线程,来防止其他线程的进入。 ```java static final class TreeBin extends Node { @@ -490,7 +490,7 @@ static final class TreeBin extends Node { } ``` -### ⭐️ConcurrentHashMap 线程安全的具体实现方式/底层具体实现 +### ⭐️ ConcurrentHashMap 线程安全的具体实现方式/底层具体实现 #### JDK1.8 之前 @@ -521,7 +521,7 @@ Java 8 几乎完全重写了 `ConcurrentHashMap`,代码量从原来 Java 7 中 Java 8 中,锁粒度更细,`synchronized` 只锁定当前链表或红黑二叉树的首节点,这样只要 hash 不冲突,就不会产生并发,就不会影响其他 Node 的读写,效率大幅提升。 -### ⭐️JDK 1.7 和 JDK 1.8 的 ConcurrentHashMap 实现有什么不同? +### ⭐️ JDK 1.7 和 JDK 1.8 的 ConcurrentHashMap 实现有什么不同? - **线程安全实现方式**:JDK 1.7 采用 `Segment` 分段锁来保证安全, `Segment` 是继承自 `ReentrantLock`。JDK1.8 放弃了 `Segment` 分段锁的设计,采用 `Node + CAS + synchronized` 保证线程安全,锁粒度更细,`synchronized` 只锁定当前链表或红黑二叉树的首节点。 - **Hash 碰撞解决方法** : JDK 1.7 采用拉链法,JDK1.8 采用拉链法结合红黑树(链表长度超过一定阈值时,将链表转换为红黑树)。 @@ -533,16 +533,16 @@ Java 8 中,锁粒度更细,`synchronized` 只锁定当前链表或红黑二 拿 get 方法取值来说,返回的结果为 null 存在两种情况: -- 值没有在集合中 ; +- 值没有在集合中; - 值本身就是 null。 这也就是二义性的由来。 -具体可以参考 [ConcurrentHashMap 源码分析](https://javaguide.cn/java/collection/concurrent-hash-map-source-code.html) 。 +具体可以参考 [ConcurrentHashMap 源码分析](https://javaguide.cn/java/collection/concurrent-hash-map-source-code.html)。 多线程环境下,存在一个线程操作该 `ConcurrentHashMap` 时,其他的线程将该 `ConcurrentHashMap` 修改的情况,所以无法通过 `containsKey(key)` 来判断否存在这个键值对,也就没办法解决二义性问题了。 -与此形成对比的是,`HashMap` 可以存储 null 的 key 和 value,但 null 作为键只能有一个,null 作为值可以有多个。如果传入 null 作为参数,就会返回 hash 值为 0 的位置的值。单线程环境下,不存在一个线程操作该 HashMap 时,其他的线程将该 `HashMap` 修改的情况,所以可以通过 `contains(key)`来做判断是否存在这个键值对,从而做相应的处理,也就不存在二义性问题。 +与此形成对比的是,`HashMap` 可以存储 null 的 key 和 value,但 null 作为键只能有一个,null 作为值可以有多个。如果传入 null 作为参数,就会返回 hash 值为 0 的位置的值。单线程环境下,不存在一个线程操作该 HashMap 时,其他的线程将该 `HashMap` 修改的情况,所以可以通过 `contains(key)` 来做判断是否存在这个键值对,从而做相应的处理,也就不存在二义性问题。 也就是说,多线程下无法正确判定键值对是否存在(存在其他线程修改的情况),单线程是可以的(不存在其他线程修改的情况)。 @@ -558,11 +558,11 @@ public static final Object NULL = new Object(); 翻译过来之后的,大致意思还是单线程下可以容忍歧义,而多线程下无法容忍。 -### ⭐️ConcurrentHashMap 能保证复合操作的原子性吗? +### ⭐️ ConcurrentHashMap 能保证复合操作的原子性吗? `ConcurrentHashMap` 是线程安全的,意味着它可以保证多个线程同时对它进行读写操作时,不会出现数据不一致的情况,也不会导致 JDK1.7 及之前版本的 `HashMap` 多线程操作导致死循环问题。但是,这并不意味着它可以保证所有的复合操作都是原子性的,一定不要搞混了! -复合操作是指由多个基本操作(如`put`、`get`、`remove`、`containsKey`等)组成的操作,例如先判断某个键是否存在`containsKey(key)`,然后根据结果进行插入或更新`put(key, value)`。这种操作在执行过程中可能会被其他线程打断,导致结果不符合预期。 +复合操作是指由多个基本操作(如 `put`、`get`、`remove`、`containsKey` 等)组成的操作,例如先判断某个键是否存在 `containsKey(key)`,然后根据结果进行插入或更新 `put(key, value)`。这种操作在执行过程中可能会被其他线程打断,导致结果不符合预期。 例如,有两个线程 A 和 B 同时对 `ConcurrentHashMap` 进行复合操作,如下: @@ -588,7 +588,7 @@ map.put(key, anotherValue); **那如何保证 `ConcurrentHashMap` 复合操作的原子性呢?** -`ConcurrentHashMap` 提供了一些原子性的复合操作,如 `putIfAbsent`、`compute`、`computeIfAbsent` 、`computeIfPresent`、`merge`等。这些方法都可以接受一个函数作为参数,根据给定的 key 和 value 来计算一个新的 value,并且将其更新到 map 中。 +`ConcurrentHashMap` 提供了一些原子性的复合操作,如 `putIfAbsent`、`compute`、`computeIfAbsent`、`computeIfPresent`、`merge` 等。这些方法都可以接受一个函数作为参数,根据给定的 key 和 value 来计算一个新的 value,并且将其更新到 map 中。 上面的代码可以改写为: @@ -615,8 +615,8 @@ map.computeIfAbsent(key, k -> anotherValue); **`Collections` 工具类常用方法**: - 排序 -- 查找,替换操作 -- 同步控制(不推荐,需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合) +- 查找,替换操作 +- 同步控制(不推荐,需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合) ### 排序操作 @@ -629,7 +629,7 @@ void swap(List list, int i , int j)//交换两个索引位置的元素 void rotate(List list, int distance)//旋转。当distance为正数时,将list后distance个元素整体移到前面。当distance为负数时,将 list的前distance个元素整体移到后面 ``` -### 查找,替换操作 +### 查找,替换操作 ```java int binarySearch(List list, Object key)//对List进行二分查找,返回索引,注意List必须是有序的 @@ -643,7 +643,7 @@ boolean replaceAll(List list, Object oldVal, Object newVal)//用新元素替换 ### 同步控制 -`Collections` 提供了多个`synchronizedXxx()`方法·,该方法可以将指定集合包装成线程同步的集合,从而解决多线程并发访问集合时的线程安全问题。 +`Collections` 提供了多个 `synchronizedXxx()` 方法·,该方法可以将指定集合包装成线程同步的集合,从而解决多线程并发访问集合时的线程安全问题。 我们知道 `HashSet`,`TreeSet`,`ArrayList`,`LinkedList`,`HashMap`,`TreeMap` 都是线程不安全的。`Collections` 提供了多个静态方法可以把他们包装成线程同步的集合。 diff --git a/docs/java/collection/linkedhashmap-source-code.md b/docs/java/collection/linkedhashmap-source-code.md index 61ce785ffb6..91463b40fc8 100644 --- a/docs/java/collection/linkedhashmap-source-code.md +++ b/docs/java/collection/linkedhashmap-source-code.md @@ -15,7 +15,7 @@ head: `LinkedHashMap` 是 Java 提供的一个集合类,它继承自 `HashMap`,并在 `HashMap` 基础上维护一条双向链表,使得具备如下特性: 1. 支持遍历时会按照插入顺序有序进行迭代。 -2. 支持按照元素访问顺序排序,适用于封装 LRU 缓存工具。 +2. 支持按照元素访问顺序排序,适用于封装 LRU 缓存工具。 3. 因为内部使用双向链表维护各个节点,所以遍历时的效率和元素个数成正比,相较于和容量成正比的 HashMap 来说,迭代效率会高很多。 `LinkedHashMap` 逻辑结构如下图所示,它是在 `HashMap` 基础上在各个节点之间维护一条双向链表,使得原本散列在不同 bucket 上的节点、链表、红黑树有序关联起来。 @@ -49,11 +49,11 @@ r:1 e:23 ``` -可以看出,`LinkedHashMap` 的迭代顺序是和插入顺序一致的,这一点是 `HashMap` 所不具备的。 +可以看出,`LinkedHashMap` 的迭代顺序是和插入顺序一致的,这一点是 `HashMap` 所不具备的。 ### 访问顺序遍历 -`LinkedHashMap` 定义了排序模式 `accessOrder`(boolean 类型,默认为 false),访问顺序则为 true,插入顺序则为 false。 +`LinkedHashMap` 定义了排序模式 `accessOrder`(boolean 类型,默认为 false),访问顺序则为 true,插入顺序则为 false。 为了实现访问顺序遍历,我们可以使用传入 `accessOrder` 属性的 `LinkedHashMap` 构造方法,并将 `accessOrder` 设置为 true,表示其具备访问有序性。 @@ -94,8 +94,8 @@ for (Map.Entry entry : map.entrySet()) { 具体实现思路如下: - 继承 `LinkedHashMap`; -- 构造方法中指定 `accessOrder` 为 true ,这样在访问元素时就会把该元素移动到链表尾部,链表首元素就是最近最少被访问的元素; -- 重写`removeEldestEntry` 方法,该方法会返回一个 boolean 值,告知 `LinkedHashMap` 是否需要移除链表首元素(缓存容量有限)。 +- 构造方法中指定 `accessOrder` 为 true,这样在访问元素时就会把该元素移动到链表尾部,链表首元素就是最近最少被访问的元素; +- 重写 `removeEldestEntry` 方法,该方法会返回一个 boolean 值,告知 `LinkedHashMap` 是否需要移除链表首元素(缓存容量有限)。 ```java public class LRUCache extends LinkedHashMap { @@ -140,16 +140,16 @@ four five ``` -从输出结果来看,由于缓存容量为 3 ,因此,添加第 4 个元素时,第 1 个元素会被删除。添加第 5 个元素时,第 2 个元素会被删除。 +从输出结果来看,由于缓存容量为 3,因此,添加第 4 个元素时,第 1 个元素会被删除。添加第 5 个元素时,第 2 个元素会被删除。 ## LinkedHashMap 源码解析 ### Node 的设计 -在正式讨论 `LinkedHashMap` 前,我们先来聊聊 `LinkedHashMap` 节点 `Entry` 的设计,我们都知道 `HashMap` 的 bucket 上的因为冲突转为链表的节点会在符合以下两个条件时会将链表转为红黑树: +在正式讨论 `LinkedHashMap` 前,我们先来聊聊 `LinkedHashMap` 节点 `Entry` 的设计,我们都知道 `HashMap` 的 bucket 上的因为冲突转为链表的节点会在符合以下两个条件时会将链表转为红黑树: -1. ~~链表上的节点个数达到树化的阈值 7,即`TREEIFY_THRESHOLD - 1`。~~ -2. bucket 的容量达到最小的树化容量即`MIN_TREEIFY_CAPACITY`。 +1. ~~链表上的节点个数达到树化的阈值 7,即 `TREEIFY_THRESHOLD - 1`。~~ +2. bucket 的容量达到最小的树化容量即 `MIN_TREEIFY_CAPACITY`。 > **🐛 修正(参见:[issue#2147](https://github.com/Snailclimb/JavaGuide/issues/2147))**: > @@ -157,7 +157,7 @@ five > > ![](https://oss.javaguide.cn/github/javaguide/java/jvm/LinkedHashMap-putval-TREEIFY.png) -而 `LinkedHashMap` 是在 `HashMap` 的基础上为 bucket 上的每一个节点建立一条双向链表,这就使得转为红黑树的树节点也需要具备双向链表节点的特性,即每一个树节点都需要拥有两个引用存储前驱节点和后继节点的地址,所以对于树节点类 `TreeNode` 的设计就是一个比较棘手的问题。 +而 `LinkedHashMap` 是在 `HashMap` 的基础上为 bucket 上的每一个节点建立一条双向链表,这就使得转为红黑树的树节点也需要具备双向链表节点的特性,即每一个树节点都需要拥有两个引用存储前驱节点和后继节点的地址,所以对于树节点类 `TreeNode` 的设计就是一个比较棘手的问题。 对此我们不妨来看看两者之间节点类的类图,可以看到: @@ -166,11 +166,11 @@ five ![LinkedHashMap 和 HashMap 之间的关系](https://oss.javaguide.cn/github/javaguide/java/collection/map-hashmap-linkedhashmap.png) -很多读者此时就会有这样一个疑问,为什么 `HashMap` 的树节点 `TreeNode` 要通过 `LinkedHashMap` 获取双向链表的特性呢?为什么不直接在 `Node` 上实现前驱和后继指针呢? +很多读者此时就会有这样一个疑问,为什么 `HashMap` 的树节点 `TreeNode` 要通过 `LinkedHashMap` 获取双向链表的特性呢?为什么不直接在 `Node` 上实现前驱和后继指针呢? -先来回答第一个问题,我们都知道 `LinkedHashMap` 是在 `HashMap` 基础上对节点增加双向指针实现双向链表的特性,所以 `LinkedHashMap` 内部链表转红黑树时,对应的节点会转为树节点 `TreeNode`,为了保证使用 `LinkedHashMap` 时树节点具备双向链表的特性,所以树节点 `TreeNode` 需要继承 `LinkedHashMap` 的 `Entry`。 +先来回答第一个问题,我们都知道 `LinkedHashMap` 是在 `HashMap` 基础上对节点增加双向指针实现双向链表的特性,所以 `LinkedHashMap` 内部链表转红黑树时,对应的节点会转为树节点 `TreeNode`,为了保证使用 `LinkedHashMap` 时树节点具备双向链表的特性,所以树节点 `TreeNode` 需要继承 `LinkedHashMap` 的 `Entry`。 -再来说说第二个问题,我们直接在 `HashMap` 的节点 `Node` 上直接实现前驱和后继指针,然后 `TreeNode` 直接继承 `Node` 获取双向链表的特性为什么不行呢?其实这样做也是可以的。只不过这种做法会使得使用 `HashMap` 时存储键值对的节点类 `Node` 多了两个没有必要的引用,占用没必要的内存空间。 +再来说说第二个问题,我们直接在 `HashMap` 的节点 `Node` 上直接实现前驱和后继指针,然后 `TreeNode` 直接继承 `Node` 获取双向链表的特性为什么不行呢?其实这样做也是可以的。只不过这种做法会使得使用 `HashMap` 时存储键值对的节点类 `Node` 多了两个没有必要的引用,占用没必要的内存空间。 所以,为了保证 `HashMap` 底层的节点类 `Node` 没有多余的引用,又要保证 `LinkedHashMap` 的节点类 `Entry` 拥有存储链表的引用,设计者就让 `LinkedHashMap` 的节点 `Entry` 去继承 Node 并增加存储前驱后继节点的引用 `before`、`after`,让需要用到链表特性的节点去实现需要的逻辑。然后树节点 `TreeNode` 再通过继承 `Entry` 获取 `before`、`after` 两个指针。 @@ -183,7 +183,7 @@ static class Entry extends HashMap.Node { } ``` -但是这样做,不也使得使用 `HashMap` 时的 `TreeNode` 多了两个没有必要的引用吗?这不也是一种空间的浪费吗? +但是这样做,不也使得使用 `HashMap` 时的 `TreeNode` 多了两个没有必要的引用吗?这不也是一种空间的浪费吗? ```java static final class TreeNode extends LinkedHashMap.Entry { @@ -192,7 +192,7 @@ static final class TreeNode extends LinkedHashMap.Entry { } ``` -对于这个问题,引用作者的一段注释,作者们认为在良好的 `hashCode` 算法时,`HashMap` 转红黑树的概率不大。就算转为红黑树变为树节点,也可能会因为移除或者扩容将 `TreeNode` 变为 `Node`,所以 `TreeNode` 的使用概率不算很大,对于这一点资源空间的浪费是可以接受的。 +对于这个问题,引用作者的一段注释,作者们认为在良好的 `hashCode` 算法时,`HashMap` 转红黑树的概率不大。就算转为红黑树变为树节点,也可能会因为移除或者扩容将 `TreeNode` 变为 `Node`,所以 `TreeNode` 的使用概率不算很大,对于这一点资源空间的浪费是可以接受的。 ```bash Because TreeNodes are about twice the size of regular nodes, we @@ -232,7 +232,7 @@ public LinkedHashMap(int initialCapacity, } ``` -我们上面也提到了,默认情况下 `accessOrder` 为 false,如果我们要让 `LinkedHashMap` 实现键值对按照访问顺序排序(即将最近未访问的元素排在链表首部、最近访问的元素移动到链表尾部),需要调用第 4 个构造方法将 `accessOrder` 设置为 true。 +我们上面也提到了,默认情况下 `accessOrder` 为 false,如果我们要让 `LinkedHashMap` 实现键值对按照访问顺序排序(即将最近未访问的元素排在链表首部、最近访问的元素移动到链表尾部),需要调用第 4 个构造方法将 `accessOrder` 设置为 true。 ### get 方法 @@ -441,7 +441,7 @@ void afterNodeRemoval(Node e) { // unlink 同样的 `LinkedHashMap` 并没有实现插入方法,而是直接继承 `HashMap` 的所有插入方法交由用户使用,但为了维护双向链表访问的有序性,它做了这样两件事: -1. 重写 `afterNodeAccess`(上文提到过),如果当前被插入的 key 已存在与 `map` 中,因为 `LinkedHashMap` 的插入操作会将新节点追加至链表末尾,所以对于存在的 key 则调用 `afterNodeAccess` 将其放到链表末端。 +1. 重写 `afterNodeAccess`(上文提到过),如果当前被插入的 key 已存在与 `map` 中,因为 `LinkedHashMap` 的插入操作会将新节点追加至链表末尾,所以对于存在的 key 则调用 `afterNodeAccess` 将其放到链表末端。 2. 重写了 `HashMap` 的 `afterNodeInsertion` 方法,当 `removeEldestEntry` 返回 true 时,会将链表首节点移除。 这一点我们可以在 `HashMap` 的插入操作核心方法 `putVal` 中看到。 @@ -502,7 +502,7 @@ void afterNodeInsertion(boolean evict) { // possibly remove eldest 从源码可以看出, `afterNodeInsertion` 方法完成了下面这些操作: -1. 判断 `eldest` 是否为 true,只有为 true 才能说明可能需要将最年长的键值对(即链表首部的元素)进行移除,具体是否具体要进行移除,还得确定链表是否为空`((first = head) != null)`,以及 `removeEldestEntry` 方法是否返回 true,只有这两个方法返回 true 才能确定当前链表不为空,且链表需要进行移除操作了。 +1. 判断 `eldest` 是否为 true,只有为 true 才能说明可能需要将最年长的键值对(即链表首部的元素)进行移除,具体是否具体要进行移除,还得确定链表是否为空 `((first = head) != null)`,以及 `removeEldestEntry` 方法是否返回 true,只有这两个方法返回 true 才能确定当前链表不为空,且链表需要进行移除操作了。 2. 获取链表第一个元素的 key。 3. 调用 `HashMap` 的 `removeNode` 方法,该方法我们上文提到过,它会将节点从 `HashMap` 的 bucket 中移除,并且 `LinkedHashMap` 还重写了 `removeNode` 中的 `afterNodeRemoval` 方法,所以这一步将通过调用 `removeNode` 将元素从 `HashMap` 的 bucket 中移除,并和 `LinkedHashMap` 的双向链表断开,等待 gc 回收。 diff --git a/docs/java/collection/linkedlist-source-code.md b/docs/java/collection/linkedlist-source-code.md index b6d4c3d598c..6af5aad7b19 100644 --- a/docs/java/collection/linkedlist-source-code.md +++ b/docs/java/collection/linkedlist-source-code.md @@ -14,15 +14,15 @@ head: ## LinkedList 简介 -`LinkedList` 是一个基于双向链表实现的集合类,经常被拿来和 `ArrayList` 做比较。关于 `LinkedList` 和`ArrayList`的详细对比,我们 [Java 集合常见面试题总结(上)](./java-collection-questions-01.md)有详细介绍到。 +`LinkedList` 是一个基于双向链表实现的集合类,经常被拿来和 `ArrayList` 做比较。关于 `LinkedList` 和 `ArrayList` 的详细对比,我们 [Java 集合常见面试题总结(上)](./java-collection-questions-01.md)有详细介绍到。 ![双向链表](https://oss.javaguide.cn/github/javaguide/cs-basics/data-structure/bidirectional-linkedlist.png) -不过,我们在项目中一般是不会使用到 `LinkedList` 的,需要用到 `LinkedList` 的场景几乎都可以使用 `ArrayList` 来代替,并且,性能通常会更好!就连 `LinkedList` 的作者约书亚 · 布洛克(Josh Bloch)自己都说从来不会使用 `LinkedList` 。 +不过,我们在项目中一般是不会使用到 `LinkedList` 的,需要用到 `LinkedList` 的场景几乎都可以使用 `ArrayList` 来代替,并且,性能通常会更好!就连 `LinkedList` 的作者约书亚 · 布洛克(Josh Bloch)自己都说从来不会使用 `LinkedList`。 ![](https://oss.javaguide.cn/github/javaguide/redisimage-20220412110853807.png) -另外,不要下意识地认为 `LinkedList` 作为链表就最适合元素增删的场景。我在上面也说了,`LinkedList` 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1),其他情况增删元素的平均时间复杂度都是 O(n) 。 +另外,不要下意识地认为 `LinkedList` 作为链表就最适合元素增删的场景。我在上面也说了,`LinkedList` 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1),其他情况增删元素的平均时间复杂度都是 O(n)。 ### LinkedList 插入和删除元素的时间复杂度? @@ -49,15 +49,15 @@ public class LinkedList } ``` -`LinkedList` 继承了 `AbstractSequentialList` ,而 `AbstractSequentialList` 又继承于 `AbstractList` 。 +`LinkedList` 继承了 `AbstractSequentialList`,而 `AbstractSequentialList` 又继承于 `AbstractList`。 -阅读过 `ArrayList` 的源码我们就知道,`ArrayList` 同样继承了 `AbstractList` , 所以 `LinkedList` 会有大部分方法和 `ArrayList` 相似。 +阅读过 `ArrayList` 的源码我们就知道,`ArrayList` 同样继承了 `AbstractList`, 所以 `LinkedList` 会有大部分方法和 `ArrayList` 相似。 `LinkedList` 实现了以下接口: - `List` : 表明它是一个列表,支持添加、删除、查找等操作,并且可以通过下标进行访问。 -- `Deque` :继承自 `Queue` 接口,具有双端队列的特性,支持从两端插入和删除元素,方便实现栈和队列等数据结构。需要注意,`Deque` 的发音为 "deck" [dɛk],这个大部分人都会读错。 -- `Cloneable` :表明它具有拷贝能力,可以进行深拷贝或浅拷贝操作。 +- `Deque`:继承自 `Queue` 接口,具有双端队列的特性,支持从两端插入和删除元素,方便实现栈和队列等数据结构。需要注意,`Deque` 的发音为 "deck" [dɛk],这个大部分人都会读错。 +- `Cloneable`:表明它具有拷贝能力,可以进行深拷贝或浅拷贝操作。 - `Serializable` : 表明它可以进行序列化操作,也就是可以将对象转换为字节流进行持久化存储或网络传输,非常方便。 ![LinkedList 类图](https://oss.javaguide.cn/github/javaguide/java/collection/linkedlist--class-diagram.png) @@ -99,7 +99,7 @@ public LinkedList(Collection c) { `LinkedList` 除了实现了 `List` 接口相关方法,还实现了 `Deque` 接口的很多方法,所以我们有很多种方式插入元素。 -我们这里以 `List` 接口中相关的插入方法为例进行源码讲解,对应的是`add()` 方法。 +我们这里以 `List` 接口中相关的插入方法为例进行源码讲解,对应的是 `add()` 方法。 `add()` 方法有两个版本: @@ -170,7 +170,7 @@ void linkBefore(E e, Node succ) { ### 获取元素 -`LinkedList`获取元素相关的方法一共有 3 个: +`LinkedList` 获取元素相关的方法一共有 3 个: 1. `getFirst()`:获取链表的第一个元素。 2. `getLast()`:获取链表的最后一个元素。 @@ -231,7 +231,7 @@ Node node(int index) { ### 删除元素 -`LinkedList`删除元素相关的方法一共有 5 个: +`LinkedList` 删除元素相关的方法一共有 5 个: 1. `removeFirst()`:删除并返回链表的第一个元素。 2. `removeLast()`:删除并返回链表的最后一个元素。 @@ -346,7 +346,7 @@ E unlink(Node x) { ### 遍历链表 -推荐使用`for-each` 循环来遍历 `LinkedList` 中的元素, `for-each` 循环最终会转换成迭代器形式。 +推荐使用 `for-each` 循环来遍历 `LinkedList` 中的元素, `for-each` 循环最终会转换成迭代器形式。 ```java LinkedList list = new LinkedList<>(); diff --git a/docs/java/concurrent/aqs.md b/docs/java/concurrent/aqs.md index cd9654bf21d..d9e85718f47 100644 --- a/docs/java/concurrent/aqs.md +++ b/docs/java/concurrent/aqs.md @@ -14,7 +14,7 @@ head: ## AQS 介绍 -AQS 的全称为 `AbstractQueuedSynchronizer` ,翻译过来的意思就是抽象队列同步器。这个类在 `java.util.concurrent.locks` 包下面。 +AQS 的全称为 `AbstractQueuedSynchronizer`,翻译过来的意思就是抽象队列同步器。这个类在 `java.util.concurrent.locks` 包下面。 ![](https://oss.javaguide.cn/github/javaguide/AQS.png) @@ -25,7 +25,7 @@ public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchron } ``` -AQS 为构建锁和同步器提供了一些通用功能的实现。因此,使用 AQS 能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的 `ReentrantLock`,`Semaphore`,其他的诸如 `ReentrantReadWriteLock`,`SynchronousQueue`等等皆是基于 AQS 的。 +AQS 为构建锁和同步器提供了一些通用功能的实现。因此,使用 AQS 能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的 `ReentrantLock`,`Semaphore`,其他的诸如 `ReentrantReadWriteLock`,`SynchronousQueue` 等等皆是基于 AQS 的。 ## AQS 原理 @@ -65,21 +65,21 @@ AQS(AbstractQueuedSynchronizer)在 CLH 锁的基础上进一步优化,形 AQS 内部通过队列来存储等待的线程节点。由于队列是共享资源,在多线程场景下,需要保证队列的同步访问。 -AQS 内部通过 `CAS` 操作来控制队列的同步访问,`CAS` 操作主要用于控制 `队列初始化` 、 `线程节点入队` 两个操作的并发安全。虽然利用 `CAS` 控制并发安全可以保证比较好的性能,但同时会带来比较高的 **编码复杂度** 。 +AQS 内部通过 `CAS` 操作来控制队列的同步访问,`CAS` 操作主要用于控制 `队列初始化`、 `线程节点入队` 两个操作的并发安全。虽然利用 `CAS` 控制并发安全可以保证比较好的性能,但同时会带来比较高的 **编码复杂度**。 #### AQS 中为什么 Node 节点需要不同的状态? -AQS 中的 `waitStatus` 状态类似于 **状态机** ,通过不同状态来表明 Node 节点的不同含义,并且根据不同操作,来控制状态之间的流转。 +AQS 中的 `waitStatus` 状态类似于 **状态机**,通过不同状态来表明 Node 节点的不同含义,并且根据不同操作,来控制状态之间的流转。 -- 状态 `0` :新节点加入队列之后,初始状态为 `0` 。 +- 状态 `0`:新节点加入队列之后,初始状态为 `0`。 -- 状态 `SIGNAL` :当有新的节点加入队列,此时新节点的前继节点状态就会由 `0` 更新为 `SIGNAL` ,表示前继节点释放锁之后,需要对新节点进行唤醒操作。如果唤醒 `SIGNAL` 状态节点的后续节点,就会将 `SIGNAL` 状态更新为 `0` 。即通过清除 `SIGNAL` 状态,表示已经执行了唤醒操作。 +- 状态 `SIGNAL`:当有新的节点加入队列,此时新节点的前继节点状态就会由 `0` 更新为 `SIGNAL`,表示前继节点释放锁之后,需要对新节点进行唤醒操作。如果唤醒 `SIGNAL` 状态节点的后续节点,就会将 `SIGNAL` 状态更新为 `0`。即通过清除 `SIGNAL` 状态,表示已经执行了唤醒操作。 -- 状态 `CANCELLED` :如果一个节点在队列中等待获取锁锁时,因为某种原因失败了,该节点的状态就会变为 `CANCELLED` ,表明取消获取锁,这种状态的节点是异常的,无法被唤醒,也无法唤醒后继节点。 +- 状态 `CANCELLED`:如果一个节点在队列中等待获取锁锁时,因为某种原因失败了,该节点的状态就会变为 `CANCELLED`,表明取消获取锁,这种状态的节点是异常的,无法被唤醒,也无法唤醒后继节点。 ### AQS 核心思想 -AQS 核心思想是,如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的工作线程,并且将共享资源设置为锁定状态。如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制,这个机制 AQS 是基于 **CLH 锁** (Craig, Landin, and Hagersten locks) 进一步优化实现的。 +AQS 核心思想是,如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的工作线程,并且将共享资源设置为锁定状态。如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制,这个机制 AQS 是基于 **CLH 锁**(Craig, Landin, and Hagersten locks) 进一步优化实现的。 **CLH 锁** 对自旋锁进行了改进,是基于单链表的自旋锁。在多线程场景下,会将请求获取锁的线程组织成一个单向队列,每个等待的线程会通过自旋访问前一个线程节点的状态,前一个节点释放锁之后,当前节点才可以获取锁。**CLH 锁** 的队列结构如下图所示。 @@ -89,8 +89,8 @@ AQS 中使用的 **等待队列** 是 CLH 锁队列的变体(接下来简称 AQS 的 CLH 变体队列是一个双向队列,会暂时获取不到锁的线程将被加入到该队列中,CLH 变体队列和原本的 CLH 锁队列的区别主要有两点: -- 由 **自旋** 优化为 **自旋 + 阻塞** :自旋操作的性能很高,但大量的自旋操作比较占用 CPU 资源,因此在 CLH 变体队列中会先通过自旋尝试获取锁,如果失败再进行阻塞等待。 -- 由 **单向队列** 优化为 **双向队列** :在 CLH 变体队列中,会对等待的线程进行阻塞操作,当队列前边的线程释放锁之后,需要对后边的线程进行唤醒,因此增加了 `next` 指针,成为了双向队列。 +- 由 **自旋** 优化为 **自旋 + 阻塞**:自旋操作的性能很高,但大量的自旋操作比较占用 CPU 资源,因此在 CLH 变体队列中会先通过自旋尝试获取锁,如果失败再进行阻塞等待。 +- 由 **单向队列** 优化为 **双向队列**:在 CLH 变体队列中,会对等待的线程进行阻塞操作,当队列前边的线程释放锁之后,需要对后边的线程进行唤醒,因此增加了 `next` 指针,成为了双向队列。 AQS 将每条请求共享资源的线程封装成一个 CLH 变体队列的一个结点(Node)来实现锁的分配。在 CLH 变体队列中,一个节点表示一个线程,它保存着线程的引用(thread)、 当前节点在队列中的状态(waitStatus)、前驱节点(prev)、后继节点(next)。 @@ -113,7 +113,7 @@ AQS 使用 **int 成员变量 `state` 表示同步状态**,通过内置的 **F private volatile int state; ``` -另外,状态信息 `state` 可以通过 `protected` 类型的`getState()`、`setState()`和`compareAndSetState()` 进行操作。并且,这几个方法都是 `final` 修饰的,在子类中无法被重写。 +另外,状态信息 `state` 可以通过 `protected` 类型的 `getState()`、`setState()` 和 `compareAndSetState()` 进行操作。并且,这几个方法都是 `final` 修饰的,在子类中无法被重写。 ```java //返回同步状态的当前值 @@ -136,11 +136,11 @@ protected final boolean compareAndSetState(int expect, int update) { ![AQS 独占模式获取锁](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-exclusive-mode-acquire-lock.png) -再以倒计时器 `CountDownLatch` 以例,任务分为 N 个子线程去执行,`state` 也初始化为 N(注意 N 要与线程个数一致)。这 N 个子线程开始执行任务,每执行完一个子线程,就调用一次 `countDown()` 方法。该方法会尝试使用 CAS(Compare and Swap) 操作,让 `state` 的值减少 1。当所有的子线程都执行完毕后(即 `state` 的值变为 0),`CountDownLatch` 会调用 `unpark()` 方法,唤醒主线程。这时,主线程就可以从 `await()` 方法(`CountDownLatch` 中的`await()` 方法而非 AQS 中的)返回,继续执行后续的操作。 +再以倒计时器 `CountDownLatch` 以例,任务分为 N 个子线程去执行,`state` 也初始化为 N(注意 N 要与线程个数一致)。这 N 个子线程开始执行任务,每执行完一个子线程,就调用一次 `countDown()` 方法。该方法会尝试使用 CAS(Compare and Swap) 操作,让 `state` 的值减少 1。当所有的子线程都执行完毕后(即 `state` 的值变为 0),`CountDownLatch` 会调用 `unpark()` 方法,唤醒主线程。这时,主线程就可以从 `await()` 方法(`CountDownLatch` 中的 `await()` 方法而非 AQS 中的)返回,继续执行后续的操作。 ### Node 节点 waitStatus 状态含义 -AQS 中的 `waitStatus` 状态类似于 **状态机** ,通过不同状态来表明 Node 节点的不同含义,并且根据不同操作,来控制状态之间的流转。 +AQS 中的 `waitStatus` 状态类似于 **状态机**,通过不同状态来表明 Node 节点的不同含义,并且根据不同操作,来控制状态之间的流转。 | Node 节点状态 | 值 | 含义 | | ------------- | --- | ------------------------------------------------------------------------------------------------------------------------- | @@ -150,11 +150,11 @@ AQS 中的 `waitStatus` 状态类似于 **状态机** ,通过不同状态来 | `PROPAGATE` | -3 | 用于共享模式。在共享模式下,可能会出现线程在队列中无法被唤醒的情况,因此引入了 `PROPAGATE` 状态来解决这个问题。 | | | 0 | 加入队列的新节点的初始状态。 | -在 AQS 的源码中,经常使用 `> 0` 、 `< 0` 来对 `waitStatus` 进行判断。 +在 AQS 的源码中,经常使用 `> 0`、 `< 0` 来对 `waitStatus` 进行判断。 -如果 `waitStatus > 0` ,表明节点的状态已经取消等待获取资源。 +如果 `waitStatus > 0`,表明节点的状态已经取消等待获取资源。 -如果 `waitStatus < 0` ,表明节点的状态处于正常的状态,即没有取消等待。 +如果 `waitStatus < 0`,表明节点的状态处于正常的状态,即没有取消等待。 其中 `SIGNAL` 状态是最重要的,节点状态流转以及对应操作如下: @@ -169,7 +169,7 @@ AQS 中的 `waitStatus` 状态类似于 **状态机** ,通过不同状态来 基于 AQS 可以实现自定义的同步器, AQS 提供了 5 个模板方法(模板方法模式)。如果需要自定义同步器一般的方式是这样(模板方法模式很经典的一个应用): -1. 自定义的同步器继承 `AbstractQueuedSynchronizer` 。 +1. 自定义的同步器继承 `AbstractQueuedSynchronizer`。 2. 重写 AQS 暴露的模板方法。 **AQS 使用了模板方法模式,自定义同步器时需要重写下面几个 AQS 提供的钩子方法:** @@ -191,13 +191,13 @@ protected boolean isHeldExclusively() 篇幅问题,这里就不详细介绍模板方法模式了,不太了解的小伙伴可以看看这篇文章:[用 Java8 改造后的模板方法模式真的是 yyds!](https://mp.weixin.qq.com/s/zpScSCktFpnSWHWIQem2jg)。 -除了上面提到的钩子方法之外,AQS 类中的其他方法都是 `final` ,所以无法被其他类重写。 +除了上面提到的钩子方法之外,AQS 类中的其他方法都是 `final`,所以无法被其他类重写。 ### AQS 资源共享方式 -AQS 定义两种资源共享方式:`Exclusive`(独占,只有一个线程能执行,如`ReentrantLock`)和`Share`(共享,多个线程可同时执行,如`Semaphore`/`CountDownLatch`)。 +AQS 定义两种资源共享方式:`Exclusive`(独占,只有一个线程能执行,如 `ReentrantLock`)和 `Share`(共享,多个线程可同时执行,如 `Semaphore`/`CountDownLatch`)。 -一般来说,自定义同步器的共享方式要么是独占,要么是共享,他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但 AQS 也支持自定义同步器同时实现独占和共享两种方式,如`ReentrantReadWriteLock`。 +一般来说,自定义同步器的共享方式要么是独占,要么是共享,他们也只需实现 `tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared` 中的一种即可。但 AQS 也支持自定义同步器同时实现独占和共享两种方式,如 `ReentrantReadWriteLock`。 ### 独占模式与共享模式的深入对比 @@ -288,7 +288,7 @@ public class ExclusiveVsSharedDemo { ### AQS 资源获取源码分析(独占模式) -AQS 中以独占模式获取资源的入口方法是 `acquire()` ,如下: +AQS 中以独占模式获取资源的入口方法是 `acquire()`,如下: ```JAVA // AQS @@ -301,9 +301,9 @@ public final void acquire(int arg) { 在 `acquire()` 中,线程会先尝试获取共享资源;如果获取失败,会将线程封装为 Node 节点加入到 AQS 的等待队列中;加入队列之后,会让等待队列中的线程尝试获取资源,并且会对线程进行阻塞操作。分别对应以下三个方法: -- `tryAcquire()` :尝试获取锁(模板方法),`AQS` 不提供具体实现,由子类实现。 -- `addWaiter()` :如果获取锁失败,会将当前线程封装为 Node 节点加入到 AQS 的 CLH 变体队列中等待获取锁。 -- `acquireQueued()` :对线程进行阻塞,并调用 `tryAcquire()` 方法让队列中的线程尝试获取锁。 +- `tryAcquire()`:尝试获取锁(模板方法),`AQS` 不提供具体实现,由子类实现。 +- `addWaiter()`:如果获取锁失败,会将当前线程封装为 Node 节点加入到 AQS 的 CLH 变体队列中等待获取锁。 +- `acquireQueued()`:对线程进行阻塞,并调用 `tryAcquire()` 方法让队列中的线程尝试获取锁。 #### `tryAcquire()` 分析 @@ -318,7 +318,7 @@ protected boolean tryAcquire(int arg) { `tryAcquire()` 方法是 AQS 提供的模板方法,不提供默认实现。 -因此,这里分析 `tryAcquire()` 方法时,以 `ReentrantLock` 的非公平锁(独占锁)为例进行分析,`ReentrantLock` 内部实现的 `tryAcquire()` 会调用到下边的 `nonfairTryAcquire()` : +因此,这里分析 `tryAcquire()` 方法时,以 `ReentrantLock` 的非公平锁(独占锁)为例进行分析,`ReentrantLock` 内部实现的 `tryAcquire()` 会调用到下边的 `nonfairTryAcquire()`: ```JAVA // ReentrantLock @@ -389,7 +389,7 @@ private Node addWaiter(Node mode) { **AQS 内部队列的初始化:** -在执行 `addWaiter()` 时,如果发现 `pred == null` ,即 `tail` 指针为 null,则证明队列没有初始化,需要调用 `enq()` 方法初始化队列,并将 `Node` 节点加入到初始化后的队列中,代码如下: +在执行 `addWaiter()` 时,如果发现 `pred == null`,即 `tail` 指针为 null,则证明队列没有初始化,需要调用 `enq()` 方法初始化队列,并将 `Node` 节点加入到初始化后的队列中,代码如下: ```JAVA // AQS @@ -467,20 +467,20 @@ final boolean acquireQueued(final Node node, int arg) { - **尝试获取资源:** 当前线程加入队列之后,如果发现前继节点是 `head` 节点,说明当前线程是队列中第一个等待的节点,于是调用 `tryAcquire()` 尝试获取资源。 -- **阻塞当前线程** :如果尝试获取资源失败,就需要阻塞当前线程,等待被唤醒之后获取资源。 +- **阻塞当前线程**:如果尝试获取资源失败,就需要阻塞当前线程,等待被唤醒之后获取资源。 **1、尝试获取资源** 在 `acquireQueued()` 方法中,尝试获取资源总共有 2 个步骤: -- `p == head` :表明当前节点的前继节点为 `head` 节点。此时当前节点为 AQS 队列中的第一个等待节点。 -- `tryAcquire(arg) == true` :表明当前线程尝试获取资源成功。 +- `p == head`:表明当前节点的前继节点为 `head` 节点。此时当前节点为 AQS 队列中的第一个等待节点。 +- `tryAcquire(arg) == true`:表明当前线程尝试获取资源成功。 -在成功获取资源之后,就需要将当前线程的节点 **从等待队列中移除** 。移除操作为:将当前等待的线程节点设置为 `head` 节点(`head` 节点是虚拟节点,并不参与排队获取资源)。 +在成功获取资源之后,就需要将当前线程的节点 **从等待队列中移除**。移除操作为:将当前等待的线程节点设置为 `head` 节点(`head` 节点是虚拟节点,并不参与排队获取资源)。 **2、阻塞当前线程** -在 `AQS` 中,当前节点的唤醒需要依赖于上一个节点。如果上一个节点取消获取锁,它的状态就会变为 `CANCELLED` ,`CANCELLED` 状态的节点没有获取到锁,也就无法执行解锁操作对当前节点进行唤醒。因此在阻塞当前线程之前,需要跳过 `CANCELLED` 状态的节点。 +在 `AQS` 中,当前节点的唤醒需要依赖于上一个节点。如果上一个节点取消获取锁,它的状态就会变为 `CANCELLED`,`CANCELLED` 状态的节点没有获取到锁,也就无法执行解锁操作对当前节点进行唤醒。因此在阻塞当前线程之前,需要跳过 `CANCELLED` 状态的节点。 通过 `shouldParkAfterFailedAcquire()` 方法来判断当前线程节点是否可以阻塞,如下: @@ -507,9 +507,9 @@ private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { `shouldParkAfterFailedAcquire()` 方法中的判断逻辑: -- 如果发现前继节点的状态是 `SIGNAL` ,则可以阻塞当前线程。 -- 如果发现前继节点的状态是 `CANCELLED` ,则需要跳过 `CANCELLED` 状态的节点。 -- 如果发现前继节点的状态不是 `SIGNAL` 和 `CANCELLED` ,表明前继节点的状态处于正常等待资源的状态,因此将前继节点的状态设置为 `SIGNAL` ,表明该前继节点需要对后续节点进行唤醒。 +- 如果发现前继节点的状态是 `SIGNAL`,则可以阻塞当前线程。 +- 如果发现前继节点的状态是 `CANCELLED`,则需要跳过 `CANCELLED` 状态的节点。 +- 如果发现前继节点的状态不是 `SIGNAL` 和 `CANCELLED`,表明前继节点的状态处于正常等待资源的状态,因此将前继节点的状态设置为 `SIGNAL`,表明该前继节点需要对后续节点进行唤醒。 当判断当前线程可以阻塞之后,通过调用 `parkAndCheckInterrupt()` 方法来阻塞当前线程。内部使用了 `LockSupport` 来实现阻塞。`LockSupoprt` 底层是基于 `Unsafe` 类来阻塞线程,代码如下: @@ -525,7 +525,7 @@ private final boolean parkAndCheckInterrupt() { **为什么在线程被唤醒之后,要返回线程的中断状态呢?** -在 `parkAndCheckInterrupt()` 方法中,当执行完 `LockSupport.park(this)` ,线程会被阻塞,代码如下: +在 `parkAndCheckInterrupt()` 方法中,当执行完 `LockSupport.park(this)`,线程会被阻塞,代码如下: ```JAVA // AQS @@ -540,7 +540,7 @@ private final boolean parkAndCheckInterrupt() { 这个和线程的中断协作机制有关系,线程被唤醒之后,并不确定是被中断唤醒,还是被 `LockSupport.unpark()` 唤醒,因此需要通过线程的中断状态来判断。 -**在 `acquire()` 方法中,为什么需要调用 `selfInterrupt()` ?** +**在 `acquire()` 方法中,为什么需要调用 `selfInterrupt()`?** `acquire()` 方法代码如下: @@ -553,17 +553,17 @@ public final void acquire(int arg) { } ``` -在 `acquire()` 方法中,当 `if` 语句的条件返回 `true` 后,就会调用 `selfInterrupt()` ,该方法会中断当前线程,为什么需要中断当前线程呢? +在 `acquire()` 方法中,当 `if` 语句的条件返回 `true` 后,就会调用 `selfInterrupt()`,该方法会中断当前线程,为什么需要中断当前线程呢? -当 `if` 判断为 `true` 时,需要 `tryAcquire()` 返回 `false` ,并且 `acquireQueued()` 返回 `true` 。 +当 `if` 判断为 `true` 时,需要 `tryAcquire()` 返回 `false`,并且 `acquireQueued()` 返回 `true`。 -其中 `acquireQueued()` 方法返回的是线程被唤醒之后的 **中断状态** ,通过执行 `Thread.interrupted()` 来返回。该方法在返回中断状态的同时,会清除线程的中断状态。 +其中 `acquireQueued()` 方法返回的是线程被唤醒之后的 **中断状态**,通过执行 `Thread.interrupted()` 来返回。该方法在返回中断状态的同时,会清除线程的中断状态。 -因此如果 `if` 判断为 `true` ,表明线程的中断状态为 `true` ,但是调用 `Thread.interrupted()` 之后,线程的中断状态被清除为 `false` ,因此需要重新执行 `selfInterrupt()` 来重新设置线程的中断状态。 +因此如果 `if` 判断为 `true`,表明线程的中断状态为 `true`,但是调用 `Thread.interrupted()` 之后,线程的中断状态被清除为 `false`,因此需要重新执行 `selfInterrupt()` 来重新设置线程的中断状态。 ### AQS 资源释放源码分析(独占模式) -AQS 中以独占模式释放资源的入口方法是 `release()` ,代码如下: +AQS 中以独占模式释放资源的入口方法是 `release()`,代码如下: ```JAVA // AQS @@ -610,20 +610,20 @@ protected final boolean tryRelease(int releases) { 在 `tryRelease()` 方法中,会先计算释放锁之后的 `state` 值,判断 `state` 值是否为 0。 -- 如果 `state == 0` ,表明该线程没有重入次数了,更新 `free = true` ,并修改持有资源的线程为 null,表明该线程完全释放这把锁。 -- 如果 `state != 0` ,表明该线程还存在重入次数,因此不更新 `free` 值,`free` 值为 `false` 表明该线程没有完全释放这把锁。 +- 如果 `state == 0`,表明该线程没有重入次数了,更新 `free = true`,并修改持有资源的线程为 null,表明该线程完全释放这把锁。 +- 如果 `state != 0`,表明该线程还存在重入次数,因此不更新 `free` 值,`free` 值为 `false` 表明该线程没有完全释放这把锁。 之后更新 `state` 值,并返回 `free` 值,`free` 值表明线程是否完全释放锁。 **2、唤醒后继节点** -如果 `tryRelease()` 返回 `true` ,表明线程已经没有重入次数了,锁已经被完全释放,因此需要唤醒后继节点。 +如果 `tryRelease()` 返回 `true`,表明线程已经没有重入次数了,锁已经被完全释放,因此需要唤醒后继节点。 -在唤醒后继节点之前,需要判断是否可以唤醒后继节点,判断条件为: `h != null && h.waitStatus != 0` 。这里解释一下为什么要这样判断: +在唤醒后继节点之前,需要判断是否可以唤醒后继节点,判断条件为: `h != null && h.waitStatus != 0`。这里解释一下为什么要这样判断: -- `h == null` :表明 `head` 节点还没有被初始化,也就是 AQS 中的队列没有被初始化,因此无法唤醒队列中的线程节点。 -- `h != null && h.waitStatus == 0` :表明头节点刚刚初始化完毕(节点的初始化状态为 0),后继节点线程还没有成功入队,因此不需要对后续节点进行唤醒。(当后继节点入队之后,会将前继节点的状态修改为 `SIGNAL` ,表明需要对后继节点进行唤醒) -- `h != null && h.waitStatus != 0` :其中 `waitStatus` 有可能大于 0,也有可能小于 0。其中 `> 0` 表明节点已经取消等待获取资源,`< 0` 表明节点处于正常等待状态。 +- `h == null`:表明 `head` 节点还没有被初始化,也就是 AQS 中的队列没有被初始化,因此无法唤醒队列中的线程节点。 +- `h != null && h.waitStatus == 0`:表明头节点刚刚初始化完毕(节点的初始化状态为 0),后继节点线程还没有成功入队,因此不需要对后续节点进行唤醒。(当后继节点入队之后,会将前继节点的状态修改为 `SIGNAL`,表明需要对后继节点进行唤醒) +- `h != null && h.waitStatus != 0`:其中 `waitStatus` 有可能大于 0,也有可能小于 0。其中 `> 0` 表明节点已经取消等待获取资源,`< 0` 表明节点处于正常等待状态。 接下来进入 `unparkSuccessor()` 方法查看如何唤醒后继节点: @@ -649,9 +649,9 @@ private void unparkSuccessor(Node node) { } ``` -在 `unparkSuccessor()` 中,如果头节点的状态 `< 0` (在正常情况下,只要有后继节点,头节点的状态应该为 `SIGNAL` ,即 -1),表示需要对后继节点进行唤醒,因此这里提前清除头节点的状态标识,将状态修改为 0,表示已经执行了对后续节点唤醒的操作。 +在 `unparkSuccessor()` 中,如果头节点的状态 `< 0`(在正常情况下,只要有后继节点,头节点的状态应该为 `SIGNAL`,即 -1),表示需要对后继节点进行唤醒,因此这里提前清除头节点的状态标识,将状态修改为 0,表示已经执行了对后续节点唤醒的操作。 -如果 `s == null` 或者 `s.waitStatus > 0` ,表明后继节点异常,此时不能唤醒异常节点,而是要找到正常状态的节点进行唤醒。 +如果 `s == null` 或者 `s.waitStatus > 0`,表明后继节点异常,此时不能唤醒异常节点,而是要找到正常状态的节点进行唤醒。 因此需要从 `tail` 指针向前遍历,来找到第一个状态正常(`waitStatus <= 0`)的节点进行唤醒。 @@ -678,9 +678,9 @@ private Node addWaiter(Node mode) { } ``` -在 `addWaiter()` 方法中,`node` 节点入队需要修改 `node.prev` 和 `pred.next` 两个指针,但是这两个操作并不是 **原子操作** ,先修改了 `node.prev` 指针,之后才修改 `pred.next` 指针。 +在 `addWaiter()` 方法中,`node` 节点入队需要修改 `node.prev` 和 `pred.next` 两个指针,但是这两个操作并不是 **原子操作**,先修改了 `node.prev` 指针,之后才修改 `pred.next` 指针。 -在极端情况下,可能会出现 `head` 节点的下一个节点状态为 `CANCELLED` ,此时新入队的节点仅更新了 `node.prev` 指针,还未更新 `pred.next` 指针,如下图: +在极端情况下,可能会出现 `head` 节点的下一个节点状态为 `CANCELLED`,此时新入队的节点仅更新了 `node.prev` 指针,还未更新 `pred.next` 指针,如下图: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-addWaiter.png) @@ -692,33 +692,33 @@ private Node addWaiter(Node mode) { 由于 AQS 是底层同步工具,获取和释放资源的方法并没有提供具体实现,因此这里基于 `ReentrantLock` 来画图进行讲解。 -假设总共有 3 个线程尝试获取锁,线程分别为 `T1` 、 `T2` 和 `T3` 。 +假设总共有 3 个线程尝试获取锁,线程分别为 `T1`、 `T2` 和 `T3`。 -此时,假设线程 `T1` 先获取到锁,线程 `T2` 排队等待获取锁。在线程 `T2` 进入队列之前,需要对 AQS 内部队列进行初始化。`head` 节点在初始化后状态为 `0` 。AQS 内部初始化后的队列如下图: +此时,假设线程 `T1` 先获取到锁,线程 `T2` 排队等待获取锁。在线程 `T2` 进入队列之前,需要对 AQS 内部队列进行初始化。`head` 节点在初始化后状态为 `0`。AQS 内部初始化后的队列如下图: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-acquire-and-release-process.png) -此时,线程 `T2` 尝试获取锁。由于线程 `T1` 持有锁,因此线程 `T2` 会进入队列中等待获取锁。同时会将前继节点( `head` 节点)的状态由 `0` 更新为 `SIGNAL` ,表示需要对 `head` 节点的后继节点进行唤醒。此时,AQS 内部队列如下图所示: +此时,线程 `T2` 尝试获取锁。由于线程 `T1` 持有锁,因此线程 `T2` 会进入队列中等待获取锁。同时会将前继节点(`head` 节点)的状态由 `0` 更新为 `SIGNAL`,表示需要对 `head` 节点的后继节点进行唤醒。此时,AQS 内部队列如下图所示: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-acquire-and-release-process-2.png) -此时,线程 `T3` 尝试获取锁。由于线程 `T1` 持有锁,因此线程 `T3` 会进入队列中等待获取锁。同时会将前继节点(线程 `T2` 节点)的状态由 `0` 更新为 `SIGNAL` ,表示线程 `T2` 节点需要对后继节点进行唤醒。此时,AQS 内部队列如下图所示: +此时,线程 `T3` 尝试获取锁。由于线程 `T1` 持有锁,因此线程 `T3` 会进入队列中等待获取锁。同时会将前继节点(线程 `T2` 节点)的状态由 `0` 更新为 `SIGNAL`,表示线程 `T2` 节点需要对后继节点进行唤醒。此时,AQS 内部队列如下图所示: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-acquire-and-release-process-3.png) -此时,假设线程 `T1` 释放锁,会唤醒后继节点 `T2` 。线程 `T2` 被唤醒后获取到锁,并且会从等待队列中退出。 +此时,假设线程 `T1` 释放锁,会唤醒后继节点 `T2`。线程 `T2` 被唤醒后获取到锁,并且会从等待队列中退出。 这里线程 `T2` 节点退出等待队列并不是直接从队列移除,而是令线程 `T2` 节点成为新的 `head` 节点,以此来退出资源获取的等待。此时 AQS 内部队列如下所示: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-acquire-and-release-process-4.png) -此时,假设线程 `T2` 释放锁,会唤醒后继节点 `T3` 。线程 `T3` 获取到锁之后,同样也退出等待队列,即将线程 `T3` 节点变为 `head` 节点来退出资源获取的等待。此时 AQS 内部队列如下所示: +此时,假设线程 `T2` 释放锁,会唤醒后继节点 `T3`。线程 `T3` 获取到锁之后,同样也退出等待队列,即将线程 `T3` 节点变为 `head` 节点来退出资源获取的等待。此时 AQS 内部队列如下所示: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/aqs-acquire-and-release-process-5.png) ### AQS 资源获取源码分析(共享模式) -AQS 中以共享模式获取资源的入口方法是 `acquireShared()` ,如下: +AQS 中以共享模式获取资源的入口方法是 `acquireShared()`,如下: ```JAVA // AQS @@ -728,7 +728,7 @@ public final void acquireShared(int arg) { } ``` -在 `acquireShared()` 方法中,会先尝试获取共享锁,如果获取失败,则将当前线程加入到队列中阻塞,等待唤醒后尝试获取共享锁,分别对应一下两个方法:`tryAcquireShared()` 和 `doAcquireShared()` 。 +在 `acquireShared()` 方法中,会先尝试获取共享锁,如果获取失败,则将当前线程加入到队列中阻塞,等待唤醒后尝试获取共享锁,分别对应一下两个方法:`tryAcquireShared()` 和 `doAcquireShared()`。 其中 `tryAcquireShared()` 方法是 AQS 提供的模板方法,由同步器来实现具体逻辑。因此这里以 `Semaphore` 为例,来分析共享模式下,如何获取资源。 @@ -761,15 +761,15 @@ final int nonfairTryAcquireShared(int acquires) { 在共享模式下,AQS 中的 `state` 值表示共享资源的数量。 -在 `nonfairTryAcquireShared()` 方法中,会在死循环中不断尝试获取资源,如果 「剩余资源数不足」 或者 「当前线程成功获取资源」 ,就退出死循环。方法返回 **剩余的资源数量** ,根据返回值的不同,分为 3 种情况: +在 `nonfairTryAcquireShared()` 方法中,会在死循环中不断尝试获取资源,如果 「剩余资源数不足」 或者 「当前线程成功获取资源」,就退出死循环。方法返回 **剩余的资源数量**,根据返回值的不同,分为 3 种情况: -- **剩余资源数量 > 0** :表示成功获取资源,并且后续的线程也可以成功获取资源。 -- **剩余资源数量 = 0** :表示成功获取资源,但是后续的线程无法成功获取资源。 -- **剩余资源数量 < 0** :表示获取资源失败。 +- **剩余资源数量 > 0**:表示成功获取资源,并且后续的线程也可以成功获取资源。 +- **剩余资源数量 = 0**:表示成功获取资源,但是后续的线程无法成功获取资源。 +- **剩余资源数量 < 0**:表示获取资源失败。 #### `doAcquireShared()` 分析 -为了方便阅读,这里再贴一下获取资源的入口方法 `acquireShared()` : +为了方便阅读,这里再贴一下获取资源的入口方法 `acquireShared()`: ```JAVA // AQS @@ -781,7 +781,7 @@ public final void acquireShared(int arg) { 在 `acquireShared()` 方法中,会先通过 `tryAcquireShared()` 尝试获取资源。 -如果发现方法的返回值 `< 0` ,即剩余的资源数小于 0,则表明当前线程获取资源失败。因此会进入 `doAcquireShared()` 方法,将当前线程加入到 AQS 队列进行等待。如下: +如果发现方法的返回值 `< 0`,即剩余的资源数小于 0,则表明当前线程获取资源失败。因此会进入 `doAcquireShared()` 方法,将当前线程加入到 AQS 队列进行等待。如下: ```JAVA // AQS @@ -842,8 +842,8 @@ private void setHeadAndPropagate(Node node, int propagate) { 在 `setHeadAndPropagate()` 方法中,唤醒后续节点需要满足一定的条件,主要需要满足 2 个条件: -- `propagate > 0` :`propagate` 代表获取资源之后剩余的资源数量,如果 `> 0` ,则可以唤醒后续线程去获取资源。 -- `h.waitStatus < 0` :这里的 `h` 节点是执行 `setHead()` 之前的 `head` 节点。判断 `head.waitStatus` 时使用 `< 0` ,主要为了确定 `head` 节点的状态为 `SIGNAL` 或 `PROPAGATE` 。如果 `head` 节点为 `SIGNAL` ,则可以唤醒后续节点;如果 `head` 节点状态为 `PROPAGATE` ,也可以唤醒后续节点(这是为了解决并发场景下出现的问题,后续会细讲)。 +- `propagate > 0`:`propagate` 代表获取资源之后剩余的资源数量,如果 `> 0`,则可以唤醒后续线程去获取资源。 +- `h.waitStatus < 0`:这里的 `h` 节点是执行 `setHead()` 之前的 `head` 节点。判断 `head.waitStatus` 时使用 `< 0`,主要为了确定 `head` 节点的状态为 `SIGNAL` 或 `PROPAGATE`。如果 `head` 节点为 `SIGNAL`,则可以唤醒后续节点;如果 `head` 节点状态为 `PROPAGATE`,也可以唤醒后续节点(这是为了解决并发场景下出现的问题,后续会细讲)。 代码中关于 **唤醒后续等待节点** 的 `if` 判断稍微复杂一些,这里来讲一下为什么这样写: @@ -854,7 +854,7 @@ if (propagate > 0 || h == null || h.waitStatus < 0 || - `h == null || h.waitStatus < 0` : `h == null` 用于防止空指针异常。正常情况下 h 不会为 `null` ,因为执行到这里之前,当前节点已经加入到队列中了,队列不可能还没有初始化。 - `h.waitStatus < 0` 主要判断 `head` 节点的状态是否为 `SIGNAL` 或者 `PROPAGATE` ,直接使用 `< 0` 来判断比较方便。 + `h.waitStatus < 0` 主要判断 `head` 节点的状态是否为 `SIGNAL` 或者 `PROPAGATE`,直接使用 `< 0` 来判断比较方便。 - `(h = head) == null || h.waitStatus < 0` :如果到这里说明之前判断的 `h.waitStatus < 0` ,说明存在并发。 @@ -890,12 +890,12 @@ private void doReleaseShared() { 在 `doReleaseShared()` 方法中,会判断 `head` 节点的 `waitStatus` 状态来决定接下来的操作,有两种情况: -- `head` 节点的状态为 `SIGNAL` :表明 `head` 节点存在后继节点需要唤醒,因此通过 `CAS` 操作将 `head` 节点的 `SIGNAL` 状态更新为 `0` 。通过清除 `SIGNAL` 状态来表示已经对 `head` 节点的后继节点进行唤醒操作了。 -- `head` 节点的状态为 `0` :表明存在并发情况,需要将 `0` 修改为 `PROPAGATE` 来保证在并发场景下可以正常唤醒线程。 +- `head` 节点的状态为 `SIGNAL`:表明 `head` 节点存在后继节点需要唤醒,因此通过 `CAS` 操作将 `head` 节点的 `SIGNAL` 状态更新为 `0`。通过清除 `SIGNAL` 状态来表示已经对 `head` 节点的后继节点进行唤醒操作了。 +- `head` 节点的状态为 `0`:表明存在并发情况,需要将 `0` 修改为 `PROPAGATE` 来保证在并发场景下可以正常唤醒线程。 #### 为什么需要 `PROPAGATE` 状态? -在 `doReleaseShared()` 释放资源时,第 3 步不太容易理解,即如果发现 `head` 节点的状态是 `0` ,就将 `head` 节点的状态由 `0` 更新为 `PROPAGATE` 。 +在 `doReleaseShared()` 释放资源时,第 3 步不太容易理解,即如果发现 `head` 节点的状态是 `0`,就将 `head` 节点的状态由 `0` 更新为 `PROPAGATE`。 AQS 中,Node 节点的 `PROPAGATE` 就是为了处理并发场景下可能出现的无法唤醒线程节点的问题。`PROPAGATE` 只在 `doReleaseShared()` 方法中用到一次。 @@ -905,23 +905,23 @@ AQS 中,Node 节点的 `PROPAGATE` 就是为了处理并发场景下可能出 - 线程获取资源的方法调用链为: `acquireShared() -> tryAcquireShared() -> 线程阻塞等待唤醒 -> tryAcquireShared() -> setHeadAndPropagate() -> if (剩余资源数 > 0) || (head.waitStatus < 0) 则唤醒后续节点` 。 -- 线程释放资源的方法调用链为: `releaseShared() -> tryReleaseShared() -> doReleaseShared()` 。 +- 线程释放资源的方法调用链为: `releaseShared() -> tryReleaseShared() -> doReleaseShared()`。 -**如果在释放资源时,没有将 `head` 节点的状态由 `0` 改为 `PROPAGATE` :** +**如果在释放资源时,没有将 `head` 节点的状态由 `0` 改为 `PROPAGATE`:** 假设总共有 4 个线程尝试以共享模式获取资源,总共有 2 个资源。初始 `T3` 和 `T4` 线程获取到了资源,`T1` 和 `T2` 线程没有获取到,因此在队列中排队等候。 - 在时刻 1 时,线程 `T1` 和 `T2` 在等待队列中,`T3` 和 `T4` 持有资源。此时等待队列内节点以及对应状态为(括号内为节点的 `waitStatus` 状态): - `head(-1) -> T1(-1) -> T2(0)` 。 + `head(-1) -> T1(-1) -> T2(0)`。 -- 在时刻 2 时,线程 `T3` 释放资源,通过 `doReleaseShared()` 方法将 `head` 节点的状态由 `SIGNAL` 更新为 `0` ,并唤醒线程 `T1` ,之后线程 `T3` 退出。 +- 在时刻 2 时,线程 `T3` 释放资源,通过 `doReleaseShared()` 方法将 `head` 节点的状态由 `SIGNAL` 更新为 `0`,并唤醒线程 `T1`,之后线程 `T3` 退出。 线程 `T1` 被唤醒之后,通过 `tryAcquireShared()` 获取到资源,但是此时还未来得及执行 `setHeadAndPropagate()` 将自己设置为 `head` 节点。此时等待队列内节点状态为: - `head(0) -> T1(-1) -> T2(0)` 。 + `head(0) -> T1(-1) -> T2(0)`。 -- 在时刻 3 时,线程 `T4` 释放资源,由于此时 `head` 节点的状态为 `0` ,如果 `doReleaseShared()` 中 `ws == 0` 时什么都不做(即没有 `PROPAGATE` 状态),那么 `T4` 无法唤醒 `head` 的后继节点,之后线程 `T4` 退出。 +- 在时刻 3 时,线程 `T4` 释放资源,由于此时 `head` 节点的状态为 `0`,如果 `doReleaseShared()` 中 `ws == 0` 时什么都不做(即没有 `PROPAGATE` 状态),那么 `T4` 无法唤醒 `head` 的后继节点,之后线程 `T4` 退出。 - 在时刻 4 时,线程 `T1` 继续执行 `setHeadAndPropagate()` 方法。先保存旧 `head`(`waitStatus == 0`),再执行 `setHead(T1)` 将自己设置为 `head` 节点。 @@ -944,19 +944,19 @@ AQS 中,Node 节点的 `PROPAGATE` 就是为了处理并发场景下可能出 | 时刻 5 | | (执行)被 T4 唤醒,获取资源,执行 `setHead(T2)` 成为新的 `head` | 已退出 | (执行)`doReleaseShared()` 唤醒 T2 | `head(0,线程 T2 节点)` | | 时刻 6 | (执行)读取新 `head` 为 T2 节点,`waitStatus == 0`,二次判断失败,不唤醒后续节点 | 已获取资源 | 已退出 | 已退出 | `head(0,线程 T2 节点)` | -**如果在线程释放资源时,将 `head` 节点的状态由 `0` 改为 `PROPAGATE` ,则可以解决上边出现的并发问题,如下:** +**如果在线程释放资源时,将 `head` 节点的状态由 `0` 改为 `PROPAGATE`,则可以解决上边出现的并发问题,如下:** `PROPAGATE` 的关键在于:它修改的是**旧 `head`** 的状态,而旧 `head` 的引用在 `setHeadAndPropagate()` 方法开头就已经保存到了局部变量 `h` 中,不会被后续的并发修改影响。 - 在时刻 1~2 时,与上述场景相同: - 时刻 1:`head(-1) -> T1(-1) -> T2(0)` 。 + 时刻 1:`head(-1) -> T1(-1) -> T2(0)`。 时刻 2:`T3` 释放资源,`head` 状态变为 `0` 并唤醒 `T1`。 -- 在时刻 3 时,线程 `T4` 释放资源,由于此时 `head` 节点的状态为 `0` ,`doReleaseShared()` 会将 `head` 节点的状态由 `0` 更新为 `PROPAGATE(-3)` ,之后线程 `T4` 退出。此时等待队列内节点状态为: +- 在时刻 3 时,线程 `T4` 释放资源,由于此时 `head` 节点的状态为 `0`,`doReleaseShared()` 会将 `head` 节点的状态由 `0` 更新为 `PROPAGATE(-3)`,之后线程 `T4` 退出。此时等待队列内节点状态为: - `head(PROPAGATE) -> T1(-1) -> T2(0)` 。 + `head(PROPAGATE) -> T1(-1) -> T2(0)`。 - 在时刻 4 时,线程 `T1` 继续执行 `setHeadAndPropagate()` 方法。先保存旧 `head` 到局部变量 `h`,此时 `h.waitStatus == PROPAGATE(-3)`。再执行 `setHead(T1)` 将自己设置为 `head` 节点。 @@ -983,7 +983,7 @@ AQS 中,Node 节点的 `PROPAGATE` 就是为了处理并发场景下可能出 ### AQS 资源释放源码分析(共享模式) -AQS 中以共享模式释放资源的入口方法是 `releaseShared()` ,代码如下: +AQS 中以共享模式释放资源的入口方法是 `releaseShared()`,代码如下: ```JAVA // AQS @@ -1309,11 +1309,11 @@ public class FairVsUnfairLockDemo { ## 常见同步工具类 -### Semaphore(信号量) +### Semaphore(信号量) #### 介绍 -`synchronized` 和 `ReentrantLock` 都是一次只允许一个线程访问某个资源,而`Semaphore`(信号量)可以用来控制同时访问特定资源的线程数量。 +`synchronized` 和 `ReentrantLock` 都是一次只允许一个线程访问某个资源,而 `Semaphore`(信号量)可以用来控制同时访问特定资源的线程数量。 `Semaphore` 的使用简单,我们这里假设有 `N(N>5)` 个线程来获取 `Semaphore` 中的共享资源,下面的代码表示同一时刻 N 个线程中只有 5 个线程能获取到共享资源,其他线程都会阻塞,只有获取到共享资源的线程才能执行。等到有线程释放了共享资源,其他阻塞的线程才能获取到。 @@ -1353,7 +1353,7 @@ public Semaphore(int permits, boolean fair) { `Semaphore` 是共享锁的一种实现,它默认构造 AQS 的 `state` 值为 `permits`,你可以将 `permits` 的值理解为许可证的数量,只有拿到许可证的线程才能执行。 -以无参 `acquire` 方法为例,调用`semaphore.acquire()` ,线程尝试获取许可证,如果 `state > 0` 的话,则表示可以获取成功,如果 `state <= 0` 的话,则表示许可证数量不足,获取失败。 +以无参 `acquire` 方法为例,调用 `semaphore.acquire()`,线程尝试获取许可证,如果 `state > 0` 的话,则表示可以获取成功,如果 `state <= 0` 的话,则表示许可证数量不足,获取失败。 如果可以获取成功的话(`state > 0` ),会尝试使用 CAS 操作去修改 `state` 的值 `state=state-1`。如果获取失败则会创建一个 Node 节点加入等待队列,挂起当前线程。 @@ -1370,7 +1370,7 @@ public void acquire(int permits) throws InterruptedException { } ``` -`acquireSharedInterruptibly`方法是 `AbstractQueuedSynchronizer` 中的默认实现。 +`acquireSharedInterruptibly` 方法是 `AbstractQueuedSynchronizer` 中的默认实现。 ```java // 共享模式下获取许可证,获取成功则返回,失败则加入等待队列,挂起线程 @@ -1409,7 +1409,7 @@ final int nonfairTryAcquireShared(int acquires) { } ``` -以无参 `release` 方法为例,调用`semaphore.release();` ,线程尝试释放许可证,并使用 CAS 操作去修改 `state` 的值 `state=state+1`。释放许可证成功之后,同时会唤醒等待队列中的一个线程。被唤醒的线程会重新尝试去修改 `state` 的值 `state=state-1` ,如果 `state > 0` 则获取令牌成功,否则重新进入等待队列,挂起线程。 +以无参 `release` 方法为例,调用 `semaphore.release();`,线程尝试释放许可证,并使用 CAS 操作去修改 `state` 的值 `state=state+1`。释放许可证成功之后,同时会唤醒等待队列中的一个线程。被唤醒的线程会重新尝试去修改 `state` 的值 `state=state-1`,如果 `state > 0` 则获取令牌成功,否则重新进入等待队列,挂起线程。 ```java // 释放一个许可证 @@ -1424,7 +1424,7 @@ public void release(int permits) { } ``` -`releaseShared`方法是 `AbstractQueuedSynchronizer` 中的默认实现。 +`releaseShared` 方法是 `AbstractQueuedSynchronizer` 中的默认实现。 ```java // 释放共享锁 @@ -1440,7 +1440,7 @@ public final boolean releaseShared(int arg) { } ``` -`tryReleaseShared` 方法是`Semaphore` 的内部类 `Sync` 重写的一个方法, `AbstractQueuedSynchronizer`中的默认实现仅仅抛出 `UnsupportedOperationException` 异常。 +`tryReleaseShared` 方法是 `Semaphore` 的内部类 `Sync` 重写的一个方法, `AbstractQueuedSynchronizer` 中的默认实现仅仅抛出 `UnsupportedOperationException` 异常。 ```java // 内部类 Sync 中重写的一个方法 @@ -1459,7 +1459,7 @@ protected final boolean tryReleaseShared(int releases) { } ``` -可以看到,上面提到的几个方法底层基本都是通过同步器 `sync` 实现的。`Sync` 是 `CountDownLatch` 的内部类 , 继承了 `AbstractQueuedSynchronizer` ,重写了其中的某些方法。并且,Sync 对应的还有两个子类 `NonfairSync`(对应非公平模式) 和 `FairSync`(对应公平模式)。 +可以看到,上面提到的几个方法底层基本都是通过同步器 `sync` 实现的。`Sync` 是 `CountDownLatch` 的内部类 , 继承了 `AbstractQueuedSynchronizer`,重写了其中的某些方法。并且,Sync 对应的还有两个子类 `NonfairSync`(对应非公平模式) 和 `FairSync`(对应公平模式)。 ```java private static final class Sync extends AbstractQueuedSynchronizer { @@ -1528,7 +1528,7 @@ semaphore.release(5);// 释放5个许可 > `Semaphore` 基于 AQS 实现,用于控制并发访问的线程数量,但它与共享锁的概念有所不同。`Semaphore` 的构造函数使用 `permits` 参数初始化 AQS 的 `state` 变量,该变量表示可用的许可数量。当线程调用 `acquire()` 方法尝试获取许可时,`state` 会原子性地减 1。如果 `state` 减 1 后大于等于 0,则 `acquire()` 成功返回,线程可以继续执行。如果 `state` 减 1 后小于 0,表示当前并发访问的线程数量已达到 `permits` 的限制,该线程会被放入 AQS 的等待队列并阻塞,**而不是自旋等待**。当其他线程完成任务并调用 `release()` 方法时,`state` 会原子性地加 1。`release()` 操作会唤醒 AQS 等待队列中的一个或多个阻塞线程。这些被唤醒的线程将再次尝试 `acquire()` 操作,竞争获取可用的许可。因此,`Semaphore` 通过控制许可数量来限制并发访问的线程数量,而不是通过自旋和共享锁机制。 -### CountDownLatch (倒计时器) +### CountDownLatch(倒计时器) #### 介绍 @@ -1554,7 +1554,7 @@ private static final class Sync extends AbstractQueuedSynchronizer { } ``` -当线程调用 `countDown()` 时,其实使用了`tryReleaseShared`方法以 CAS 的操作来减少 `state`,直至 `state` 为 0 。当 `state` 为 0 时,表示所有的线程都调用了 `countDown` 方法,那么在 `CountDownLatch` 上等待的线程就会被唤醒并继续执行。 +当线程调用 `countDown()` 时,其实使用了 `tryReleaseShared` 方法以 CAS 的操作来减少 `state`,直至 `state` 为 0。当 `state` 为 0 时,表示所有的线程都调用了 `countDown` 方法,那么在 `CountDownLatch` 上等待的线程就会被唤醒并继续执行。 ```java public void countDown() { @@ -1563,7 +1563,7 @@ public void countDown() { } ``` -`releaseShared`方法是 `AbstractQueuedSynchronizer` 中的默认实现。 +`releaseShared` 方法是 `AbstractQueuedSynchronizer` 中的默认实现。 ```java // 释放共享锁 @@ -1579,7 +1579,7 @@ public final boolean releaseShared(int arg) { } ``` -`tryReleaseShared` 方法是`CountDownLatch` 的内部类 `Sync` 重写的一个方法, `AbstractQueuedSynchronizer`中的默认实现仅仅抛出 `UnsupportedOperationException` 异常。 +`tryReleaseShared` 方法是 `CountDownLatch` 的内部类 `Sync` 重写的一个方法, `AbstractQueuedSynchronizer` 中的默认实现仅仅抛出 `UnsupportedOperationException` 异常。 ```java // 对 state 进行递减,直到 state 变成 0; @@ -1600,7 +1600,7 @@ protected boolean tryReleaseShared(int releases) { } ``` -以无参 `await`方法为例,当调用 `await()` 的时候,如果 `state` 不为 0,那就证明任务还没有执行完毕,`await()` 就会一直阻塞,也就是说 `await()` 之后的语句不会被执行(`main` 线程被加入到等待队列也就是 变体 CLH 队列中了)。然后,`CountDownLatch` 会自旋 CAS 判断 `state == 0`,如果 `state == 0` 的话,就会释放所有等待的线程,`await()` 方法之后的语句得到执行。 +以无参 `await` 方法为例,当调用 `await()` 的时候,如果 `state` 不为 0,那就证明任务还没有执行完毕,`await()` 就会一直阻塞,也就是说 `await()` 之后的语句不会被执行(`main` 线程被加入到等待队列也就是 变体 CLH 队列中了)。然后,`CountDownLatch` 会自旋 CAS 判断 `state == 0`,如果 `state == 0` 的话,就会释放所有等待的线程,`await()` 方法之后的语句得到执行。 ```java // 等待(也可以叫做加锁) @@ -1614,7 +1614,7 @@ public boolean await(long timeout, TimeUnit unit) } ``` -`acquireSharedInterruptibly`方法是 `AbstractQueuedSynchronizer` 中的默认实现。 +`acquireSharedInterruptibly` 方法是 `AbstractQueuedSynchronizer` 中的默认实现。 ```java // 尝试获取锁,获取成功则返回,失败则加入等待队列,挂起线程 @@ -1629,7 +1629,7 @@ public final void acquireSharedInterruptibly(int arg) } ``` -`tryAcquireShared` 方法是`CountDownLatch` 的内部类 `Sync` 重写的一个方法,其作用就是判断 `state` 的值是否为 0,是的话就返回 1,否则返回 -1。 +`tryAcquireShared` 方法是 `CountDownLatch` 的内部类 `Sync` 重写的一个方法,其作用就是判断 `state` 的值是否为 0,是的话就返回 1,否则返回 -1。 ```java protected int tryAcquireShared(int acquires) { @@ -1641,8 +1641,8 @@ protected int tryAcquireShared(int acquires) { **CountDownLatch 的两种典型用法**: -1. 某一线程在开始运行前等待 n 个线程执行完毕 : 将 `CountDownLatch` 的计数器初始化为 n (`new CountDownLatch(n)`),每当一个任务线程执行完毕,就将计数器减 1 (`countdownlatch.countDown()`),当计数器的值变为 0 时,在 `CountDownLatch 上 await()` 的线程就会被唤醒。一个典型应用场景就是启动一个服务时,主线程需要等待多个组件加载完毕,之后再继续执行。 -2. 实现多个线程开始执行任务的最大并行性:注意是并行性,不是并发,强调的是多个线程在某一时刻同时开始执行。类似于赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。做法是初始化一个共享的 `CountDownLatch` 对象,将其计数器初始化为 1 (`new CountDownLatch(1)`),多个线程在开始执行任务前首先 `coundownlatch.await()`,当主线程调用 `countDown()` 时,计数器变为 0,多个线程同时被唤醒。 +1. 某一线程在开始运行前等待 n 个线程执行完毕 : 将 `CountDownLatch` 的计数器初始化为 n(`new CountDownLatch(n)`),每当一个任务线程执行完毕,就将计数器减 1(`countdownlatch.countDown()`),当计数器的值变为 0 时,在 `CountDownLatch 上 await()` 的线程就会被唤醒。一个典型应用场景就是启动一个服务时,主线程需要等待多个组件加载完毕,之后再继续执行。 +2. 实现多个线程开始执行任务的最大并行性:注意是并行性,不是并发,强调的是多个线程在某一时刻同时开始执行。类似于赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。做法是初始化一个共享的 `CountDownLatch` 对象,将其计数器初始化为 1(`new CountDownLatch(1)`),多个线程在开始执行任务前首先 `coundownlatch.await()`,当主线程调用 `countDown()` 时,计数器变为 0,多个线程同时被唤醒。 **CountDownLatch 代码示例**: @@ -1683,11 +1683,11 @@ public class CountDownLatchExample { } ``` -上面的代码中,我们定义了请求的数量为 550,当这 550 个请求被处理完成之后,才会执行`System.out.println("finish");`。 +上面的代码中,我们定义了请求的数量为 550,当这 550 个请求被处理完成之后,才会执行 `System.out.println("finish");`。 与 `CountDownLatch` 的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用 `CountDownLatch.await()` 方法。这样主线程的操作就会在这个方法上阻塞,直到其他线程完成各自的任务。 -其他 N 个线程必须引用闭锁对象,因为他们需要通知 `CountDownLatch` 对象,他们已经完成了各自的任务。这种通知机制是通过 `CountDownLatch.countDown()`方法来完成的;每调用一次这个方法,在构造函数中初始化的 count 值就减 1。所以当 N 个线程都调 用了这个方法,count 的值等于 0,然后主线程就能通过 `await()`方法,恢复执行自己的任务。 +其他 N 个线程必须引用闭锁对象,因为他们需要通知 `CountDownLatch` 对象,他们已经完成了各自的任务。这种通知机制是通过 `CountDownLatch.countDown()` 方法来完成的;每调用一次这个方法,在构造函数中初始化的 count 值就减 1。所以当 N 个线程都调 用了这个方法,count 的值等于 0,然后主线程就能通过 `await()` 方法,恢复执行自己的任务。 再插一嘴:`CountDownLatch` 的 `await()` 方法使用不当很容易产生死锁,比如我们上面代码中的 for 循环改为: @@ -1699,7 +1699,7 @@ for (int i = 0; i < threadCount-1; i++) { 这样就导致 `count` 的值没办法等于 0,然后就会导致一直等待。 -### CyclicBarrier(循环栅栏) +### CyclicBarrier(循环栅栏) #### 介绍 @@ -1739,7 +1739,7 @@ public CyclicBarrier(int parties, Runnable barrierAction) { 其中,`parties` 就代表了有拦截的线程的数量,当拦截的线程数量达到这个值的时候就打开栅栏,让所有线程通过。 -2、当调用 `CyclicBarrier` 对象调用 `await()` 方法时,实际上调用的是 `dowait(false, 0L)`方法。 `await()` 方法就像树立起一个栅栏的行为一样,将线程挡住了,当拦住的线程数量达到 `parties` 的值时,栅栏才会打开,线程才得以通过执行。 +2、当调用 `CyclicBarrier` 对象调用 `await()` 方法时,实际上调用的是 `dowait(false, 0L)` 方法。 `await()` 方法就像树立起一个栅栏的行为一样,将线程挡住了,当拦住的线程数量达到 `parties` 的值时,栅栏才会打开,线程才得以通过执行。 ```java public int await() throws InterruptedException, BrokenBarrierException { @@ -1751,7 +1751,7 @@ public int await() throws InterruptedException, BrokenBarrierException { } ``` -`dowait(false, 0L)`方法源码分析如下: +`dowait(false, 0L)` 方法源码分析如下: ```java // 当线程数量或者请求数量达到 count 时 await 之后的方法才会被执行。上面的示例中 count 的值就为 5。 diff --git a/docs/java/concurrent/atomic-classes.md b/docs/java/concurrent/atomic-classes.md index 2955d1aa33d..44825caf4ee 100644 --- a/docs/java/concurrent/atomic-classes.md +++ b/docs/java/concurrent/atomic-classes.md @@ -66,7 +66,7 @@ head: 上面三个类提供的方法几乎相同,所以我们这里以 `AtomicInteger` 为例子来介绍。 -**`AtomicInteger` 类常用方法** : +**`AtomicInteger` 类常用方法**: ```java public final int get() //获取当前的值 @@ -348,7 +348,7 @@ Final Reference: Daisy, Final Mark: true 要想原子地更新对象的属性需要两步。第一步,因为对象的属性修改类型原子类都是抽象类,所以每次使用都必须使用静态方法 newUpdater()创建一个更新器,并且需要设置想要更新的类和属性。第二步,更新的对象属性必须使用 volatile int 修饰符。 -上面三个类提供的方法几乎相同,所以我们这里以 `AtomicIntegerFieldUpdater`为例子来介绍。 +上面三个类提供的方法几乎相同,所以我们这里以 `AtomicIntegerFieldUpdater` 为例子来介绍。 **`AtomicIntegerFieldUpdater` 类使用示例** : diff --git a/docs/java/concurrent/cas.md b/docs/java/concurrent/cas.md index f7b795791a7..913bbae784a 100644 --- a/docs/java/concurrent/cas.md +++ b/docs/java/concurrent/cas.md @@ -12,15 +12,15 @@ head: 乐观锁和悲观锁的介绍以及乐观锁常见实现方式可以阅读笔者写的这篇文章:[乐观锁和悲观锁详解](https://javaguide.cn/java/concurrent/optimistic-lock-and-pessimistic-lock.html)。 -这篇文章主要介绍 :Java 中 CAS 的实现以及 CAS 存在的一些问题。 +这篇文章主要介绍:Java 中 CAS 的实现以及 CAS 存在的一些问题。 ## Java 中 CAS 是如何实现的? -在 Java 中,实现 CAS(Compare-And-Swap, 比较并交换)操作的一个关键类是`Unsafe`。 +在 Java 中,实现 CAS(Compare-And-Swap, 比较并交换)操作的一个关键类是 `Unsafe`。 -`Unsafe`类位于`sun.misc`包下,是一个提供低级别、不安全操作的类。由于其强大的功能和潜在的危险性,它通常用于 JVM 内部或一些需要极高性能和底层访问的库中,而不推荐普通开发者在应用程序中使用。关于 `Unsafe`类的详细介绍,可以阅读这篇文章:📌[Java 魔法类 Unsafe 详解](https://javaguide.cn/java/basis/unsafe.html)。 +`Unsafe` 类位于 `sun.misc` 包下,是一个提供低级别、不安全操作的类。由于其强大的功能和潜在的危险性,它通常用于 JVM 内部或一些需要极高性能和底层访问的库中,而不推荐普通开发者在应用程序中使用。关于 `Unsafe` 类的详细介绍,可以阅读这篇文章:📌[Java 魔法类 Unsafe 详解](https://javaguide.cn/java/basis/unsafe.html)。 -`sun.misc`包下的`Unsafe`类提供了`compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong`方法来实现的对`Object`、`int`、`long`类型的 CAS 操作: +`sun.misc` 包下的 `Unsafe` 类提供了 `compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong` 方法来实现的对 `Object`、`int`、`long` 类型的 CAS 操作: ```java /** @@ -45,7 +45,7 @@ boolean compareAndSwapInt(Object o, long offset, int expected, int x); boolean compareAndSwapLong(Object o, long offset, long expected, long x); ``` -`Unsafe`类中的 CAS 方法是`native`方法。`native`关键字表明这些方法是用本地代码(通常是 C 或 C++)实现的,而不是用 Java 实现的。这些方法直接调用底层的硬件指令来实现原子操作。也就是说,Java 语言并没有直接用 Java 实现 CAS。 +`Unsafe` 类中的 CAS 方法是 `native` 方法。`native` 关键字表明这些方法是用本地代码(通常是 C 或 C++)实现的,而不是用 Java 实现的。这些方法直接调用底层的硬件指令来实现原子操作。也就是说,Java 语言并没有直接用 Java 实现 CAS。 更准确点来说,Java 中 CAS 是 C++ 内联汇编的形式实现的,通过 JNI(Java Native Interface) 调用。因此,CAS 的具体实现与操作系统以及 CPU 密切相关。 @@ -57,11 +57,11 @@ boolean compareAndSwapLong(Object o, long offset, long expected, long x); Atomic 类依赖于 CAS 乐观锁来保证其方法的原子性,而不需要使用传统的锁机制(如 `synchronized` 块或 `ReentrantLock`)。 -`AtomicInteger`是 Java 的原子类之一,主要用于对 `int` 类型的变量进行原子操作,它利用`Unsafe`类提供的低级别原子操作方法实现无锁的线程安全性。 +`AtomicInteger` 是 Java 的原子类之一,主要用于对 `int` 类型的变量进行原子操作,它利用 `Unsafe` 类提供的低级别原子操作方法实现无锁的线程安全性。 -下面,我们通过解读`AtomicInteger`的核心源码(JDK1.8),来说明 Java 如何使用`Unsafe`类的方法来实现原子操作。 +下面,我们通过解读 `AtomicInteger` 的核心源码(JDK1.8),来说明 Java 如何使用 `Unsafe` 类的方法来实现原子操作。 -`AtomicInteger`核心源码如下: +`AtomicInteger` 核心源码如下: ```java // 获取 Unsafe 实例 @@ -101,7 +101,7 @@ public final int getAndDecrement() { } ``` -`Unsafe#getAndAddInt`源码: +`Unsafe#getAndAddInt` 源码: ```java // 原子地获取并增加整数值 @@ -116,9 +116,9 @@ public final int getAndAddInt(Object o, long offset, int delta) { } ``` -可以看到,`getAndAddInt` 使用了 `do-while` 循环:在`compareAndSwapInt`操作失败时,会不断重试直到成功。也就是说,`getAndAddInt`方法会通过 `compareAndSwapInt` 方法来尝试更新 `value` 的值,如果更新失败(当前值在此期间被其他线程修改),它会重新获取当前值并再次尝试更新,直到操作成功。 +可以看到,`getAndAddInt` 使用了 `do-while` 循环:在 `compareAndSwapInt` 操作失败时,会不断重试直到成功。也就是说,`getAndAddInt` 方法会通过 `compareAndSwapInt` 方法来尝试更新 `value` 的值,如果更新失败(当前值在此期间被其他线程修改),它会重新获取当前值并再次尝试更新,直到操作成功。 -由于 CAS 操作可能会因为并发冲突而失败,因此通常会与`while`循环搭配使用,在失败后不断重试,直到操作成功。这就是 **自旋锁机制** 。 +由于 CAS 操作可能会因为并发冲突而失败,因此通常会与 `while` 循环搭配使用,在失败后不断重试,直到操作成功。这就是 **自旋锁机制**。 ## CAS 算法存在哪些问题? @@ -149,14 +149,14 @@ public boolean compareAndSet(V expectedReference, CAS 经常会用到自旋操作来进行重试,也就是不成功就一直循环执行直到成功。如果长时间不成功,会给 CPU 带来非常大的执行开销。 -如果 JVM 能够支持处理器提供的`pause`指令,那么自旋操作的效率将有所提升。`pause`指令有两个重要作用: +如果 JVM 能够支持处理器提供的 `pause` 指令,那么自旋操作的效率将有所提升。`pause` 指令有两个重要作用: -1. **延迟流水线执行指令**:`pause`指令可以延迟指令的执行,从而减少 CPU 的资源消耗。具体的延迟时间取决于处理器的实现版本,在某些处理器上,延迟时间可能为零。 -2. **避免内存顺序冲突**:在退出循环时,`pause`指令可以避免由于内存顺序冲突而导致的 CPU 流水线被清空,从而提高 CPU 的执行效率。 +1. **延迟流水线执行指令**:`pause` 指令可以延迟指令的执行,从而减少 CPU 的资源消耗。具体的延迟时间取决于处理器的实现版本,在某些处理器上,延迟时间可能为零。 +2. **避免内存顺序冲突**:在退出循环时,`pause` 指令可以避免由于内存顺序冲突而导致的 CPU 流水线被清空,从而提高 CPU 的执行效率。 ### 只能保证一个共享变量的原子操作 -CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量时,CAS 就显得无能为力。不过,从 JDK 1.5 开始,Java 提供了`AtomicReference`类,这使得我们能够保证引用对象之间的原子性。通过将多个变量封装在一个对象中,我们可以使用`AtomicReference`来执行 CAS 操作。 +CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量时,CAS 就显得无能为力。不过,从 JDK 1.5 开始,Java 提供了 `AtomicReference` 类,这使得我们能够保证引用对象之间的原子性。通过将多个变量封装在一个对象中,我们可以使用 `AtomicReference` 来执行 CAS 操作。 除了 `AtomicReference` 这种方式之外,还可以利用加锁来保证。 @@ -164,4 +164,4 @@ CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量 在 Java 中,CAS 通过 `Unsafe` 类中的 `native` 方法实现,这些方法调用底层的硬件指令来完成原子操作。由于其实现依赖于 C++ 内联汇编和 JNI 调用,因此 CAS 的具体实现与操作系统以及 CPU 密切相关。 -CAS 虽然具有高效的无锁特性,但也需要注意 ABA 、循环时间长开销大等问题。 +CAS 虽然具有高效的无锁特性,但也需要注意 ABA、循环时间长开销大等问题。 diff --git a/docs/java/concurrent/completablefuture-intro.md b/docs/java/concurrent/completablefuture-intro.md index 3061298348d..9970d821bea 100644 --- a/docs/java/concurrent/completablefuture-intro.md +++ b/docs/java/concurrent/completablefuture-intro.md @@ -12,7 +12,7 @@ head: 实际项目中,一个接口可能需要同时获取多种不同的数据,然后再汇总返回,这种场景还是挺常见的。举个例子:用户请求获取订单信息,可能需要同时获取用户信息、商品详情、物流信息、商品推荐等数据。 -如果是串行(按顺序依次执行每个任务)执行的话,接口的响应速度会非常慢。考虑到这些任务之间有大部分都是 **无前后顺序关联** 的,可以 **并行执行** ,就比如说调用获取商品详情的时候,可以同时调用获取物流信息。通过并行执行多个任务的方式,接口的响应速度会得到大幅优化。 +如果是串行(按顺序依次执行每个任务)执行的话,接口的响应速度会非常慢。考虑到这些任务之间有大部分都是 **无前后顺序关联** 的,可以 **并行执行**,就比如说调用获取商品详情的时候,可以同时调用获取物流信息。通过并行执行多个任务的方式,接口的响应速度会得到大幅优化。 ![](https://oss.javaguide.cn/github/javaguide/high-performance/serial-to-parallel.png) @@ -72,7 +72,7 @@ public interface Future { `Future` 在实际使用过程中存在一些局限性,比如不支持异步任务的编排组合、获取计算结果的 `get()` 方法为阻塞调用。 -Java 8 才被引入`CompletableFuture` 类可以解决`Future` 的这些缺陷。`CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。 +Java 8 才被引入 `CompletableFuture` 类可以解决 `Future` 的这些缺陷。`CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。 下面我们来简单看看 `CompletableFuture` 类的定义。 @@ -112,7 +112,7 @@ public class CompletableFuture implements Future, CompletionStage { 常见的创建 `CompletableFuture` 对象的方法如下: 1. 通过 new 关键字。 -2. 基于 `CompletableFuture` 自带的静态工厂方法:`runAsync()`、`supplyAsync()` 。 +2. 基于 `CompletableFuture` 自带的静态工厂方法:`runAsync()`、`supplyAsync()`。 #### new 关键字 @@ -149,7 +149,7 @@ public boolean isDone() { rpcResponse = completableFuture.get(); ``` -如果你已经知道计算的结果的话,可以使用静态方法 `completedFuture()` 来创建 `CompletableFuture` 。 +如果你已经知道计算的结果的话,可以使用静态方法 `completedFuture()` 来创建 `CompletableFuture`。 ```java CompletableFuture future = CompletableFuture.completedFuture("hello!"); @@ -177,7 +177,7 @@ static CompletableFuture runAsync(Runnable runnable); static CompletableFuture runAsync(Runnable runnable, Executor executor); ``` -`runAsync()` 方法接受的参数是 `Runnable` ,这是一个函数式接口,不允许返回值。当你需要异步操作且不关心返回结果的时候可以使用 `runAsync()` 方法。 +`runAsync()` 方法接受的参数是 `Runnable`,这是一个函数式接口,不允许返回值。当你需要异步操作且不关心返回结果的时候可以使用 `runAsync()` 方法。 ```java @FunctionalInterface @@ -186,7 +186,7 @@ public interface Runnable { } ``` -`supplyAsync()` 方法接受的参数是 `Supplier` ,这也是一个函数式接口,`U` 是返回结果值的类型。 +`supplyAsync()` 方法接受的参数是 `Supplier`,这也是一个函数式接口,`U` 是返回结果值的类型。 ```java @FunctionalInterface @@ -201,7 +201,7 @@ public interface Supplier { } ``` -当你需要异步操作且关心返回结果的时候,可以使用 `supplyAsync()` 方法。 +当你需要异步操作且关心返回结果的时候,可以使用 `supplyAsync()` 方法。 ```java CompletableFuture future = CompletableFuture.runAsync(() -> System.out.println("hello!")); @@ -261,7 +261,7 @@ assertEquals("hello!world!nice!", future.get()); **如果你不需要从回调函数中获取返回结果,可以使用 `thenAccept()` 或者 `thenRun()`。这两个方法的区别在于 `thenRun()` 不能访问异步计算的结果。** -`thenAccept()` 方法的参数是 `Consumer` 。 +`thenAccept()` 方法的参数是 `Consumer`。 ```java public CompletableFuture thenAccept(Consumer action) { @@ -293,7 +293,7 @@ public interface Consumer { } ``` -`thenRun()` 的方法是的参数是 `Runnable` 。 +`thenRun()` 的方法是的参数是 `Runnable`。 ```java public CompletableFuture thenRun(Runnable action) { @@ -320,7 +320,7 @@ CompletableFuture.completedFuture("hello!") .thenApply(s -> s + "world!").thenApply(s -> s + "nice!").thenRun(() -> System.out.println("hello!"));//hello! ``` -`whenComplete()` 的方法的参数是 `BiConsumer` 。 +`whenComplete()` 的方法的参数是 `BiConsumer`。 ```java public CompletableFuture whenComplete( @@ -340,7 +340,7 @@ public CompletableFuture whenCompleteAsync( } ``` -相对于 `Consumer` , `BiConsumer` 可以接收 2 个输入对象然后进行“消费”。 +相对于 `Consumer`, `BiConsumer` 可以接收 2 个输入对象然后进行“消费”。 ```java @FunctionalInterface @@ -551,11 +551,11 @@ try { 任务2执行完毕,当前时间:1695088059523 ``` -任务组合操作`acceptEitherAsync()`会在异步任务 1 和异步任务 2 中的任意一个完成时触发执行任务 3,但是需要注意,这个触发时机是不确定的。如果任务 1 和任务 2 都还未完成,那么任务 3 就不能被执行。 +任务组合操作 `acceptEitherAsync()` 会在异步任务 1 和异步任务 2 中的任意一个完成时触发执行任务 3,但是需要注意,这个触发时机是不确定的。如果任务 1 和任务 2 都还未完成,那么任务 3 就不能被执行。 ### 并行运行多个 CompletableFuture -你可以通过 `CompletableFuture` 的 `allOf()`这个静态方法来并行运行多个 `CompletableFuture` 。 +你可以通过 `CompletableFuture` 的 `allOf()` 这个静态方法来并行运行多个 `CompletableFuture`。 实际项目中,我们经常需要并行运行多个互不相关的任务,这些任务之间没有依赖关系,可以互相独立地运行。 @@ -612,7 +612,7 @@ CompletableFuture future2 = CompletableFuture.supplyAsync(() -> { }); ``` -调用 `join()` 可以让程序等`future1` 和 `future2` 都运行完了之后再继续执行。 +调用 `join()` 可以让程序等 `future1` 和 `future2` 都运行完了之后再继续执行。 ```java CompletableFuture completableFuture = CompletableFuture.allOf(future1, future2); @@ -678,7 +678,7 @@ CompletableFuture.runAsync(() -> { ### 尽量避免使用 get() -`CompletableFuture`的`get()`方法是阻塞的,尽量避免使用。如果必须要使用的话,需要添加超时时间,否则可能会导致主线程一直等待,无法执行其他任务。 +`CompletableFuture` 的 `get()` 方法是阻塞的,尽量避免使用。如果必须要使用的话,需要添加超时时间,否则可能会导致主线程一直等待,无法执行其他任务。 ```java CompletableFuture future = CompletableFuture.supplyAsync(() -> { @@ -705,7 +705,7 @@ CompletableFuture.runAsync(() -> { ### 正确进行异常处理 -使用 `CompletableFuture`的时候一定要以正确的方式进行异常处理,避免异常丢失或者出现不可控问题。 +使用 `CompletableFuture` 的时候一定要以正确的方式进行异常处理,避免异常丢失或者出现不可控问题。 下面是一些建议: @@ -717,19 +717,19 @@ CompletableFuture.runAsync(() -> { ### 合理组合多个异步任务 -正确使用 `thenCompose()` 、 `thenCombine()` 、`acceptEither()`、`allOf()`、`anyOf()`等方法来组合多个异步任务,以满足实际业务的需求,提高程序执行效率。 +正确使用 `thenCompose()`、 `thenCombine()`、`acceptEither()`、`allOf()`、`anyOf()` 等方法来组合多个异步任务,以满足实际业务的需求,提高程序执行效率。 -实际使用中,我们还可以利用或者参考现成的异步任务编排框架,比如京东的 [asyncTool](https://gitee.com/jd-platform-opensource/asyncTool) 。 +实际使用中,我们还可以利用或者参考现成的异步任务编排框架,比如京东的 [asyncTool](https://gitee.com/jd-platform-opensource/asyncTool)。 ![asyncTool README 文档](https://oss.javaguide.cn/github/javaguide/java/concurrent/asyncTool-readme.png) ## 后记 -这篇文章只是简单介绍了 `CompletableFuture` 的核心概念和比较常用的一些 API 。如果想要深入学习的话,还可以多找一些书籍和博客看,比如下面几篇文章就挺不错: +这篇文章只是简单介绍了 `CompletableFuture` 的核心概念和比较常用的一些 API。如果想要深入学习的话,还可以多找一些书籍和博客看,比如下面几篇文章就挺不错: - [CompletableFuture 原理与实践-外卖商家端 API 的异步化 - 美团技术团队](https://tech.meituan.com/2022/05/12/principles-and-practices-of-completablefuture.html):这篇文章详细介绍了 `CompletableFuture` 在实际项目中的运用。参考这篇文章,可以对项目中类似的场景进行优化,也算是一个小亮点了。这种性能优化方式比较简单且效果还不错! -- [读 RocketMQ 源码,学习并发编程三大神器 - 勇哥 java 实战分享](https://mp.weixin.qq.com/s/32Ak-WFLynQfpn0Cg0N-0A):这篇文章介绍了 RocketMQ 对`CompletableFuture`的应用。具体来说,从 RocketMQ 4.7 开始,RocketMQ 引入了 `CompletableFuture`来实现异步消息处理 。 +- [读 RocketMQ 源码,学习并发编程三大神器 - 勇哥 java 实战分享](https://mp.weixin.qq.com/s/32Ak-WFLynQfpn0Cg0N-0A):这篇文章介绍了 RocketMQ 对 `CompletableFuture` 的应用。具体来说,从 RocketMQ 4.7 开始,RocketMQ 引入了 `CompletableFuture` 来实现异步消息处理。 -另外,建议 G 友们可以看看京东的 [asyncTool](https://gitee.com/jd-platform-opensource/asyncTool) 这个并发框架,里面大量使用到了 `CompletableFuture` 。 +另外,建议 G 友们可以看看京东的 [asyncTool](https://gitee.com/jd-platform-opensource/asyncTool) 这个并发框架,里面大量使用到了 `CompletableFuture`。 diff --git a/docs/java/concurrent/java-concurrent-collections.md b/docs/java/concurrent/java-concurrent-collections.md index f5f29154f93..f0446c47be4 100644 --- a/docs/java/concurrent/java-concurrent-collections.md +++ b/docs/java/concurrent/java-concurrent-collections.md @@ -40,7 +40,7 @@ Java 8 中,锁粒度更细,`synchronized` 只锁定当前链表或红黑二 在 JDK1.5 之前,如果想要使用并发安全的 `List` 只能选择 `Vector`。而 `Vector` 是一种老旧的集合,已经被淘汰。`Vector` 对于增删改查等方法基本都加了 `synchronized`,这种方式虽然能够保证同步,但这相当于对整个 `Vector` 加上了一把大锁,使得每个方法执行的时候都要去获得锁,导致性能非常低下。 -JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线程安全且并发性能良好的容器,其中唯一的线程安全 `List` 实现就是 `CopyOnWriteArrayList` 。 +JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线程安全且并发性能良好的容器,其中唯一的线程安全 `List` 实现就是 `CopyOnWriteArrayList`。 对于大部分业务场景来说,读取操作往往是远大于写入操作的。由于读取操作不会对原有数据进行修改,因此,对于每次读取都进行加锁其实是一种资源浪费。相比之下,我们应该允许多个线程同时访问 `List` 的内部数据,毕竟对于读取操作来说是安全的。 @@ -48,7 +48,7 @@ JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线 `CopyOnWriteArrayList` 线程安全的核心在于其采用了 **写时复制(Copy-On-Write)** 的策略,从 `CopyOnWriteArrayList` 的名字就能看出了。 -当需要修改( `add`,`set`、`remove` 等操作) `CopyOnWriteArrayList` 的内容时,不会直接修改原数组,而是会先创建底层数组的副本,对副本数组进行修改,修改完之后再将修改后的数组赋值回去,这样就可以保证写操作不会影响读操作了。 +当需要修改(`add`,`set`、`remove` 等操作) `CopyOnWriteArrayList` 的内容时,不会直接修改原数组,而是会先创建底层数组的副本,对副本数组进行修改,修改完之后再将修改后的数组赋值回去,这样就可以保证写操作不会影响读操作了。 关于 `CopyOnWriteArrayList` 的详细介绍,请看我写的这篇文章:[`CopyOnWriteArrayList` 源码分析](./../collection/copyonwritearraylist-source-code.md)。 @@ -56,7 +56,7 @@ JDK1.5 引入了 `Java.util.concurrent`(JUC)包,其中提供了很多线 Java 提供的线程安全的 `Queue` 可以分为**阻塞队列**和**非阻塞队列**,其中阻塞队列的典型例子是 `BlockingQueue`,非阻塞队列的典型例子是 `ConcurrentLinkedQueue`,在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 **阻塞队列可以通过加锁来实现,非阻塞队列可以通过 CAS 操作实现。** -从名字可以看出,`ConcurrentLinkedQueue`这个队列使用链表作为其数据结构.`ConcurrentLinkedQueue` 应该算是在高并发环境中性能最好的队列了。它之所有能有很好的性能,是因为其内部复杂的实现。 +从名字可以看出,`ConcurrentLinkedQueue` 这个队列使用链表作为其数据结构.`ConcurrentLinkedQueue` 应该算是在高并发环境中性能最好的队列了。它之所有能有很好的性能,是因为其内部复杂的实现。 `ConcurrentLinkedQueue` 内部代码我们就不分析了,大家知道 `ConcurrentLinkedQueue` 主要使用 CAS 非阻塞算法来实现线程安全就好了。 @@ -72,7 +72,7 @@ Java 提供的线程安全的 `Queue` 可以分为**阻塞队列**和**非阻塞 ![BlockingQueue 的实现类](https://oss.javaguide.cn/github/javaguide/java/51622268.jpg) -下面主要介绍一下 3 个常见的 `BlockingQueue` 的实现类:`ArrayBlockingQueue`、`LinkedBlockingQueue`、`PriorityBlockingQueue` 。 +下面主要介绍一下 3 个常见的 `BlockingQueue` 的实现类:`ArrayBlockingQueue`、`LinkedBlockingQueue`、`PriorityBlockingQueue`。 ### ArrayBlockingQueue @@ -84,7 +84,7 @@ extends AbstractQueue implements BlockingQueue, Serializable{} ``` -`ArrayBlockingQueue` 一旦创建,容量不能改变。其并发控制采用可重入锁 `ReentrantLock` ,不管是插入操作还是读取操作,都需要获取到锁才能进行操作。当队列容量满时,尝试将元素放入队列将导致操作阻塞;尝试从一个空队列中取一个元素也会同样阻塞。 +`ArrayBlockingQueue` 一旦创建,容量不能改变。其并发控制采用可重入锁 `ReentrantLock`,不管是插入操作还是读取操作,都需要获取到锁才能进行操作。当队列容量满时,尝试将元素放入队列将导致操作阻塞;尝试从一个空队列中取一个元素也会同样阻塞。 `ArrayBlockingQueue` 默认情况下不能保证线程访问队列的公平性,所谓公平性是指严格按照线程等待的绝对时间顺序,即最先等待的线程能够最先访问到 `ArrayBlockingQueue`。而非公平性则是指访问 `ArrayBlockingQueue` 的顺序不是遵守严格的时间顺序,有可能存在,当 `ArrayBlockingQueue` 可以被访问时,长时间阻塞的线程依然无法访问到 `ArrayBlockingQueue`。如果保证公平性,通常会降低吞吐量。如果需要获得公平性的 `ArrayBlockingQueue`,可采用如下代码: @@ -94,7 +94,7 @@ private static ArrayBlockingQueue blockingQueue = new ArrayBlockingQueu ### LinkedBlockingQueue -`LinkedBlockingQueue` 底层基于**单向链表**实现的阻塞队列,可以当做无界队列也可以当做有界队列来使用,同样满足 FIFO 的特性,与 `ArrayBlockingQueue` 相比起来具有更高的吞吐量,为了防止 `LinkedBlockingQueue` 容量迅速增,损耗大量内存。通常在创建 `LinkedBlockingQueue` 对象时,会指定其大小,如果未指定,容量等于 `Integer.MAX_VALUE` 。 +`LinkedBlockingQueue` 底层基于**单向链表**实现的阻塞队列,可以当做无界队列也可以当做有界队列来使用,同样满足 FIFO 的特性,与 `ArrayBlockingQueue` 相比起来具有更高的吞吐量,为了防止 `LinkedBlockingQueue` 容量迅速增,损耗大量内存。通常在创建 `LinkedBlockingQueue` 对象时,会指定其大小,如果未指定,容量等于 `Integer.MAX_VALUE`。 **相关构造方法:** diff --git a/docs/java/concurrent/java-concurrent-questions-01.md b/docs/java/concurrent/java-concurrent-questions-01.md index 00d5f7497df..51664f54c9f 100644 --- a/docs/java/concurrent/java-concurrent-questions-01.md +++ b/docs/java/concurrent/java-concurrent-questions-01.md @@ -12,9 +12,9 @@ head: ## 线程 -### ⭐️什么是线程和进程? +### ⭐️ 什么是线程和进程? -#### 何为进程? +#### 何为进程? 进程是程序的一次执行过程,是系统运行程序的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。 @@ -24,7 +24,7 @@ head: ![进程示例图片-Windows](https://oss.javaguide.cn/github/javaguide/java/%E8%BF%9B%E7%A8%8B%E7%A4%BA%E4%BE%8B%E5%9B%BE%E7%89%87-Windows.png) -#### 何为线程? +#### 何为线程? 线程与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的**堆**和**方法区**资源,但每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比进程小得多,也正因为如此,线程也被称为轻量级进程。 @@ -80,13 +80,13 @@ JDK 1.2 之前,Java 线程是基于绿色线程(Green Threads)实现的, 在 Windows 和 Linux 等主流操作系统中,Java 线程采用的是一对一的线程模型,也就是一个 Java 线程对应一个系统内核线程。Solaris 系统是一个特例(Solaris 系统本身就支持多对多的线程模型),HotSpot VM 在 Solaris 上支持多对多和一对一。具体可以参考 R 大的回答: [JVM 中的线程模型是用户级的么?](https://www.zhihu.com/question/23096638/answer/29617153)。 -### ⭐️请简要描述线程与进程的关系,区别及优缺点? +### ⭐️ 请简要描述线程与进程的关系,区别及优缺点? 下图是 Java 内存区域,通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。 ![Java 运行时数据区域(JDK1.8 之后)](https://oss.javaguide.cn/github/javaguide/java/jvm/java-runtime-data-areas-jdk1.8.png) -从上图可以看出:一个进程中可以有多个线程,多个线程共享进程的**堆**和**方法区 (JDK1.8 之后的元空间)**资源,但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。 +从上图可以看出:一个进程中可以有多个线程,多个线程共享进程的**堆**和**方法区(JDK1.8 之后的元空间)**资源,但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。 **总结:** 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的,而各线程则不一定,因为同一进程中的线程极有可能会相互影响。线程执行开销小,但不利于资源的管理和保护;而进程正相反。 @@ -94,7 +94,7 @@ JDK 1.2 之前,Java 线程是基于绿色线程(Green Threads)实现的, 下面来思考这样一个问题:为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢?为什么堆和方法区是线程共享的呢? -#### 程序计数器为什么是私有的? +#### 程序计数器为什么是私有的? 程序计数器主要有下面两个作用: @@ -105,31 +105,31 @@ JDK 1.2 之前,Java 线程是基于绿色线程(Green Threads)实现的, 所以,程序计数器私有主要是为了**线程切换后能恢复到正确的执行位置**。 -#### 虚拟机栈和本地方法栈为什么是私有的? +#### 虚拟机栈和本地方法栈为什么是私有的? - **虚拟机栈:** 每个 Java 方法在执行之前会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程,就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。 -- **本地方法栈:** 和虚拟机栈所发挥的作用非常相似,区别是:**虚拟机栈为虚拟机执行 Java 方法 (也就是字节码)服务,而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。 +- **本地方法栈:** 和虚拟机栈所发挥的作用非常相似,区别是:**虚拟机栈为虚拟机执行 Java 方法(也就是字节码)服务,而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。 所以,为了**保证线程中的局部变量不被别的线程访问到**,虚拟机栈和本地方法栈是线程私有的。 #### 一句话简单了解堆和方法区 -堆和方法区是所有线程共享的资源,其中堆是进程中最大的一块内存,主要用于存放新创建的对象 (几乎所有对象都在这里分配内存),方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。 +堆和方法区是所有线程共享的资源,其中堆是进程中最大的一块内存,主要用于存放新创建的对象(几乎所有对象都在这里分配内存),方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。 ### 如何创建线程? -一般来说,创建线程有很多种方式,例如继承`Thread`类、实现`Runnable`接口、实现`Callable`接口、使用线程池、使用`CompletableFuture`类等等。 +一般来说,创建线程有很多种方式,例如继承 `Thread` 类、实现 `Runnable` 接口、实现 `Callable` 接口、使用线程池、使用 `CompletableFuture` 类等等。 不过,这些方式其实并没有真正创建出线程。准确点来说,这些都属于是在 Java 代码中使用多线程的方法。 -严格来说,Java 就只有一种方式可以创建线程,那就是通过`new Thread().start()`创建。不管是哪种方式,最终还是依赖于`new Thread().start()`。 +严格来说,Java 就只有一种方式可以创建线程,那就是通过 `new Thread().start()` 创建。不管是哪种方式,最终还是依赖于 `new Thread().start()`。 -### ⭐️说说线程的生命周期和状态? +### ⭐️ 说说线程的生命周期和状态? Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态: -- NEW: 初始状态,线程被创建出来但没有被调用 `start()` 。 -- RUNNABLE: 运行状态,线程被调用了 `start()`等待运行的状态。 +- NEW: 初始状态,线程被创建出来但没有被调用 `start()`。 +- RUNNABLE: 运行状态,线程被调用了 `start()` 等待运行的状态。 - BLOCKED:阻塞状态,需要等待锁释放。 - WAITING:等待状态,表示该线程需要等待其他线程做出一些特定动作(通知或中断)。 - TIME_WAITING:超时等待状态,可以在指定的时间后自行返回而不是像 WAITING 那样一直等待。 @@ -143,18 +143,18 @@ Java 线程状态变迁图(图源:[挑错 |《Java 并发编程的艺术》中 由上图可以看出:线程创建之后它将处于 **NEW(新建)** 状态,调用 `start()` 方法后开始运行,线程这时候处于 **READY(可运行)** 状态。可运行状态的线程获得了 CPU 时间片(timeslice)后就处于 **RUNNING(运行)** 状态。 -> 在操作系统层面,线程有 READY 和 RUNNING 状态;而在 JVM 层面,只能看到 RUNNABLE 状态(图源:[HowToDoInJava](https://howtodoinJava.com/ "HowToDoInJava"):[Java Thread Life Cycle and Thread States](https://howtodoinJava.com/Java/multi-threading/Java-thread-life-cycle-and-thread-states/ "Java Thread Life Cycle and Thread States")),所以 Java 系统一般将这两个状态统称为 **RUNNABLE(运行中)** 状态 。 +> 在操作系统层面,线程有 READY 和 RUNNING 状态;而在 JVM 层面,只能看到 RUNNABLE 状态(图源:[HowToDoInJava](https://howtodoinJava.com/ "HowToDoInJava"):[Java Thread Life Cycle and Thread States](https://howtodoinJava.com/Java/multi-threading/Java-thread-life-cycle-and-thread-states/ "Java Thread Life Cycle and Thread States")),所以 Java 系统一般将这两个状态统称为 **RUNNABLE(运行中)** 状态。 > -> **为什么 JVM 没有区分这两种状态呢?** (摘自:[Java 线程运行怎么有第六种状态? - Dawell 的回答](https://www.zhihu.com/question/56494969/answer/154053599) ) 现在的时分(time-sharing)多任务(multi-task)操作系统架构通常都是用所谓的“时间分片(time quantum or time slice)”方式进行抢占式(preemptive)轮转调度(round-robin 式)。这个时间分片通常是很小的,一个线程一次最多只能在 CPU 上运行比如 10-20ms 的时间(此时处于 running 状态),也即大概只有 0.01 秒这一量级,时间片用后就要被切换下来放入调度队列的末尾等待再次调度。(也即回到 ready 状态)。线程切换的如此之快,区分这两种状态就没什么意义了。 +> **为什么 JVM 没有区分这两种状态呢?**(摘自:[Java 线程运行怎么有第六种状态? - Dawell 的回答](https://www.zhihu.com/question/56494969/answer/154053599)) 现在的时分(time-sharing)多任务(multi-task)操作系统架构通常都是用所谓的“时间分片(time quantum or time slice)”方式进行抢占式(preemptive)轮转调度(round-robin 式)。这个时间分片通常是很小的,一个线程一次最多只能在 CPU 上运行比如 10-20ms 的时间(此时处于 running 状态),也即大概只有 0.01 秒这一量级,时间片用后就要被切换下来放入调度队列的末尾等待再次调度。(也即回到 ready 状态)。线程切换的如此之快,区分这两种状态就没什么意义了。 ![RUNNABLE-VS-RUNNING](https://oss.javaguide.cn/github/javaguide/java/RUNNABLE-VS-RUNNING.png) -- 当线程执行 `wait()`方法之后,线程进入 **WAITING(等待)** 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态。 -- **TIMED_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制,比如通过 `sleep(long millis)`方法或 `wait(long millis)`方法可以将线程置于 TIMED_WAITING 状态。当超时时间结束后,线程将会返回到 RUNNABLE 状态。 +- 当线程执行 `wait()` 方法之后,线程进入 **WAITING(等待)** 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态。 +- **TIMED_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制,比如通过 `sleep(long millis)` 方法或 `wait(long millis)` 方法可以将线程置于 TIMED_WAITING 状态。当超时时间结束后,线程将会返回到 RUNNABLE 状态。 - 当线程进入 `synchronized` 方法/块或者调用 `wait` 后(被 `notify`)重新进入 `synchronized` 方法/块,但是锁被其它线程占有,这个时候线程就会进入 **BLOCKED(阻塞)** 状态。 -- 线程在执行完了 `run()`方法之后将会进入到 **TERMINATED(终止)** 状态。 +- 线程在执行完了 `run()` 方法之后将会进入到 **TERMINATED(终止)** 状态。 -### 什么是线程上下文切换? +### 什么是线程上下文切换? 线程在执行过程中会有自己的运行条件和状态(也称上下文),比如上文所说到过的程序计数器,栈信息等。当出现如下情况的时候,线程会从占用 CPU 状态中退出。 @@ -173,9 +173,9 @@ Java 线程状态变迁图(图源:[挑错 |《Java 并发编程的艺术》中 **区别**: -- **`sleep()` 方法没有释放锁,而 `wait()` 方法释放了锁** 。 -- `wait()` 通常被用于线程间交互/通信,`sleep()`通常被用于暂停执行。 -- `wait()` 方法被调用后,线程不会自动苏醒,需要别的线程调用同一个对象上的 `notify()`或者 `notifyAll()` 方法。`sleep()`方法执行完成后,线程会自动苏醒,或者也可以使用 `wait(long timeout)` 超时后线程会自动苏醒。 +- **`sleep()` 方法没有释放锁,而 `wait()` 方法释放了锁**。 +- `wait()` 通常被用于线程间交互/通信,`sleep()` 通常被用于暂停执行。 +- `wait()` 方法被调用后,线程不会自动苏醒,需要别的线程调用同一个对象上的 `notify()` 或者 `notifyAll()` 方法。`sleep()` 方法执行完成后,线程会自动苏醒,或者也可以使用 `wait(long timeout)` 超时后线程会自动苏醒。 - `sleep()` 是 `Thread` 类的静态本地方法,`wait()` 则是 `Object` 类的本地方法。为什么这样设计呢?下一个问题就会聊到。 ### 为什么 wait() 方法不定义在 Thread 中? @@ -190,7 +190,7 @@ Java 线程状态变迁图(图源:[挑错 |《Java 并发编程的艺术》中 这是另一个非常经典的 Java 多线程面试问题,而且在面试中会经常被问到。很简单,但是很多人都会答不上来! -new 一个 `Thread`,线程进入了新建状态。调用 `start()`方法,会启动一个线程并使线程进入了就绪状态,当分配到时间片后就可以开始运行了。 `start()` 会执行线程的相应准备工作,然后自动执行 `run()` 方法的内容,这是真正的多线程工作。 但是,直接执行 `run()` 方法,会把 `run()` 方法当成一个普通方法在调用该方法的线程去执行,所以这并不是多线程工作。 +new 一个 `Thread`,线程进入了新建状态。调用 `start()` 方法,会启动一个线程并使线程进入了就绪状态,当分配到时间片后就可以开始运行了。 `start()` 会执行线程的相应准备工作,然后自动执行 `run()` 方法的内容,这是真正的多线程工作。 但是,直接执行 `run()` 方法,会把 `run()` 方法当成一个普通方法在调用该方法的线程去执行,所以这并不是多线程工作。 **总结:调用 `start()` 方法方可启动线程并使线程进入就绪状态,直接执行 `run()` 方法的话不会以多线程的方式执行。** @@ -208,7 +208,7 @@ new 一个 `Thread`,线程进入了新建状态。调用 `start()`方法,会 - **同步**:发出一个调用之后,在没有得到结果之前, 该调用就不可以返回,一直等待。 - **异步**:调用在发出之后,不用等待返回结果,该调用直接返回。 -### ⭐️为什么要使用多线程? +### ⭐️ 为什么要使用多线程? 先从总体上来说: @@ -220,7 +220,7 @@ new 一个 `Thread`,线程进入了新建状态。调用 `start()`方法,会 - **单核时代**:在单核时代多线程主要是为了提高单进程利用 CPU 和 IO 系统的效率。 假设只运行了一个 Java 进程的情况,当我们请求 IO 的时候,如果 Java 进程中只有一个线程,此线程被 IO 阻塞则整个进程被阻塞。CPU 和 IO 设备只有一个在运行,那么可以简单地说系统整体效率只有 50%。当使用多线程的时候,一个线程被 IO 阻塞,其他线程还可以继续使用 CPU。从而提高了 Java 进程利用系统资源的整体效率。 - **多核时代**: 多核时代多线程主要是为了提高进程利用多核 CPU 的能力。举个例子:假如我们要计算一个复杂的任务,我们只用一个线程的话,不论系统有几个 CPU 核心,都只会有一个 CPU 核心被利用到。而创建多个线程,这些线程可以被映射到底层多个 CPU 核心上执行,在任务中的多个线程没有资源竞争的情况下,任务执行的效率会有显著性的提高,约等于(单核时执行时间/CPU 核心数)。 -### ⭐️单核 CPU 支持 Java 多线程吗? +### ⭐️ 单核 CPU 支持 Java 多线程吗? 单核 CPU 是支持 Java 多线程的。操作系统通过时间片轮转的方式,将 CPU 的时间分配给不同的线程。尽管单核 CPU 一次只能执行一个任务,但通过快速在多个线程之间切换,可以让用户感觉多个任务是同时进行的。 @@ -233,7 +233,7 @@ new 一个 `Thread`,线程进入了新建状态。调用 `start()`方法,会 Java 使用的线程调度是抢占式的。也就是说,JVM 本身不负责线程的调度,而是将线程的调度委托给操作系统。操作系统通常会基于线程优先级和时间片来调度线程的执行,高优先级的线程通常获得 CPU 时间片的机会更多。 -### ⭐️单核 CPU 上运行多个线程效率一定会高吗? +### ⭐️ 单核 CPU 上运行多个线程效率一定会高吗? 单核 CPU 同时运行多个线程的效率是否会高,取决于线程的类型和任务的性质。一般来说,有两种类型的线程: @@ -244,7 +244,7 @@ Java 使用的线程调度是抢占式的。也就是说,JVM 本身不负责 因此,对于单核 CPU 来说,如果任务是 CPU 密集型的,那么开很多线程会影响效率;如果任务是 IO 密集型的,那么开很多线程会提高效率。当然,这里的“很多”也要适度,不能超过系统能够承受的上限。 -### 使用多线程可能带来什么问题? +### 使用多线程可能带来什么问题? 并发编程的目的就是为了能提高程序的执行效率进而提高程序的运行速度,但是并发编程并不总是能提高程序运行速度的,而且并发编程可能会遇到很多问题,比如:内存泄漏、死锁、线程不安全等等。 @@ -255,7 +255,7 @@ Java 使用的线程调度是抢占式的。也就是说,JVM 本身不负责 - 线程安全指的是在多线程环境下,对于同一份数据,不管有多少个线程同时访问,都能保证这份数据的正确性和一致性。 - 线程不安全则表示在多线程环境下,对于同一份数据,多个线程同时访问时可能会导致数据混乱、错误或者丢失。 -## ⭐️死锁 +## ⭐️ 死锁 ### 什么是线程死锁? @@ -265,7 +265,7 @@ Java 使用的线程调度是抢占式的。也就是说,JVM 本身不负责 ![死锁场景示意图:线程 A 持有 resource1 并等待 resource2,线程 B 持有 resource2 并等待 resource1,等待链形成闭环](https://oss.javaguide.cn/github/javaguide/cs-basics/operating-system/dead-lock-deadlock-scenario.png) -下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》): +下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况(代码来源于《并发编程之美》): ```java public class DeadLockDemo { @@ -326,7 +326,7 @@ Thread[线程 2,5,main]waiting get resource1 ### 如何检测死锁? -- 使用`jmap`、`jstack`等命令查看 JVM 线程栈和堆内存的情况。如果有死锁,`jstack` 的输出中通常会有 `Found one Java-level deadlock:`的字样,后面会跟着死锁相关的线程信息。另外,实际项目中还可以搭配使用`top`、`df`、`free`等命令查看操作系统的基本情况,出现死锁可能会导致 CPU、内存等资源消耗过高。 +- 使用 `jmap`、`jstack` 等命令查看 JVM 线程栈和堆内存的情况。如果有死锁,`jstack` 的输出中通常会有 `Found one Java-level deadlock:` 的字样,后面会跟着死锁相关的线程信息。另外,实际项目中还可以搭配使用 `top`、`df`、`free` 等命令查看操作系统的基本情况,出现死锁可能会导致 CPU、内存等资源消耗过高。 - 采用 VisualVM、JConsole 等工具进行排查。 这里以 JConsole 工具为例进行演示。 @@ -335,7 +335,7 @@ Thread[线程 2,5,main]waiting get resource1 ![jconsole](https://oss.javaguide.cn/github/javaguide/java/concurrent/jdk-home-bin-jconsole.png) -对于 MAC 用户来说,可以通过 `/usr/libexec/java_home -V`查看 JDK 安装目录,找到后通过 `open . + 文件夹地址`打开即可。例如,我本地的某个 JDK 的路径是: +对于 MAC 用户来说,可以通过 `/usr/libexec/java_home -V` 查看 JDK 安装目录,找到后通过 `open . + 文件夹地址` 打开即可。例如,我本地的某个 JDK 的路径是: ```bash open . /Users/guide/Library/Java/JavaVirtualMachines/corretto-1.8.0_252/Contents/Home @@ -347,7 +347,7 @@ Thread[线程 2,5,main]waiting get resource1 ![jconsole 检测到死锁](https://oss.javaguide.cn/github/javaguide/java/concurrent/jconsole-check-deadlock-done.png) -### 如何预防和避免线程死锁? +### 如何预防和避免线程死锁? **如何预防死锁?** 破坏死锁的产生的必要条件即可: @@ -393,8 +393,8 @@ Thread[线程 2,5,main]get resource2 Process finished with exit code 0 ``` -我们分析一下上面的代码为什么避免了死锁的发生? +我们分析一下上面的代码为什么避免了死锁的发生? -线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁,可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用,线程 2 获取到就可以执行了。这样就破坏了循环等待条件,因此避免了死锁。 +线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁,可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用,线程 2 获取到就可以执行了。这样就破坏了循环等待条件,因此避免了死锁。 diff --git a/docs/java/concurrent/java-concurrent-questions-02.md b/docs/java/concurrent/java-concurrent-questions-02.md index 80557766c3f..d782202da75 100644 --- a/docs/java/concurrent/java-concurrent-questions-02.md +++ b/docs/java/concurrent/java-concurrent-questions-02.md @@ -12,15 +12,15 @@ head: -## ⭐️JMM(Java 内存模型) +## ⭐️ JMM(Java 内存模型) -JMM(Java 内存模型)相关的问题比较多,也比较重要,于是我单独抽了一篇文章来总结 JMM 相关的知识点和问题:[JMM(Java 内存模型)详解](https://javaguide.cn/java/concurrent/jmm.html) 。 +JMM(Java 内存模型)相关的问题比较多,也比较重要,于是我单独抽了一篇文章来总结 JMM 相关的知识点和问题:[JMM(Java 内存模型)详解](https://javaguide.cn/java/concurrent/jmm.html)。 -## ⭐️volatile 关键字 +## ⭐️ volatile 关键字 ### 如何保证变量的可见性? -在 Java 中,`volatile` 关键字可以保证变量的可见性,如果我们将变量声明为 **`volatile`** ,这就指示 JVM,这个变量是共享且不稳定的,每次使用它都到主存中进行读取。 +在 Java 中,`volatile` 关键字可以保证变量的可见性,如果我们将变量声明为 **`volatile`**,这就指示 JVM,这个变量是共享且不稳定的,每次使用它都到主存中进行读取。 ![JMM(Java 内存模型)](https://oss.javaguide.cn/github/javaguide/java/concurrent/jmm.png) @@ -32,7 +32,7 @@ JMM(Java 内存模型)相关的问题比较多,也比较重要,于是我 ### 如何禁止指令重排序? -**在 Java 中,`volatile` 关键字除了可以保证变量的可见性,还有一个重要的作用就是防止 JVM 的指令重排序。** 如果我们将变量声明为 **`volatile`** ,在对这个变量进行读写操作的时候,会通过插入特定的 **内存屏障** 的方式来禁止指令重排序。 +**在 Java 中,`volatile` 关键字除了可以保证变量的可见性,还有一个重要的作用就是防止 JVM 的指令重排序。** 如果我们将变量声明为 **`volatile`**,在对这个变量进行读写操作的时候,会通过插入特定的 **内存屏障** 的方式来禁止指令重排序。 在 Java 中,`Unsafe` 类提供了三个开箱即用的内存屏障相关的方法,屏蔽了操作系统底层的差异: @@ -42,7 +42,7 @@ public native void storeFence(); public native void fullFence(); ``` -理论上来说,你通过这个三个方法也可以实现和`volatile`禁止重排序一样的效果,只是会麻烦一些。 +理论上来说,你通过这个三个方法也可以实现和 `volatile` 禁止重排序一样的效果,只是会麻烦一些。 #### 4 种内存屏障类型 @@ -175,13 +175,13 @@ public class VolatileHappensBeforeDemo { 上面代码中,happens-before 关系链如下: -1. 操作1、操作2 happens-before 操作3(**程序顺序规则**:同一线程中,前面的操作 happens-before 后面的操作) -2. 操作3 happens-before 操作4(**volatile 变量规则**:volatile 写 happens-before volatile 读) -3. 操作4 happens-before 操作5、操作6(**程序顺序规则**) +1. 操作 1、操作 2 happens-before 操作 3(**程序顺序规则**:同一线程中,前面的操作 happens-before 后面的操作) +2. 操作 3 happens-before 操作 4(**volatile 变量规则**:volatile 写 happens-before volatile 读) +3. 操作 4 happens-before 操作 5、操作 6(**程序顺序规则**) -根据 **传递性**:操作1、操作2 happens-before 操作5、操作6。 +根据 **传递性**:操作 1、操作 2 happens-before 操作 5、操作 6。 -因此,当线程 B 在操作4 读取到 `flag == true` 时,线程 A 在操作3 之前对 `a` 和 `b` 的修改对线程 B 一定是可见的。这里的关键在于:**volatile 变量的写-读操作,不仅保证了 volatile 变量本身的可见性,还通过 happens-before 的传递性“顺带”保证了其前后普通变量的可见性。** +因此,当线程 B 在操作 4 读取到 `flag == true` 时,线程 A 在操作 3 之前对 `a` 和 `b` 的修改对线程 B 一定是可见的。这里的关键在于:**volatile 变量的写-读操作,不仅保证了 volatile 变量本身的可见性,还通过 happens-before 的传递性“顺带”保证了其前后普通变量的可见性。** 这也解释了为什么在实际开发中,`volatile` 经常被用作 **状态标志位**(如上面例子中的 `flag`),它可以在不使用锁的情况下,安全地在线程间传递状态信息,同时保证相关数据的可见性。 @@ -237,12 +237,12 @@ public class VolatileAtomicityDemo { `volatile` 是无法保证这三个操作是具有原子性的,有可能导致下面这种情况出现: -1. 线程 1 对 `inc` 进行读取操作之后,还未对其进行修改。线程 2 又读取了 `inc`的值并对其进行修改(+1),再将`inc` 的值写回内存。 -2. 线程 2 操作完毕后,线程 1 对 `inc`的值进行修改(+1),再将`inc` 的值写回内存。 +1. 线程 1 对 `inc` 进行读取操作之后,还未对其进行修改。线程 2 又读取了 `inc` 的值并对其进行修改(+1),再将 `inc` 的值写回内存。 +2. 线程 2 操作完毕后,线程 1 对 `inc` 的值进行修改(+1),再将 `inc` 的值写回内存。 这也就导致两个线程分别对 `inc` 进行了一次自增操作后,`inc` 实际上只增加了 1。 -其实,如果想要保证上面的代码运行正确也非常简单,利用 `synchronized`、`Lock`或者`AtomicInteger`都可以。 +其实,如果想要保证上面的代码运行正确也非常简单,利用 `synchronized`、`Lock` 或者 `AtomicInteger` 都可以。 使用 `synchronized` 改进: @@ -276,13 +276,13 @@ public void increase() { } ``` -## ⭐️乐观锁和悲观锁 +## ⭐️ 乐观锁和悲观锁 ### 什么是悲观锁? -悲观锁总是假设最坏的情况,认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改),所以每次在获取资源操作的时候都会上锁,这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说,**共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程**。 +悲观锁总是假设最坏的情况,认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改),所以每次在获取资源操作的时候都会上锁,这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说,**共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程**。 -像 Java 中`synchronized`和`ReentrantLock`等独占锁就是悲观锁思想的实现。 +像 Java 中 `synchronized` 和 `ReentrantLock` 等独占锁就是悲观锁思想的实现。 ```java public void performSynchronisedTask() { @@ -306,7 +306,7 @@ try { 乐观锁总是假设最好的情况,认为共享资源每次被访问的时候不会出现问题,线程可以不停地执行,无需加锁也无需等待,只是在提交修改的时候去验证对应的资源(也就是数据)是否被其它线程修改了(具体方法可以使用版本号机制或 CAS 算法)。 -在 Java 中`java.util.concurrent.atomic`包下面的原子变量类(比如`AtomicInteger`、`LongAdder`)就是使用了乐观锁的一种实现方式 **CAS** 实现的。 +在 Java 中 `java.util.concurrent.atomic` 包下面的原子变量类(比如 `AtomicInteger`、`LongAdder`)就是使用了乐观锁的一种实现方式 **CAS** 实现的。 ![JUC原子类概览](https://oss.javaguide.cn/github/javaguide/java/JUC%E5%8E%9F%E5%AD%90%E7%B1%BB%E6%A6%82%E8%A7%88-20230814005211968.png) ```java @@ -318,12 +318,12 @@ sum.increment(); 高并发的场景下,乐观锁相比悲观锁来说,不存在锁竞争造成线程阻塞,也不会有死锁的问题,在性能上往往会更胜一筹。但是,如果冲突频繁发生(写占比非常多的情况),会频繁失败和重试,这样同样会非常影响性能,导致 CPU 飙升。 -不过,大量失败重试的问题也是可以解决的,像我们前面提到的 `LongAdder`以空间换时间的方式就解决了这个问题。 +不过,大量失败重试的问题也是可以解决的,像我们前面提到的 `LongAdder` 以空间换时间的方式就解决了这个问题。 理论上来说: -- 悲观锁通常多用于写比较多的情况(多写场景,竞争激烈),这样可以避免频繁失败和重试影响性能,悲观锁的开销是固定的。不过,如果乐观锁解决了频繁失败和重试这个问题的话(比如`LongAdder`),也是可以考虑使用乐观锁的,要视实际情况而定。 -- 乐观锁通常多用于写比较少的情况(多读场景,竞争较少),这样可以避免频繁加锁影响性能。不过,乐观锁主要针对的对象是单个共享变量(参考`java.util.concurrent.atomic`包下面的原子变量类)。 +- 悲观锁通常多用于写比较多的情况(多写场景,竞争激烈),这样可以避免频繁失败和重试影响性能,悲观锁的开销是固定的。不过,如果乐观锁解决了频繁失败和重试这个问题的话(比如 `LongAdder`),也是可以考虑使用乐观锁的,要视实际情况而定。 +- 乐观锁通常多用于写比较少的情况(多读场景,竞争较少),这样可以避免频繁加锁影响性能。不过,乐观锁主要针对的对象是单个共享变量(参考 `java.util.concurrent.atomic` 包下面的原子变量类)。 ### 如何实现乐观锁? @@ -333,18 +333,18 @@ sum.increment(); 一般是在数据表中加上一个数据版本号 `version` 字段,表示数据被修改的次数。当数据被修改时,`version` 值会加一。当线程 A 要更新数据值时,在读取数据的同时也会读取 `version` 值,在提交更新时,若刚才读取到的 version 值为当前数据库中的 `version` 值相等时才更新,否则重试更新操作,直到更新成功。 -**举一个简单的例子**:假设数据库中帐户信息表中有一个 version 字段,当前值为 1 ;而当前帐户余额字段( `balance` )为 \$100 。 +**举一个简单的例子**:假设数据库中帐户信息表中有一个 version 字段,当前值为 1;而当前帐户余额字段(`balance`)为 \$100。 -1. 操作员 A 此时将其读出( `version`=1 ),并从其帐户余额中扣除 $50( $100-\$50 )。 -2. 在操作员 A 操作的过程中,操作员 B 也读入此用户信息( `version`=1 ),并从其帐户余额中扣除 $20 ( $100-\$20 )。 -3. 操作员 A 完成了修改工作,将数据版本号( `version`=1 ),连同帐户扣除后余额( `balance`=\$50 ),提交至数据库更新,此时由于提交数据版本等于数据库记录当前版本,数据被更新,数据库记录 `version` 更新为 2 。 -4. 操作员 B 完成了操作,也将版本号( `version`=1 )试图向数据库提交数据( `balance`=\$80 ),但此时比对数据库记录版本时发现,操作员 B 提交的数据版本号为 1 ,数据库记录当前版本也为 2 ,不满足 “ 提交版本必须等于当前版本才能执行更新 ” 的乐观锁策略,因此,操作员 B 的提交被驳回。 +1. 操作员 A 此时将其读出(`version`=1),并从其帐户余额中扣除 $50($100-\$50)。 +2. 在操作员 A 操作的过程中,操作员 B 也读入此用户信息(`version`=1),并从其帐户余额中扣除 $20($100-\$20)。 +3. 操作员 A 完成了修改工作,将数据版本号(`version`=1),连同帐户扣除后余额(`balance`=\$50),提交至数据库更新,此时由于提交数据版本等于数据库记录当前版本,数据被更新,数据库记录 `version` 更新为 2。 +4. 操作员 B 完成了操作,也将版本号(`version`=1)试图向数据库提交数据(`balance`=\$80),但此时比对数据库记录版本时发现,操作员 B 提交的数据版本号为 1,数据库记录当前版本也为 2,不满足 “ 提交版本必须等于当前版本才能执行更新 ” 的乐观锁策略,因此,操作员 B 的提交被驳回。 这样就避免了操作员 B 用基于 `version`=1 的旧数据修改的结果覆盖操作员 A 的操作结果的可能。 #### CAS 算法 -CAS 的全称是 **Compare And Swap(比较与交换)** ,用于实现乐观锁,被广泛应用于各大框架中。CAS 的思想很简单,就是用一个预期值和要更新的变量值进行比较,两值相等才会进行更新。 +CAS 的全称是 **Compare And Swap(比较与交换)**,用于实现乐观锁,被广泛应用于各大框架中。CAS 的思想很简单,就是用一个预期值和要更新的变量值进行比较,两值相等才会进行更新。 CAS 是一个原子操作,底层依赖于一条 CPU 的原子指令。 @@ -360,14 +360,14 @@ CAS 涉及到三个操作数: **举一个简单的例子**:线程 A 要修改变量 i 的值为 6,i 原值为 1(V = 1,E=1,N=6,假设不存在 ABA 问题)。 -1. i 与 1 进行比较,如果相等, 则说明没被其他线程修改,可以被设置为 6 。 +1. i 与 1 进行比较,如果相等, 则说明没被其他线程修改,可以被设置为 6。 2. i 与 1 进行比较,如果不相等,则说明被其他线程修改,当前线程放弃更新,CAS 操作失败。 当多个线程同时使用 CAS 操作一个变量时,只有一个会胜出,并成功更新,其余均会失败,但失败的线程并不会被挂起,仅是被告知失败,并且允许再次尝试,当然也允许失败的线程放弃操作。 Java 语言并没有直接实现 CAS,CAS 相关的实现是通过 C++ 内联汇编的形式实现的(JNI 调用)。因此, CAS 的具体实现和操作系统以及 CPU 都有关系。 -`sun.misc`包下的`Unsafe`类提供了`compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong`方法来实现的对`Object`、`int`、`long`类型的 CAS 操作 +`sun.misc` 包下的 `Unsafe` 类提供了 `compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong` 方法来实现的对 `Object`、`int`、`long` 类型的 CAS 操作 ```java /** @@ -385,15 +385,15 @@ public final native boolean compareAndSwapInt(Object o, long offset, int expecte public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update); ``` -关于 `Unsafe` 类的详细介绍可以看这篇文章:[Java 魔法类 Unsafe 详解 - JavaGuide - 2022](https://javaguide.cn/java/basis/unsafe.html) 。 +关于 `Unsafe` 类的详细介绍可以看这篇文章:[Java 魔法类 Unsafe 详解 - JavaGuide - 2022](https://javaguide.cn/java/basis/unsafe.html)。 ### Java 中 CAS 是如何实现的? -在 Java 中,实现 CAS(Compare-And-Swap, 比较并交换)操作的一个关键类是`Unsafe`。 +在 Java 中,实现 CAS(Compare-And-Swap, 比较并交换)操作的一个关键类是 `Unsafe`。 -`Unsafe`类位于`sun.misc`包下,是一个提供低级别、不安全操作的类。由于其强大的功能和潜在的危险性,它通常用于 JVM 内部或一些需要极高性能和底层访问的库中,而不推荐普通开发者在应用程序中使用。关于 `Unsafe`类的详细介绍,可以阅读这篇文章:📌[Java 魔法类 Unsafe 详解](https://javaguide.cn/java/basis/unsafe.html)。 +`Unsafe` 类位于 `sun.misc` 包下,是一个提供低级别、不安全操作的类。由于其强大的功能和潜在的危险性,它通常用于 JVM 内部或一些需要极高性能和底层访问的库中,而不推荐普通开发者在应用程序中使用。关于 `Unsafe` 类的详细介绍,可以阅读这篇文章:📌[Java 魔法类 Unsafe 详解](https://javaguide.cn/java/basis/unsafe.html)。 -`sun.misc`包下的`Unsafe`类提供了`compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong`方法来实现的对`Object`、`int`、`long`类型的 CAS 操作: +`sun.misc` 包下的 `Unsafe` 类提供了 `compareAndSwapObject`、`compareAndSwapInt`、`compareAndSwapLong` 方法来实现的对 `Object`、`int`、`long` 类型的 CAS 操作: ```java /** @@ -418,7 +418,7 @@ boolean compareAndSwapInt(Object o, long offset, int expected, int x); boolean compareAndSwapLong(Object o, long offset, long expected, long x); ``` -`Unsafe`类中的 CAS 方法是`native`方法。`native`关键字表明这些方法是用本地代码(通常是 C 或 C++)实现的,而不是用 Java 实现的。这些方法直接调用底层的硬件指令来实现原子操作。也就是说,Java 语言并没有直接用 Java 实现 CAS,而是通过 C++ 内联汇编的形式实现的(通过 JNI 调用)。因此,CAS 的具体实现与操作系统以及 CPU 密切相关。 +`Unsafe` 类中的 CAS 方法是 `native` 方法。`native` 关键字表明这些方法是用本地代码(通常是 C 或 C++)实现的,而不是用 Java 实现的。这些方法直接调用底层的硬件指令来实现原子操作。也就是说,Java 语言并没有直接用 Java 实现 CAS,而是通过 C++ 内联汇编的形式实现的(通过 JNI 调用)。因此,CAS 的具体实现与操作系统以及 CPU 密切相关。 `java.util.concurrent.atomic` 包提供了一些用于原子操作的类。这些类利用底层的原子指令,确保在多线程环境下的操作是线程安全的。 @@ -426,11 +426,11 @@ boolean compareAndSwapLong(Object o, long offset, long expected, long x); 关于这些 Atomic 原子类的介绍和使用,可以阅读这篇文章:[Atomic 原子类总结](https://javaguide.cn/java/concurrent/atomic-classes.html)。 -`AtomicInteger`是 Java 的原子类之一,主要用于对 `int` 类型的变量进行原子操作,它利用`Unsafe`类提供的低级别原子操作方法实现无锁的线程安全性。 +`AtomicInteger` 是 Java 的原子类之一,主要用于对 `int` 类型的变量进行原子操作,它利用 `Unsafe` 类提供的低级别原子操作方法实现无锁的线程安全性。 -下面,我们通过解读`AtomicInteger`的核心源码(JDK1.8),来说明 Java 如何使用`Unsafe`类的方法来实现原子操作。 +下面,我们通过解读 `AtomicInteger` 的核心源码(JDK1.8),来说明 Java 如何使用 `Unsafe` 类的方法来实现原子操作。 -`AtomicInteger`核心源码如下: +`AtomicInteger` 核心源码如下: ```java // 获取 Unsafe 实例 @@ -470,7 +470,7 @@ public final int getAndDecrement() { } ``` -`Unsafe#getAndAddInt`源码: +`Unsafe#getAndAddInt` 源码: ```java // 原子地获取并增加整数值 @@ -485,9 +485,9 @@ public final int getAndAddInt(Object o, long offset, int delta) { } ``` -可以看到,`getAndAddInt` 使用了 `do-while` 循环:在`compareAndSwapInt`操作失败时,会不断重试直到成功。也就是说,`getAndAddInt`方法会通过 `compareAndSwapInt` 方法来尝试更新 `value` 的值,如果更新失败(当前值在此期间被其他线程修改),它会重新获取当前值并再次尝试更新,直到操作成功。 +可以看到,`getAndAddInt` 使用了 `do-while` 循环:在 `compareAndSwapInt` 操作失败时,会不断重试直到成功。也就是说,`getAndAddInt` 方法会通过 `compareAndSwapInt` 方法来尝试更新 `value` 的值,如果更新失败(当前值在此期间被其他线程修改),它会重新获取当前值并再次尝试更新,直到操作成功。 -由于 CAS 操作可能会因为并发冲突而失败,因此通常会与`while`循环搭配使用,在失败后不断重试,直到操作成功。这就是 **自旋锁机制** 。 +由于 CAS 操作可能会因为并发冲突而失败,因此通常会与 `while` 循环搭配使用,在失败后不断重试,直到操作成功。这就是 **自旋锁机制**。 ### CAS 算法存在哪些问题? @@ -518,14 +518,14 @@ public boolean compareAndSet(V expectedReference, CAS 经常会用到自旋操作来进行重试,也就是不成功就一直循环执行直到成功。如果长时间不成功,会给 CPU 带来非常大的执行开销。 -如果 JVM 能够支持处理器提供的`pause`指令,那么自旋操作的效率将有所提升。`pause`指令有两个重要作用: +如果 JVM 能够支持处理器提供的 `pause` 指令,那么自旋操作的效率将有所提升。`pause` 指令有两个重要作用: -1. **延迟流水线执行指令**:`pause`指令可以延迟指令的执行,从而减少 CPU 的资源消耗。具体的延迟时间取决于处理器的实现版本,在某些处理器上,延迟时间可能为零。 -2. **避免内存顺序冲突**:在退出循环时,`pause`指令可以避免由于内存顺序冲突而导致的 CPU 流水线被清空,从而提高 CPU 的执行效率。 +1. **延迟流水线执行指令**:`pause` 指令可以延迟指令的执行,从而减少 CPU 的资源消耗。具体的延迟时间取决于处理器的实现版本,在某些处理器上,延迟时间可能为零。 +2. **避免内存顺序冲突**:在退出循环时,`pause` 指令可以避免由于内存顺序冲突而导致的 CPU 流水线被清空,从而提高 CPU 的执行效率。 #### 只能保证一个共享变量的原子操作 -CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量时,CAS 就显得无能为力。不过,从 JDK 1.5 开始,Java 提供了`AtomicReference`类,这使得我们能够保证引用对象之间的原子性。通过将多个变量封装在一个对象中,我们可以使用`AtomicReference`来执行 CAS 操作。 +CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量时,CAS 就显得无能为力。不过,从 JDK 1.5 开始,Java 提供了 `AtomicReference` 类,这使得我们能够保证引用对象之间的原子性。通过将多个变量封装在一个对象中,我们可以使用 `AtomicReference` 来执行 CAS 操作。 除了 `AtomicReference` 这种方式之外,还可以利用加锁来保证。 @@ -550,7 +550,7 @@ CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量 在 Java 早期版本中,`synchronized` 属于 **重量级锁**,效率低下。这是因为监视器锁(monitor)是依赖于底层的操作系统的 `Mutex Lock` 来实现的,Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程,都需要操作系统帮忙完成,而操作系统实现线程之间的切换时需要从用户态转换到内核态,这个状态之间的转换需要相对比较长的时间,时间成本相对较高。 -不过,在 Java 6 之后, `synchronized` 引入了大量的优化如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销,这些优化让 `synchronized` 锁的效率提升了很多。因此, `synchronized` 还是可以在实际项目中使用的,像 JDK 源码、很多开源框架都大量使用了 `synchronized` 。 +不过,在 Java 6 之后, `synchronized` 引入了大量的优化如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销,这些优化让 `synchronized` 锁的效率提升了很多。因此, `synchronized` 还是可以在实际项目中使用的,像 JDK 源码、很多开源框架都大量使用了 `synchronized`。 关于偏向锁多补充一点:由于偏向锁增加了 JVM 的复杂性,同时也并没有为所有应用都带来性能提升。因此,在 JDK15 中,偏向锁被默认关闭(仍然可以使用 `-XX:+UseBiasedLocking` 启用偏向锁),在 JDK18 中,偏向锁已经被彻底废弃(无法通过命令行打开)。 @@ -562,9 +562,9 @@ CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量 2. 修饰静态方法 3. 修饰代码块 -**1、修饰实例方法** (锁当前对象实例) +**1、修饰实例方法**(锁当前对象实例) -给当前对象实例加锁,进入同步代码前要获得 **当前对象实例的锁** 。 +给当前对象实例加锁,进入同步代码前要获得 **当前对象实例的锁**。 ```java synchronized void method() { @@ -572,9 +572,9 @@ synchronized void method() { } ``` -**2、修饰静态方法** (锁当前类) +**2、修饰静态方法**(锁当前类) -给当前类加锁,会作用于类的所有对象实例 ,进入同步代码前要获得 **当前 class 的锁**。 +给当前类加锁,会作用于类的所有对象实例,进入同步代码前要获得 **当前 class 的锁**。 这是因为静态成员不属于任何一个实例对象,归整个类所有,不依赖于类的特定实例,被类的所有实例共享。 @@ -586,7 +586,7 @@ synchronized static void method() { 静态 `synchronized` 方法和非静态 `synchronized` 方法之间的调用互斥么?不互斥!如果一个线程 A 调用一个实例对象的非静态 `synchronized` 方法,而线程 B 需要调用这个实例对象所属类的静态 `synchronized` 方法,是允许的,不会发生互斥现象,因为访问静态 `synchronized` 方法占用的锁是当前类的锁,而访问非静态 `synchronized` 方法占用的锁是当前实例对象锁。 -**3、修饰代码块** (锁指定对象/类) +**3、修饰代码块**(锁指定对象/类) 对括号里指定的对象/类加锁: @@ -611,7 +611,7 @@ synchronized(this) { 另外,构造方法本身是线程安全的,但如果在构造方法中涉及到共享资源的操作,就需要采取适当的同步措施来保证整个构造过程的线程安全。 -### ⭐️synchronized 底层原理了解吗? +### ⭐️ synchronized 底层原理了解吗? synchronized 关键字底层原理属于 JVM 层面的东西。 @@ -627,7 +627,7 @@ public class SynchronizedDemo { } ``` -通过 JDK 自带的 `javap` 命令查看 `SynchronizedDemo` 类的相关字节码信息:首先切换到类的对应目录执行 `javac SynchronizedDemo.java` 命令生成编译后的 .class 文件,然后执行`javap -c -s -v -l SynchronizedDemo.class`。 +通过 JDK 自带的 `javap` 命令查看 `SynchronizedDemo` 类的相关字节码信息:首先切换到类的对应目录执行 `javac SynchronizedDemo.java` 命令生成编译后的 .class 文件,然后执行 `javap -c -s -v -l SynchronizedDemo.class`。 ![synchronized关键字原理](https://oss.javaguide.cn/github/javaguide/java/concurrent/synchronized-principle.png) @@ -637,11 +637,11 @@ public class SynchronizedDemo { 当执行 `monitorenter` 指令时,线程试图获取锁也就是获取 **对象监视器 `monitor`** 的持有权。 -> 在 Java 虚拟机(HotSpot)中,Monitor 是基于 C++实现的,由[ObjectMonitor](https://github.com/openjdk-mirror/jdk7u-hotspot/blob/50bdefc3afe944ca74c3093e7448d6b889cd20d1/src/share/vm/runtime/objectMonitor.cpp)实现的。每个对象中都内置了一个 `ObjectMonitor`对象。 +> 在 Java 虚拟机(HotSpot)中,Monitor 是基于 C++实现的,由[ObjectMonitor](https://github.com/openjdk-mirror/jdk7u-hotspot/blob/50bdefc3afe944ca74c3093e7448d6b889cd20d1/src/share/vm/runtime/objectMonitor.cpp)实现的。每个对象中都内置了一个 `ObjectMonitor` 对象。 > -> 另外,`wait/notify`等方法也依赖于`monitor`对象,这就是为什么只有在同步的块或者方法中才能调用`wait/notify`等方法,否则会抛出`java.lang.IllegalMonitorStateException`的异常的原因。 +> 另外,`wait/notify` 等方法也依赖于 `monitor` 对象,这就是为什么只有在同步的块或者方法中才能调用 `wait/notify` 等方法,否则会抛出 `java.lang.IllegalMonitorStateException` 的异常的原因。 -在执行`monitorenter`时,会尝试获取对象的锁,如果锁的计数器为 0 则表示锁可以被获取,获取后将锁计数器设为 1 也就是加 1。 +在执行 `monitorenter` 时,会尝试获取对象的锁,如果锁的计数器为 0 则表示锁可以被获取,获取后将锁计数器设为 1 也就是加 1。 ![执行 monitorenter 获取锁](https://oss.javaguide.cn/github/javaguide/java/concurrent/synchronized-get-lock-code-block.png) @@ -676,7 +676,7 @@ public class SynchronizedDemo2 { **不过,两者的本质都是对对象监视器 monitor 的获取。** -相关推荐:[Java 锁与线程的那些事 - 有赞技术团队](https://tech.youzan.com/javasuo-yu-xian-cheng-de-na-xie-shi/) 。 +相关推荐:[Java 锁与线程的那些事 - 有赞技术团队](https://tech.youzan.com/javasuo-yu-xian-cheng-de-na-xie-shi/)。 🧗🏻 进阶一下:学有余力的小伙伴可以抽时间详细研究一下对象监视器 `monitor`。 @@ -706,19 +706,19 @@ Open JDK 官方声明:[JEP 374: Deprecate and Disable Biased Locking](https:// 偏向锁仅仅在单线程访问同步代码块的场景中可以获得性能收益。 -如果存在多线程竞争,就需要 **撤销偏向锁** ,这个操作的性能开销是比较昂贵的。偏向锁的撤销需要等待进入到全局安全点(safe point),该状态下所有线程都是暂停的,此时去检查线程状态并进行偏向锁的撤销。 +如果存在多线程竞争,就需要 **撤销偏向锁**,这个操作的性能开销是比较昂贵的。偏向锁的撤销需要等待进入到全局安全点(safe point),该状态下所有线程都是暂停的,此时去检查线程状态并进行偏向锁的撤销。 - **JVM 内部代码维护成本太高:** 偏向锁将许多复杂代码引入到同步子系统,并且对其他的 HotSpot 组件也具有侵入性。这种复杂性为理解代码、系统重构带来了困难,因此, OpenJDK 官方希望禁用、废弃并删除偏向锁。 -### ⭐️synchronized 和 volatile 有什么区别? +### ⭐️ synchronized 和 volatile 有什么区别? `synchronized` 关键字和 `volatile` 关键字是两个互补的存在,而不是对立的存在! -- `volatile` 关键字是线程同步的轻量级实现,所以 `volatile`性能肯定比`synchronized`关键字要好 。但是 `volatile` 关键字只能用于变量而 `synchronized` 关键字可以修饰方法以及代码块 。 +- `volatile` 关键字是线程同步的轻量级实现,所以 `volatile` 性能肯定比 `synchronized` 关键字要好。但是 `volatile` 关键字只能用于变量而 `synchronized` 关键字可以修饰方法以及代码块。 - `volatile` 关键字能保证数据的可见性,但不能保证数据的原子性。`synchronized` 关键字两者都能保证。 -- `volatile`关键字主要用于解决变量在多个线程之间的可见性,而 `synchronized` 关键字解决的是多个线程之间访问资源的同步性。 +- `volatile` 关键字主要用于解决变量在多个线程之间的可见性,而 `synchronized` 关键字解决的是多个线程之间访问资源的同步性。 #### volatile 与 synchronized 的性能对比 @@ -773,7 +773,7 @@ public ReentrantLock(boolean fair) { - **公平锁** : 锁被释放之后,先申请的线程先得到锁。性能较差一些,因为公平锁为了保证时间上的绝对顺序,上下文切换更频繁。 - **非公平锁**:锁被释放之后,后申请的线程可能会先获取到锁,是随机或者按照其他优先级排序的。性能更好,但可能会导致某些线程永远无法获取到锁。 -### ⭐️synchronized 和 ReentrantLock 有什么区别? +### ⭐️ synchronized 和 ReentrantLock 有什么区别? #### 两者都是可重入锁 @@ -781,7 +781,7 @@ public ReentrantLock(boolean fair) { JDK 中常用的锁(如 synchronized、ReentrantLock、ReentrantReadWriteLock)是可重入的,但并不是所有 Lock 实现都支持可重入,例如 StampedLock 就是不可重入的。 -在下面的代码中,`method1()` 和 `method2()`都被 `synchronized` 关键字修饰,`method1()`调用了`method2()`。 +在下面的代码中,`method1()` 和 `method2()` 都被 `synchronized` 关键字修饰,`method1()` 调用了 `method2()`。 ```java public class SynchronizedDemo { @@ -796,7 +796,7 @@ public class SynchronizedDemo { } ``` -由于 `synchronized`锁是可重入的,同一个线程在调用`method1()` 时可以直接获得当前对象的锁,执行 `method2()` 的时候可以再次获取这个对象的锁,不会产生死锁问题。假如`synchronized`是不可重入锁的话,由于该对象的锁已被当前线程所持有且无法释放,这就导致线程在执行 `method2()`时获取锁失败,会出现死锁问题。 +由于 `synchronized` 锁是可重入的,同一个线程在调用 `method1()` 时可以直接获得当前对象的锁,执行 `method2()` 的时候可以再次获取这个对象的锁,不会产生死锁问题。假如 `synchronized` 是不可重入锁的话,由于该对象的锁已被当前线程所持有且无法释放,这就导致线程在执行 `method2()` 时获取锁失败,会出现死锁问题。 #### synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API @@ -806,24 +806,24 @@ public class SynchronizedDemo { #### ReentrantLock 比 synchronized 增加了一些高级功能 -相比`synchronized`,`ReentrantLock`增加了一些高级功能。主要来说主要有三点: +相比 `synchronized`,`ReentrantLock` 增加了一些高级功能。主要来说主要有三点: -- **等待可中断** : `ReentrantLock`提供了一种能够中断等待锁的线程的机制,通过 `lock.lockInterruptibly()` 来实现这个机制。也就是说当前线程在等待获取锁的过程中,如果其他线程中断当前线程「 `interrupt()` 」,当前线程就会抛出 `InterruptedException` 异常,可以捕捉该异常进行相应处理。 -- **可实现公平锁** : `ReentrantLock`可以指定是公平锁还是非公平锁。而`synchronized`只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。`ReentrantLock`默认情况是非公平的,可以通过 `ReentrantLock`类的`ReentrantLock(boolean fair)`构造方法来指定是否是公平的。 +- **等待可中断** : `ReentrantLock` 提供了一种能够中断等待锁的线程的机制,通过 `lock.lockInterruptibly()` 来实现这个机制。也就是说当前线程在等待获取锁的过程中,如果其他线程中断当前线程「 `interrupt()` 」,当前线程就会抛出 `InterruptedException` 异常,可以捕捉该异常进行相应处理。 +- **可实现公平锁** : `ReentrantLock` 可以指定是公平锁还是非公平锁。而 `synchronized` 只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。`ReentrantLock` 默认情况是非公平的,可以通过 `ReentrantLock` 类的 `ReentrantLock(boolean fair)` 构造方法来指定是否是公平的。 - **通知机制更强大**:`ReentrantLock` 通过绑定多个 `Condition` 对象,可以实现分组唤醒和选择性通知。这解决了 `synchronized` 只能随机唤醒或全部唤醒的效率问题,为复杂的线程协作场景提供了强大的支持。 -- **支持超时** :`ReentrantLock` 提供了 `tryLock(timeout)` 的方法,可以指定等待获取锁的最长等待时间,如果超过了等待时间,就会获取锁失败,不会一直等待。 +- **支持超时**:`ReentrantLock` 提供了 `tryLock(timeout)` 的方法,可以指定等待获取锁的最长等待时间,如果超过了等待时间,就会获取锁失败,不会一直等待。 如果你想使用上述功能,那么选择 `ReentrantLock` 是一个不错的选择。 -关于 `Condition`接口的补充: +关于 `Condition` 接口的补充: -> `Condition`是 JDK1.5 之后才有的,它具有很好的灵活性,比如可以实现多路通知功能也就是在一个`Lock`对象中可以创建多个`Condition`实例(即对象监视器),**线程对象可以注册在指定的`Condition`中,从而可以有选择性的进行线程通知,在调度线程上更加灵活。 在使用`notify()/notifyAll()`方法进行通知时,被通知的线程是由 JVM 选择的,用`ReentrantLock`类结合`Condition`实例可以实现“选择性通知”** ,这个功能非常重要,而且是 `Condition` 接口默认提供的。而`synchronized`关键字就相当于整个 `Lock` 对象中只有一个`Condition`实例,所有的线程都注册在它一个身上。如果执行`notifyAll()`方法的话就会通知所有处于等待状态的线程,这样会造成很大的效率问题。而`Condition`实例的`signalAll()`方法,只会唤醒注册在该`Condition`实例中的所有等待线程。 +> `Condition` 是 JDK1.5 之后才有的,它具有很好的灵活性,比如可以实现多路通知功能也就是在一个 `Lock` 对象中可以创建多个 `Condition` 实例(即对象监视器),**线程对象可以注册在指定的 `Condition` 中,从而可以有选择性的进行线程通知,在调度线程上更加灵活。 在使用 `notify()/notifyAll()` 方法进行通知时,被通知的线程是由 JVM 选择的,用 `ReentrantLock` 类结合 `Condition` 实例可以实现“选择性通知”**,这个功能非常重要,而且是 `Condition` 接口默认提供的。而 `synchronized` 关键字就相当于整个 `Lock` 对象中只有一个 `Condition` 实例,所有的线程都注册在它一个身上。如果执行 `notifyAll()` 方法的话就会通知所有处于等待状态的线程,这样会造成很大的效率问题。而 `Condition` 实例的 `signalAll()` 方法,只会唤醒注册在该 `Condition` 实例中的所有等待线程。 关于 **等待可中断** 的补充: > `lockInterruptibly()` 会让获取锁的线程在阻塞等待的过程中可以响应中断,即当前线程在获取锁的时候,发现锁被其他线程持有,就会阻塞等待。 > -> 在阻塞等待的过程中,如果其他线程中断当前线程 `interrupt()` ,就会抛出 `InterruptedException` 异常,可以捕获该异常,做一些处理操作。 +> 在阻塞等待的过程中,如果其他线程中断当前线程 `interrupt()`,就会抛出 `InterruptedException` 异常,可以捕获该异常,做一些处理操作。 > > 为了更好理解这个方法,借用 Stack Overflow 上的一个案例,可以更好地理解 `lockInterruptibly()` 可以响应中断: > @@ -907,15 +907,15 @@ public class SynchronizedDemo { - `ReentrantLock#lock()` 也是不可中断的。 - **可中断锁**:线程在等待锁的过程中如果收到中断信号,会立即停止等待并抛出 `InterruptedException`,从而有机会进行取消或错误处理。 - `ReentrantLock#lockInterruptibly()` 实现了可中断锁。 - - `ReentrantLock#tryLock(long time, TimeUnit unit)` (带超时的尝试获取)也是可中断的。 + - `ReentrantLock#tryLock(long time, TimeUnit unit)`(带超时的尝试获取)也是可中断的。 ## ReentrantReadWriteLock -`ReentrantReadWriteLock` 在实际项目中使用的并不多,面试中也问的比较少,简单了解即可。JDK 1.8 引入了性能更好的读写锁 `StampedLock` 。 +`ReentrantReadWriteLock` 在实际项目中使用的并不多,面试中也问的比较少,简单了解即可。JDK 1.8 引入了性能更好的读写锁 `StampedLock`。 ### ReentrantReadWriteLock 是什么? -`ReentrantReadWriteLock` 实现了 `ReadWriteLock` ,是一个可重入的读写锁,既可以保证多个线程同时读的效率,同时又可以保证有写入操作时的线程安全。 +`ReentrantReadWriteLock` 实现了 `ReadWriteLock`,是一个可重入的读写锁,既可以保证多个线程同时读的效率,同时又可以保证有写入操作时的线程安全。 ```java public class ReentrantReadWriteLock @@ -930,7 +930,7 @@ public interface ReadWriteLock { - 一般锁进行并发控制的规则:读读互斥、读写互斥、写写互斥。 - 读写锁进行并发控制的规则:读读不互斥、读写互斥、写写互斥(只有读读不互斥)。 -`ReentrantReadWriteLock` 其实是两把锁,一把是 `WriteLock` (写锁),一把是 `ReadLock`(读锁) 。读锁是共享锁,写锁是独占锁。读锁可以被同时读,可以同时被多个线程持有,而写锁最多只能同时被一个线程持有。 +`ReentrantReadWriteLock` 其实是两把锁,一把是 `WriteLock`(写锁),一把是 `ReadLock`(读锁)。读锁是共享锁,写锁是独占锁。读锁可以被同时读,可以同时被多个线程持有,而写锁最多只能同时被一个线程持有。 和 `ReentrantLock` 一样,`ReentrantReadWriteLock` 底层也是基于 AQS 实现的。 @@ -958,7 +958,7 @@ public ReentrantReadWriteLock(boolean fair) { ### 线程持有读锁还能获取写锁吗? -- 在线程持有读锁的情况下,该线程不能取得写锁(因为获取写锁的时候,如果发现当前的读锁被占用,就马上获取失败,不管读锁是不是被当前线程持有)。 +- 在线程持有读锁的情况下,该线程不能取得写锁(因为获取写锁的时候,如果发现当前的读锁被占用,就马上获取失败,不管读锁是不是被当前线程持有)。 - 在线程持有写锁的情况下,该线程可以继续获取读锁(获取读锁时如果发现写锁被占用,只有写锁没有被当前线程占用的情况才会获取失败)。 读写锁的源码分析,推荐阅读 [聊聊 Java 的几把 JVM 级锁 - 阿里巴巴中间件](https://mp.weixin.qq.com/s/h3VIUyH9L0v14MrQJiiDbw) 这篇文章,写的很不错。 @@ -1003,7 +1003,7 @@ flowchart TB `StampedLock` 是 JDK 1.8 引入的性能更好的读写锁,不可重入且不支持条件变量 `Condition`。 -不同于一般的 `Lock` 类,`StampedLock` 并不是直接实现 `Lock`或 `ReadWriteLock`接口,而是基于 **CLH 锁** 独立实现的(AQS 也是基于这玩意)。 +不同于一般的 `Lock` 类,`StampedLock` 并不是直接实现 `Lock` 或 `ReadWriteLock` 接口,而是基于 **CLH 锁** 独立实现的(AQS 也是基于这玩意)。 ```java public class StampedLock implements java.io.Serializable { @@ -1013,10 +1013,10 @@ public class StampedLock implements java.io.Serializable { `StampedLock` 提供了三种模式的读写控制模式:读锁、写锁和乐观读。 - **写锁**:独占锁,一把锁只能被一个线程获得。当一个线程获取写锁后,其他请求读锁和写锁的线程必须等待。类似于 `ReentrantReadWriteLock` 的写锁,不过这里的写锁是不可重入的。 -- **读锁** (悲观读):共享锁,没有线程获取写锁的情况下,多个线程可以同时持有读锁。如果己经有线程持有写锁,则其他线程请求获取该读锁会被阻塞。类似于 `ReentrantReadWriteLock` 的读锁,不过这里的读锁是不可重入的。 +- **读锁**(悲观读):共享锁,没有线程获取写锁的情况下,多个线程可以同时持有读锁。如果己经有线程持有写锁,则其他线程请求获取该读锁会被阻塞。类似于 `ReentrantReadWriteLock` 的读锁,不过这里的读锁是不可重入的。 - **乐观读**:允许多个线程获取乐观读以及读锁。同时允许一个写线程获取写锁。 -另外,`StampedLock` 还支持这三种锁在一定条件下进行相互转换 。 +另外,`StampedLock` 还支持这三种锁在一定条件下进行相互转换。 ```java long tryConvertToWriteLock(long stamp){} @@ -1024,7 +1024,7 @@ long tryConvertToReadLock(long stamp){} long tryConvertToOptimisticRead(long stamp){} ``` -`StampedLock` 在获取锁的时候会返回一个 long 型的数据戳,该数据戳用于稍后的锁释放参数,如果返回的数据戳为 0 则表示锁获取失败。当前线程持有了锁再次获取锁还是会返回一个新的数据戳,这也是`StampedLock`不可重入的原因。 +`StampedLock` 在获取锁的时候会返回一个 long 型的数据戳,该数据戳用于稍后的锁释放参数,如果返回的数据戳为 0 则表示锁获取失败。当前线程持有了锁再次获取锁还是会返回一个新的数据戳,这也是 `StampedLock` 不可重入的原因。 ```java // 写锁 @@ -1050,19 +1050,19 @@ public long tryOptimisticRead() { ### StampedLock 的性能为什么更好? -相比于传统读写锁多出来的乐观读是`StampedLock`比 `ReadWriteLock` 性能更好的关键原因。`StampedLock` 的乐观读允许一个写线程获取写锁,所以不会导致所有写线程阻塞,也就是当读多写少的时候,写线程有机会获取写锁,减少了线程饥饿的问题,吞吐量大大提高。 +相比于传统读写锁多出来的乐观读是 `StampedLock` 比 `ReadWriteLock` 性能更好的关键原因。`StampedLock` 的乐观读允许一个写线程获取写锁,所以不会导致所有写线程阻塞,也就是当读多写少的时候,写线程有机会获取写锁,减少了线程饥饿的问题,吞吐量大大提高。 ### StampedLock 适合什么场景? -和 `ReentrantReadWriteLock` 一样,`StampedLock` 同样适合读多写少的业务场景,可以作为 `ReentrantReadWriteLock`的替代品,性能更好。 +和 `ReentrantReadWriteLock` 一样,`StampedLock` 同样适合读多写少的业务场景,可以作为 `ReentrantReadWriteLock` 的替代品,性能更好。 -不过,需要注意的是`StampedLock`不可重入,不支持条件变量 `Condition`,对中断操作支持也不友好(使用不当容易导致 CPU 飙升)。如果你需要用到 `ReentrantLock` 的一些高级性能,就不太建议使用 `StampedLock` 了。 +不过,需要注意的是 `StampedLock` 不可重入,不支持条件变量 `Condition`,对中断操作支持也不友好(使用不当容易导致 CPU 飙升)。如果你需要用到 `ReentrantLock` 的一些高级性能,就不太建议使用 `StampedLock` 了。 -另外,`StampedLock` 性能虽好,但使用起来相对比较麻烦,一旦使用不当,就会出现生产问题。强烈建议你在使用`StampedLock` 之前,看看 [StampedLock 官方文档中的案例](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html)。 +另外,`StampedLock` 性能虽好,但使用起来相对比较麻烦,一旦使用不当,就会出现生产问题。强烈建议你在使用 `StampedLock` 之前,看看 [StampedLock 官方文档中的案例](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/StampedLock.html)。 ### StampedLock 的底层原理了解吗? -`StampedLock` 不是直接实现 `Lock`或 `ReadWriteLock`接口,而是基于 **CLH 锁** 实现的(AQS 也是基于这玩意),CLH 锁是对自旋锁的一种改良,是一种隐式的链表队列。`StampedLock` 通过 CLH 队列进行线程的管理,通过同步状态值 `state` 来表示锁的状态和类型。 +`StampedLock` 不是直接实现 `Lock` 或 `ReadWriteLock` 接口,而是基于 **CLH 锁** 实现的(AQS 也是基于这玩意),CLH 锁是对自旋锁的一种改良,是一种隐式的链表队列。`StampedLock` 通过 CLH 队列进行线程的管理,通过同步状态值 `state` 来表示锁的状态和类型。 `StampedLock` 的原理和 AQS 原理比较类似,这里就不详细介绍了,感兴趣的可以看看下面这两篇文章: @@ -1073,7 +1073,7 @@ public long tryOptimisticRead() { ## Atomic 原子类 -Atomic 原子类部分的内容我单独写了一篇文章来总结:[Atomic 原子类总结](./atomic-classes.md) 。 +Atomic 原子类部分的内容我单独写了一篇文章来总结:[Atomic 原子类总结](./atomic-classes.md)。 ## 参考 diff --git a/docs/java/concurrent/java-concurrent-questions-03.md b/docs/java/concurrent/java-concurrent-questions-03.md index 8eb4e0a5db5..e5dab08a8eb 100644 --- a/docs/java/concurrent/java-concurrent-questions-03.md +++ b/docs/java/concurrent/java-concurrent-questions-03.md @@ -45,9 +45,9 @@ public class ThreadLocalExample { } ``` -### ⭐️ThreadLocal 原理了解吗? +### ⭐️ ThreadLocal 原理了解吗? -从 `Thread`类源代码入手。 +从 `Thread` 类源代码入手。 ```java public class Thread implements Runnable { @@ -61,9 +61,9 @@ public class Thread implements Runnable { } ``` -从上面`Thread`类 源代码可以看出`Thread` 类中有一个 `threadLocals` 和 一个 `inheritableThreadLocals` 变量,它们都是 `ThreadLocalMap` 类型的变量,我们可以把 `ThreadLocalMap` 理解为`ThreadLocal` 类实现的定制化的 `HashMap`。默认情况下这两个变量都是 null,只有当前线程调用 `ThreadLocal` 类的 `set`或`get`方法时才创建它们,实际上调用这两个方法的时候,我们调用的是`ThreadLocalMap`类对应的 `get()`、`set()`方法。 +从上面 `Thread` 类 源代码可以看出 `Thread` 类中有一个 `threadLocals` 和 一个 `inheritableThreadLocals` 变量,它们都是 `ThreadLocalMap` 类型的变量,我们可以把 `ThreadLocalMap` 理解为 `ThreadLocal` 类实现的定制化的 `HashMap`。默认情况下这两个变量都是 null,只有当前线程调用 `ThreadLocal` 类的 `set` 或 `get` 方法时才创建它们,实际上调用这两个方法的时候,我们调用的是 `ThreadLocalMap` 类对应的 `get()`、`set()` 方法。 -`ThreadLocal`类的`set()`方法 +`ThreadLocal` 类的 `set()` 方法 ```java public void set(T value) { @@ -82,9 +82,9 @@ ThreadLocalMap getMap(Thread t) { } ``` -通过上面这些内容,我们足以通过猜测得出结论:**最终的变量是放在了当前线程的 `ThreadLocalMap` 中,并不是存在 `ThreadLocal` 上,`ThreadLocal` 可以理解为只是`ThreadLocalMap`的封装,传递了变量值。** `ThrealLocal` 类中可以通过`Thread.currentThread()`获取到当前线程对象后,直接通过`getMap(Thread t)`可以访问到该线程的`ThreadLocalMap`对象。 +通过上面这些内容,我们足以通过猜测得出结论:**最终的变量是放在了当前线程的 `ThreadLocalMap` 中,并不是存在 `ThreadLocal` 上,`ThreadLocal` 可以理解为只是 `ThreadLocalMap` 的封装,传递了变量值。** `ThrealLocal` 类中可以通过 `Thread.currentThread()` 获取到当前线程对象后,直接通过 `getMap(Thread t)` 可以访问到该线程的 `ThreadLocalMap` 对象。 -**每个`Thread`中都具备一个`ThreadLocalMap`,而`ThreadLocalMap`可以存储以`ThreadLocal`为 key ,Object 对象为 value 的键值对。** +**每个 `Thread` 中都具备一个 `ThreadLocalMap`,而 `ThreadLocalMap` 可以存储以 `ThreadLocal` 为 key,Object 对象为 value 的键值对。** ```java ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { @@ -92,17 +92,17 @@ ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { } ``` -比如我们在同一个线程中声明了两个 `ThreadLocal` 对象的话, `Thread`内部都是使用仅有的那个`ThreadLocalMap` 存放数据的,`ThreadLocalMap`的 key 就是 `ThreadLocal`对象,value 就是 `ThreadLocal` 对象调用`set`方法设置的值。 +比如我们在同一个线程中声明了两个 `ThreadLocal` 对象的话, `Thread` 内部都是使用仅有的那个 `ThreadLocalMap` 存放数据的,`ThreadLocalMap` 的 key 就是 `ThreadLocal` 对象,value 就是 `ThreadLocal` 对象调用 `set` 方法设置的值。 `ThreadLocal` 数据结构如下图所示: ![ThreadLocal 数据结构](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadlocal-data-structure.png) -`ThreadLocalMap`是`ThreadLocal`的静态内部类。 +`ThreadLocalMap` 是 `ThreadLocal` 的静态内部类。 ![ThreadLocal内部类](https://oss.javaguide.cn/github/javaguide/java/concurrent/thread-local-inner-class.png) -### ⭐️ThreadLocal 内存泄露问题是怎么导致的? +### ⭐️ ThreadLocal 内存泄露问题是怎么导致的? `ThreadLocal` 内存泄漏的根本原因在于其内部实现机制。 @@ -122,7 +122,7 @@ public void set(T value) { } ``` -`ThreadLocalMap` 的 `set()` 和 `createMap()` 方法中,并没有直接存储 `ThreadLocal` 对象本身,而是使用 `ThreadLocal` 的哈希值计算数组索引,最终存储于类型为`static class Entry extends WeakReference>`的数组中。 +`ThreadLocalMap` 的 `set()` 和 `createMap()` 方法中,并没有直接存储 `ThreadLocal` 对象本身,而是使用 `ThreadLocal` 的哈希值计算数组索引,最终存储于类型为 `static class Entry extends WeakReference>` 的数组中。 ```java int i = key.threadLocalHashCode & (len-1); @@ -234,7 +234,7 @@ public void processRequest(HttpServletRequest request) { 2. **`try-finally` 保证 `remove()` 一定被执行**:即使业务逻辑抛出异常,`finally` 块也能确保 `ThreadLocal` 被清理。 3. **在使用完毕后立即清理,而不是在下次使用前设置**:在使用前 `set()` 虽然可以覆盖旧值解决脏数据问题,但无法解决上一次任务遗留 value 的内存占用问题。只有在用完后 `remove()`,才能同时避免内存泄漏和数据污染。 -### ⭐️如何跨线程传递 ThreadLocal 的值? +### ⭐️ 如何跨线程传递 ThreadLocal 的值? **为什么 ThreadLocal 在异步场景下会失效?** @@ -254,8 +254,8 @@ Thread → ThreadLocalMap → Entry(ThreadLocal, value) 为了解决这个问题,业界有两套主流的解决方案,一套是 JDK 原生的,另一套是阿里巴巴开源的。 -1. `InheritableThreadLocal` :JDK1.2 提供的一个类,继承自 `ThreadLocal` 。使用 `InheritableThreadLocal` 时,会在创建子线程时,令子线程继承父线程中的 `ThreadLocal` 值,但是无法支持线程池场景下的 `ThreadLocal` 值传递。 -2. `TransmittableThreadLocal` : `TransmittableThreadLocal` (简称 TTL) 是阿里巴巴开源的工具类,继承并加强了`InheritableThreadLocal`类,可以在线程池的场景下支持 `ThreadLocal` 值传递。项目地址:。 +1. `InheritableThreadLocal`:JDK1.2 提供的一个类,继承自 `ThreadLocal`。使用 `InheritableThreadLocal` 时,会在创建子线程时,令子线程继承父线程中的 `ThreadLocal` 值,但是无法支持线程池场景下的 `ThreadLocal` 值传递。 +2. `TransmittableThreadLocal`: `TransmittableThreadLocal`(简称 TTL) 是阿里巴巴开源的工具类,继承并加强了 `InheritableThreadLocal` 类,可以在线程池的场景下支持 `ThreadLocal` 值传递。项目地址:。 #### InheritableThreadLocal 原理 @@ -263,7 +263,7 @@ Thread → ThreadLocalMap → Entry(ThreadLocal, value) **`InheritableThreadLocal` 的值存储在哪里?** -在 `Thread` 类中添加了一个新的 `ThreadLocalMap` ,命名为 `inheritableThreadLocals` ,该变量用于存储需要跨线程传递的 `ThreadLocal` 值。如下: +在 `Thread` 类中添加了一个新的 `ThreadLocalMap`,命名为 `inheritableThreadLocals`,该变量用于存储需要跨线程传递的 `ThreadLocal` 值。如下: ```JAVA class Thread implements Runnable { @@ -292,7 +292,7 @@ private void init(/* ... */) { 这个方案的缺陷在于它的**一次性**,也就是它只在线程创建时发生一次复制。然而,现在的开发中,我们会大量使用线程池,但线程池里的线程是被复用的。 -想象一下,任务A在线程1中执行,把它的 `ThreadLocal` 值传给了线程池里的子线程2。任务A结束后,线程1去休息了。接着,任务B来了,它在线程3中执行,线程池又复用了刚才那个子线程2来执行任务B的一部分。此时,子线程2的`ThreadLocal`里还残留着任务A传给它的脏数据,而任务B(在线程3里)的上下文却完全没有传递过来。这就导致了数据污染和上下文丢失。 +想象一下,任务 A 在线程 1 中执行,把它的 `ThreadLocal` 值传给了线程池里的子线程 2。任务 A 结束后,线程 1 去休息了。接着,任务 B 来了,它在线程 3 中执行,线程池又复用了刚才那个子线程 2 来执行任务 B 的一部分。此时,子线程 2 的 `ThreadLocal` 里还残留着任务 A 传给它的脏数据,而任务 B(在线程 3 里)的上下文却完全没有传递过来。这就导致了数据污染和上下文丢失。 #### TransmittableThreadLocal 原理 @@ -453,18 +453,18 @@ java -javaagent:path/to/transmittable-thread-local-2.x.y.jar \ 为了解决这个问题,主要有两种方案: -1. **JDK的 InheritableThreadLocal**:它会在**创建子线程**的时候,把父线程的值**复制**一份给子线程。但它的问题是,在**线程池**场景下会失效。因为线程池会**复用**线程,这会导致线程拿到的可能是上一个任务传下来的**脏数据**。 +1. **JDK 的 InheritableThreadLocal**:它会在**创建子线程**的时候,把父线程的值**复制**一份给子线程。但它的问题是,在**线程池**场景下会失效。因为线程池会**复用**线程,这会导致线程拿到的可能是上一个任务传下来的**脏数据**。 2. **阿里的 TransmittableThreadLocal (TTL)**:这是我们项目里用的方案,它专门解决线程池的问题。它的原理是,在**提交任务**到线程池时,它会把父线程的 `ThreadLocal` 值**捕获**下来,和任务**绑定**在一起。等线程池里的某个线程要执行这个任务时,它再把捕获的值**设置**到这个线程上,任务执行完再**清理**掉。 -简单说,**InheritableThreadLocal是跟线程绑定的,只在创建时有效;而TTL是跟任务绑定的,完美支持线程池。** +简单说,**InheritableThreadLocal 是跟线程绑定的,只在创建时有效;而 TTL 是跟任务绑定的,完美支持线程池。** ## 线程池 -### 什么是线程池? +### 什么是线程池? 顾名思义,线程池就是管理一系列线程的资源池。当有任务要处理时,直接从线程池中获取线程来处理,处理完之后线程并不会立即被销毁,而是等待下一个任务。 -### ⭐️为什么要用线程池? +### ⭐️ 为什么要用线程池? 池化技术想必大家已经屡见不鲜了,线程池、数据库连接池、HTTP 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗,提高对资源的利用率。 @@ -478,26 +478,26 @@ java -javaagent:path/to/transmittable-thread-local-2.x.y.jar \ 在 Java 中,创建线程池主要有两种方式: -**方式一:通过 `ThreadPoolExecutor` 构造函数直接创建 (推荐)** +**方式一:通过 `ThreadPoolExecutor` 构造函数直接创建(推荐)** ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpoolexecutor-construtors.png) 这是最推荐的方式,因为它允许开发者明确指定线程池的核心参数,对线程池的运行行为有更精细的控制,从而避免资源耗尽的风险。 -**方式二:通过 `Executors` 工具类创建 (不推荐用于生产环境)** +**方式二:通过 `Executors` 工具类创建(不推荐用于生产环境)** -`Executors`工具类提供的创建线程池的方法如下图所示: +`Executors` 工具类提供的创建线程池的方法如下图所示: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/executors-new-thread-pool-methods.png) -可以看出,通过`Executors`工具类可以创建多种类型的线程池,包括: +可以看出,通过 `Executors` 工具类可以创建多种类型的线程池,包括: - `FixedThreadPool`:固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时,线程池中若有空闲线程,则立即执行。若没有,则新的任务会被暂存在一个任务队列中,待有线程空闲时,便处理在任务队列中的任务。 - `SingleThreadExecutor`: 只有一个线程的线程池。若多余一个任务被提交到该线程池,任务会被保存在一个任务队列中,待线程空闲,按先入先出的顺序执行队列中的任务。 - `CachedThreadPool`: 可根据实际情况调整线程数量的线程池。线程池的线程数量不确定,但若有空闲线程可以复用,则会优先使用可复用的线程。若所有线程均在工作,又有新的任务提交,则会创建新的线程处理任务。所有线程在当前任务执行完毕后,将返回线程池进行复用。 - `ScheduledThreadPool`:给定的延迟后运行任务或者定期执行任务的线程池。 -### ⭐️为什么不推荐使用内置线程池? +### ⭐️ 为什么不推荐使用内置线程池? 在《阿里巴巴 Java 开发手册》“并发处理”这一章节,明确指出线程资源必须通过线程池提供,不允许在应用中自行显式创建线程。 @@ -507,11 +507,11 @@ java -javaagent:path/to/transmittable-thread-local-2.x.y.jar \ 另外,《阿里巴巴 Java 开发手册》中强制线程池不允许使用 `Executors` 去创建,而是通过 `ThreadPoolExecutor` 构造函数的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险 -`Executors` 返回线程池对象的弊端如下(后文会详细介绍到): +`Executors` 返回线程池对象的弊端如下(后文会详细介绍到): - `FixedThreadPool` 和 `SingleThreadExecutor`:使用的是阻塞队列 `LinkedBlockingQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可以看作是无界的,可能堆积大量的请求,从而导致 OOM。 -- `CachedThreadPool`:使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE` ,如果任务数量过多且执行速度较慢,可能会创建大量的线程,从而导致 OOM。 -- `ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`:使用的无界的延迟阻塞队列`DelayedWorkQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求,从而导致 OOM。 +- `CachedThreadPool`:使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE`,如果任务数量过多且执行速度较慢,可能会创建大量的线程,从而导致 OOM。 +- `ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`:使用的无界的延迟阻塞队列 `DelayedWorkQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求,从而导致 OOM。 ```java public static ExecutorService newFixedThreadPool(int nThreads) { @@ -543,7 +543,7 @@ public ScheduledThreadPoolExecutor(int corePoolSize) { } ``` -### ⭐️线程池常见参数有哪些?如何解释? +### ⭐️ 线程池常见参数有哪些?如何解释? ```java /** @@ -579,9 +579,9 @@ public ScheduledThreadPoolExecutor(int corePoolSize) { - `maximumPoolSize` : 任务队列中存放的任务达到队列容量的时候,当前可以同时运行的线程数量变为最大线程数。 - `workQueue`: 新任务来的时候会先判断当前运行的线程数量是否达到核心线程数,如果达到的话,新任务就会被存放在队列中。 -`ThreadPoolExecutor`其他常见参数 : +`ThreadPoolExecutor` 其他常见参数 : -- `keepAliveTime`:当线程池中的线程数量大于 `corePoolSize` ,即有非核心线程(线程池中核心线程以外的线程)时,这些非核心线程空闲后不会立即销毁,而是会等待,直到等待的时间超过了 `keepAliveTime`才会被回收销毁。 +- `keepAliveTime`:当线程池中的线程数量大于 `corePoolSize`,即有非核心线程(线程池中核心线程以外的线程)时,这些非核心线程空闲后不会立即销毁,而是会等待,直到等待的时间超过了 `keepAliveTime` 才会被回收销毁。 - `unit` : `keepAliveTime` 参数的时间单位。 - `threadFactory` :executor 创建新线程的时候会用到。 - `handler` :拒绝策略(后面会单独详细介绍一下)。 @@ -615,21 +615,21 @@ public void allowCoreThreadTimeOut(boolean value) { 核心线程空闲时,其状态分为以下两种情况: -- **设置了核心线程的存活时间** :核心线程在空闲时,会处于 `WAITING` 状态,等待获取任务。如果阻塞等待的时间超过了核心线程存活时间,则该线程会退出工作,将该线程从线程池的工作线程集合中移除,线程状态变为 `TERMINATED` 状态。 -- **没有设置核心线程的存活时间** :核心线程在空闲时,会一直处于 `WAITING` 状态,等待获取任务,核心线程会一直存活在线程池中。 +- **设置了核心线程的存活时间**:核心线程在空闲时,会处于 `WAITING` 状态,等待获取任务。如果阻塞等待的时间超过了核心线程存活时间,则该线程会退出工作,将该线程从线程池的工作线程集合中移除,线程状态变为 `TERMINATED` 状态。 +- **没有设置核心线程的存活时间**:核心线程在空闲时,会一直处于 `WAITING` 状态,等待获取任务,核心线程会一直存活在线程池中。 当队列中有可用任务时,会唤醒被阻塞的线程,线程的状态会由 `WAITING` 状态变为 `RUNNABLE` 状态,之后去执行对应任务。 接下来通过相关源码,了解一下线程池内部是如何做的。 -线程在线程池内部被抽象为了 `Worker` ,当 `Worker` 被启动之后,会不断去任务队列中获取任务。 +线程在线程池内部被抽象为了 `Worker`,当 `Worker` 被启动之后,会不断去任务队列中获取任务。 -在获取任务的时候,会根据 `timed` 值来决定从任务队列( `BlockingQueue` )获取任务的行为。 +在获取任务的时候,会根据 `timed` 值来决定从任务队列(`BlockingQueue`)获取任务的行为。 -如果「设置了核心线程的存活时间」或者「线程数量超过了核心线程数量」,则将 `timed` 标记为 `true` ,表明获取任务时需要使用 `poll()` 指定超时时间。 +如果「设置了核心线程的存活时间」或者「线程数量超过了核心线程数量」,则将 `timed` 标记为 `true`,表明获取任务时需要使用 `poll()` 指定超时时间。 -- `timed == true` :使用 `poll(timeout, unit)` 来获取任务。使用 `poll(timeout, unit)` 方法获取任务超时的话,则当前线程会退出执行( `TERMINATED` ),该线程从线程池中被移除。 -- `timed == false` :使用 `take()` 来获取任务。使用 `take()` 方法获取任务会让当前线程一直阻塞等待(`WAITING`)。 +- `timed == true`:使用 `poll(timeout, unit)` 来获取任务。使用 `poll(timeout, unit)` 方法获取任务超时的话,则当前线程会退出执行(`TERMINATED`),该线程从线程池中被移除。 +- `timed == false`:使用 `take()` 来获取任务。使用 `take()` 方法获取任务会让当前线程一直阻塞等待(`WAITING`)。 源码如下: @@ -668,16 +668,16 @@ private Runnable getTask() { } ``` -### ⭐️线程池的拒绝策略有哪些? +### ⭐️ 线程池的拒绝策略有哪些? 如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时,`ThreadPoolExecutor` 定义一些策略: -- `ThreadPoolExecutor.AbortPolicy`:抛出 `RejectedExecutionException`来拒绝新任务的处理。 -- `ThreadPoolExecutor.CallerRunsPolicy`:调用执行者自己的线程运行任务,也就是直接在调用`execute`方法的线程中运行(`run`)被拒绝的任务,如果执行程序已关闭,则会丢弃该任务。因此这种策略会降低对于新任务提交速度,影响程序的整体性能。如果你的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话,你可以选择这个策略。 +- `ThreadPoolExecutor.AbortPolicy`:抛出 `RejectedExecutionException` 来拒绝新任务的处理。 +- `ThreadPoolExecutor.CallerRunsPolicy`:调用执行者自己的线程运行任务,也就是直接在调用 `execute` 方法的线程中运行(`run`)被拒绝的任务,如果执行程序已关闭,则会丢弃该任务。因此这种策略会降低对于新任务提交速度,影响程序的整体性能。如果你的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话,你可以选择这个策略。 - `ThreadPoolExecutor.DiscardPolicy`:不处理新任务,直接丢弃掉。 - `ThreadPoolExecutor.DiscardOldestPolicy`:此策略将丢弃最早的未处理的任务请求。 -举个例子:Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候,当我们不指定 `RejectedExecutionHandler` 拒绝策略来配置线程池的时候,默认使用的是 `AbortPolicy`。在这种拒绝策略下,如果队列满了,`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 异常来拒绝新来的任务 ,这代表你将丢失对这个任务的处理。如果不想丢弃任务的话,可以使用`CallerRunsPolicy`。`CallerRunsPolicy` 和其他的几个策略不同,它既不会抛弃任务,也不会抛出异常,而是将任务回退给调用者,使用调用者的线程来执行任务。 +举个例子:Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候,当我们不指定 `RejectedExecutionHandler` 拒绝策略来配置线程池的时候,默认使用的是 `AbortPolicy`。在这种拒绝策略下,如果队列满了,`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 异常来拒绝新来的任务,这代表你将丢失对这个任务的处理。如果不想丢弃任务的话,可以使用 `CallerRunsPolicy`。`CallerRunsPolicy` 和其他的几个策略不同,它既不会抛弃任务,也不会抛出异常,而是将任务回退给调用者,使用调用者的线程来执行任务。 ```java public static class CallerRunsPolicy implements RejectedExecutionHandler { @@ -695,9 +695,9 @@ public static class CallerRunsPolicy implements RejectedExecutionHandler { ### 如果不允许丢弃任务,应该选择哪个拒绝策略? -根据上面对线程池拒绝策略的介绍,相信大家很容易能够得出答案是:`CallerRunsPolicy` 。 +根据上面对线程池拒绝策略的介绍,相信大家很容易能够得出答案是:`CallerRunsPolicy`。 -这里我们再来结合`CallerRunsPolicy` 的源码来看看: +这里我们再来结合 `CallerRunsPolicy` 的源码来看看: ```java public static class CallerRunsPolicy implements RejectedExecutionHandler { @@ -715,15 +715,15 @@ public static class CallerRunsPolicy implements RejectedExecutionHandler { } ``` -从源码可以看出,只要当前程序不关闭就会使用执行`execute`方法的线程执行该任务。 +从源码可以看出,只要当前程序不关闭就会使用执行 `execute` 方法的线程执行该任务。 ### CallerRunsPolicy 拒绝策略有什么风险?如何解决? 我们上面也提到了:如果想要保证任何一个任务请求都要被执行的话,那选择 `CallerRunsPolicy` 拒绝策略更合适一些。 -不过,如果走到`CallerRunsPolicy`的任务是个非常耗时的任务,且处理提交任务的线程是主线程,可能会导致主线程阻塞,影响程序的正常运行。 +不过,如果走到 `CallerRunsPolicy` 的任务是个非常耗时的任务,且处理提交任务的线程是主线程,可能会导致主线程阻塞,影响程序的正常运行。 -这里简单举一个例子,该线程池限定了最大线程数为 2,阻塞队列大小为 1(这意味着第 4 个任务就会走到拒绝策略),`ThreadUtil`为 Hutool 提供的工具类: +这里简单举一个例子,该线程池限定了最大线程数为 2,阻塞队列大小为 1(这意味着第 4 个任务就会走到拒绝策略),`ThreadUtil` 为 Hutool 提供的工具类: ```java public class ThreadPoolTest { @@ -787,11 +787,11 @@ public class ThreadPoolTest { 18:21:48.219 INFO [pool-1-thread-2] c.j.concurrent.ThreadPoolTest - 核心线程执行第五个任务 ``` -从输出结果可以看出,因为`CallerRunsPolicy`这个拒绝策略,导致耗时的任务用了主线程执行,导致线程池阻塞,进而导致后续任务无法及时执行,严重的情况下很可能导致 OOM。 +从输出结果可以看出,因为 `CallerRunsPolicy` 这个拒绝策略,导致耗时的任务用了主线程执行,导致线程池阻塞,进而导致后续任务无法及时执行,严重的情况下很可能导致 OOM。 -我们从问题的本质入手,调用者采用`CallerRunsPolicy`是希望所有的任务都能够被执行,暂时无法处理的任务又被保存在阻塞队列`BlockingQueue`中。这样的话,在内存允许的情况下,我们可以增加阻塞队列`BlockingQueue`的大小并调整堆内存以容纳更多的任务,确保任务能够被准确执行。 +我们从问题的本质入手,调用者采用 `CallerRunsPolicy` 是希望所有的任务都能够被执行,暂时无法处理的任务又被保存在阻塞队列 `BlockingQueue` 中。这样的话,在内存允许的情况下,我们可以增加阻塞队列 `BlockingQueue` 的大小并调整堆内存以容纳更多的任务,确保任务能够被准确执行。 -为了充分利用 CPU,我们还可以调整线程池的`maximumPoolSize` (最大线程数)参数,这样可以提高任务处理速度,避免累计在 `BlockingQueue`的任务过多导致内存用完。 +为了充分利用 CPU,我们还可以调整线程池的 `maximumPoolSize`(最大线程数)参数,这样可以提高任务处理速度,避免累计在 `BlockingQueue` 的任务过多导致内存用完。 ![调整阻塞队列大小和最大线程数](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpool-reject-2-threadpool-reject-01.png) @@ -805,8 +805,8 @@ public class ThreadPoolTest { 这里以方案一为例,简单介绍一下实现逻辑: -1. 实现`RejectedExecutionHandler`接口自定义拒绝策略,自定义拒绝策略负责将线程池暂时无法处理(此时阻塞队列已满)的任务入库(保存到 MySQL 中)。注意:线程池暂时无法处理的任务会先被放在阻塞队列中,阻塞队列满了才会触发拒绝策略。 -2. 继承`BlockingQueue`实现一个混合式阻塞队列,该队列包含 JDK 自带的`ArrayBlockingQueue`。另外,该混合式阻塞队列需要修改取任务处理的逻辑,也就是重写`take()`方法,取任务时优先从数据库中读取最早的任务,数据库中无任务时再从 `ArrayBlockingQueue`中去取任务。 +1. 实现 `RejectedExecutionHandler` 接口自定义拒绝策略,自定义拒绝策略负责将线程池暂时无法处理(此时阻塞队列已满)的任务入库(保存到 MySQL 中)。注意:线程池暂时无法处理的任务会先被放在阻塞队列中,阻塞队列满了才会触发拒绝策略。 +2. 继承 `BlockingQueue` 实现一个混合式阻塞队列,该队列包含 JDK 自带的 `ArrayBlockingQueue`。另外,该混合式阻塞队列需要修改取任务处理的逻辑,也就是重写 `take()` 方法,取任务时优先从数据库中读取最早的任务,数据库中无任务时再从 `ArrayBlockingQueue` 中去取任务。 ![将一部分任务保存到MySQL中](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpool-reject-2-threadpool-reject-02.png) @@ -855,19 +855,19 @@ new RejectedExecutionHandler() { 不同的线程池会选用不同的阻塞队列,我们可以结合内置线程池来分析。 -- 容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界阻塞队列):`FixedThreadPool` 和 `SingleThreadExecutor` 。`FixedThreadPool`最多只能创建核心线程数的线程(核心线程数和最大线程数相等),`SingleThreadExecutor`只能创建一个线程(核心线程数和最大线程数都是 1),二者的任务队列永远不会被放满。 -- `SynchronousQueue`(同步队列):`CachedThreadPool` 。`SynchronousQueue` 没有容量,不存储元素,目的是保证对于提交的任务,如果有空闲线程,则使用空闲线程来处理;否则新建一个线程来处理任务。也就是说,`CachedThreadPool` 的最大线程数是 `Integer.MAX_VALUE` ,可以理解为线程数是可以无限扩展的,可能会创建大量线程,从而导致 OOM。 -- `DelayedWorkQueue`(延迟队列):`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor` 。`DelayedWorkQueue` 的内部元素并不是按照放入的时间排序,而是会按照延迟的时间长短对任务进行排序,内部采用的是“堆”的数据结构,可以保证每次出队的任务都是当前队列中执行时间最靠前的。`DelayedWorkQueue` 是一个无界队列。其底层虽然是数组,但当数组容量不足时,它会自动进行扩容,因此队列永远不会被填满。当任务不断提交时,它们会全部被添加到队列中。这意味着线程池的线程数量永远不会超过其核心线程数,最大线程数参数对于使用该队列的线程池来说是无效的。 +- 容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界阻塞队列):`FixedThreadPool` 和 `SingleThreadExecutor`。`FixedThreadPool` 最多只能创建核心线程数的线程(核心线程数和最大线程数相等),`SingleThreadExecutor` 只能创建一个线程(核心线程数和最大线程数都是 1),二者的任务队列永远不会被放满。 +- `SynchronousQueue`(同步队列):`CachedThreadPool`。`SynchronousQueue` 没有容量,不存储元素,目的是保证对于提交的任务,如果有空闲线程,则使用空闲线程来处理;否则新建一个线程来处理任务。也就是说,`CachedThreadPool` 的最大线程数是 `Integer.MAX_VALUE`,可以理解为线程数是可以无限扩展的,可能会创建大量线程,从而导致 OOM。 +- `DelayedWorkQueue`(延迟队列):`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`。`DelayedWorkQueue` 的内部元素并不是按照放入的时间排序,而是会按照延迟的时间长短对任务进行排序,内部采用的是“堆”的数据结构,可以保证每次出队的任务都是当前队列中执行时间最靠前的。`DelayedWorkQueue` 是一个无界队列。其底层虽然是数组,但当数组容量不足时,它会自动进行扩容,因此队列永远不会被填满。当任务不断提交时,它们会全部被添加到队列中。这意味着线程池的线程数量永远不会超过其核心线程数,最大线程数参数对于使用该队列的线程池来说是无效的。 - `ArrayBlockingQueue`(有界阻塞队列):底层由数组实现,容量一旦创建,就不能修改。 -### ⭐️线程池处理任务的流程了解吗? +### ⭐️ 线程池处理任务的流程了解吗? ![图解线程池实现原理](https://oss.javaguide.cn/github/javaguide/java/concurrent/thread-pool-principle.png) 1. 如果当前运行的线程数小于核心线程数,那么就会新建一个线程来执行任务。 2. 如果当前运行的线程数等于或大于核心线程数,但是小于最大线程数,那么就把该任务放入到任务队列里等待执行。 3. 如果向任务队列投放任务失败(任务队列已经满了),但是当前运行的线程数是小于最大线程数的,就新建一个线程来执行任务。 -4. 如果当前运行的线程数已经等同于最大线程数了,新建线程将会使当前运行的线程超出最大线程数,那么当前任务会被拒绝,拒绝策略会调用`RejectedExecutionHandler.rejectedExecution()`方法。 +4. 如果当前运行的线程数已经等同于最大线程数了,新建线程将会使当前运行的线程超出最大线程数,那么当前任务会被拒绝,拒绝策略会调用 `RejectedExecutionHandler.rejectedExecution()` 方法。 再提一个有意思的小问题:**线程池在提交任务前,可以提前创建线程吗?** @@ -876,20 +876,20 @@ new RejectedExecutionHandler() { - `prestartCoreThread()`:启动一个线程,等待任务,如果已达到核心线程数,这个方法返回 false,否则返回 true; - `prestartAllCoreThreads()`:启动所有的核心线程,并返回启动成功的核心线程数。 -### ⭐️线程池中线程异常后,销毁还是复用? +### ⭐️ 线程池中线程异常后,销毁还是复用? 直接说结论,需要分两种情况: -- **使用`execute()`提交任务**:当任务通过`execute()`提交到线程池并在执行过程中抛出异常时,如果这个异常没有在任务内被捕获,那么该异常会导致当前线程终止,并且异常会被打印到控制台或日志文件中。线程池会检测到这种线程终止,并创建一个新线程来替换它,从而保持配置的线程数不变。 -- **使用`submit()`提交任务**:对于通过`submit()`提交的任务,如果在任务执行中发生异常,这个异常不会直接打印出来。相反,异常会被封装在由`submit()`返回的`Future`对象中。当调用`Future.get()`方法时,可以捕获到一个`ExecutionException`。在这种情况下,线程不会因为异常而终止,它会继续存在于线程池中,准备执行后续的任务。 +- **使用 `execute()` 提交任务**:当任务通过 `execute()` 提交到线程池并在执行过程中抛出异常时,如果这个异常没有在任务内被捕获,那么该异常会导致当前线程终止,并且异常会被打印到控制台或日志文件中。线程池会检测到这种线程终止,并创建一个新线程来替换它,从而保持配置的线程数不变。 +- **使用 `submit()` 提交任务**:对于通过 `submit()` 提交的任务,如果在任务执行中发生异常,这个异常不会直接打印出来。相反,异常会被封装在由 `submit()` 返回的 `Future` 对象中。当调用 `Future.get()` 方法时,可以捕获到一个 `ExecutionException`。在这种情况下,线程不会因为异常而终止,它会继续存在于线程池中,准备执行后续的任务。 -简单来说:使用`execute()`时,未捕获异常导致线程终止,线程池创建新线程替代;使用`submit()`时,异常被封装在`Future`中,线程继续复用。 +简单来说:使用 `execute()` 时,未捕获异常导致线程终止,线程池创建新线程替代;使用 `submit()` 时,异常被封装在 `Future` 中,线程继续复用。 -这种设计允许`submit()`提供更灵活的错误处理机制,因为它允许调用者决定如何处理异常,而`execute()`则适用于那些不需要关注执行结果的场景。 +这种设计允许 `submit()` 提供更灵活的错误处理机制,因为它允许调用者决定如何处理异常,而 `execute()` 则适用于那些不需要关注执行结果的场景。 具体的源码分析可以参考这篇:[线程池中线程异常后:销毁还是复用? - 京东技术](https://mp.weixin.qq.com/s/9ODjdUU-EwQFF5PrnzOGfw)。 -### ⭐️如何给线程池命名? +### ⭐️ 如何给线程池命名? 初始化线程池的时候需要显示命名(设置线程池名称前缀),有利于定位问题。 @@ -976,7 +976,7 @@ CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内 公式也只是参考,具体还是要根据项目实际线上运行情况来动态调整。我在后面介绍的美团的线程池参数动态配置这种方案就非常不错,很实用! -### ⭐️如何动态修改线程池的参数? +### ⭐️ 如何动态修改线程池的参数? 美团技术团队在[《Java 线程池实现原理及其在美团业务中的实践》](https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html)这篇文章中介绍到对线程池参数实现可自定义配置的思路和方法。 @@ -994,9 +994,9 @@ CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内 ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpoolexecutor-methods.png) -格外需要注意的是`corePoolSize`, 程序运行期间的时候,我们调用 `setCorePoolSize()`这个方法的话,线程池会首先判断当前工作线程数是否大于`corePoolSize`,如果大于的话就会回收工作线程。 +格外需要注意的是 `corePoolSize`, 程序运行期间的时候,我们调用 `setCorePoolSize()` 这个方法的话,线程池会首先判断当前工作线程数是否大于 `corePoolSize`,如果大于的话就会回收工作线程。 -另外,你也看到了上面并没有动态指定队列长度的方法,美团的方式是自定义了一个叫做 `ResizableCapacityLinkedBlockIngQueue` 的队列(主要就是把`LinkedBlockingQueue`的 capacity 字段的 final 关键字修饰给去掉了,让它变为可变的)。 +另外,你也看到了上面并没有动态指定队列长度的方法,美团的方式是自定义了一个叫做 `ResizableCapacityLinkedBlockIngQueue` 的队列(主要就是把 `LinkedBlockingQueue` 的 capacity 字段的 final 关键字修饰给去掉了,让它变为可变的)。 最终实现的可动态修改线程池参数效果如下。👏👏👏 @@ -1011,13 +1011,13 @@ CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内 - **[Hippo4j](https://github.com/opengoofy/hippo4j)**:异步线程池框架,支持线程池动态变更&监控&报警,无需修改代码轻松引入。支持多种使用模式,轻松引入,致力于提高系统运行保障能力。 - **[Dynamic TP](https://github.com/dromara/dynamic-tp)**:轻量级动态线程池,内置监控告警功能,集成三方中间件线程池管理,基于主流配置中心(已支持 Nacos、Apollo,Zookeeper、Consul、Etcd,可通过 SPI 自定义实现)。 -### ⭐️如何设计一个能够根据任务的优先级来执行的线程池? +### ⭐️ 如何设计一个能够根据任务的优先级来执行的线程池? 这是一个常见的面试问题,本质其实还是在考察求职者对于线程池以及阻塞队列的掌握。 -我们上面也提到了,不同的线程池会选用不同的阻塞队列作为任务队列,比如`FixedThreadPool` 使用的是`LinkedBlockingQueue`(有界队列),默认构造器初始的队列长度为 `Integer.MAX_VALUE` ,由于队列永远不会被放满,因此`FixedThreadPool`最多只能创建核心线程数的线程。 +我们上面也提到了,不同的线程池会选用不同的阻塞队列作为任务队列,比如 `FixedThreadPool` 使用的是 `LinkedBlockingQueue`(有界队列),默认构造器初始的队列长度为 `Integer.MAX_VALUE`,由于队列永远不会被放满,因此 `FixedThreadPool` 最多只能创建核心线程数的线程。 -假如我们需要实现一个优先级任务线程池的话,那可以考虑使用 `PriorityBlockingQueue` (优先级阻塞队列)作为任务队列(`ThreadPoolExecutor` 的构造函数有一个 `workQueue` 参数可以传入任务队列)。 +假如我们需要实现一个优先级任务线程池的话,那可以考虑使用 `PriorityBlockingQueue`(优先级阻塞队列)作为任务队列(`ThreadPoolExecutor` 的构造函数有一个 `workQueue` 参数可以传入任务队列)。 ![ThreadPoolExecutor构造函数](https://oss.javaguide.cn/github/javaguide/java/concurrent/common-parameters-of-threadpool-workqueue.jpg) @@ -1026,7 +1026,7 @@ CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内 要想让 `PriorityBlockingQueue` 实现对任务的排序,传入其中的任务必须是具备排序能力的,方式有两种: 1. 提交到线程池的任务实现 `Comparable` 接口,并重写 `compareTo` 方法来指定任务之间的优先级比较规则。 -2. 创建 `PriorityBlockingQueue` 时传入一个 `Comparator` 对象来指定任务之间的排序规则(推荐)。 +2. 创建 `PriorityBlockingQueue` 时传入一个 `Comparator` 对象来指定任务之间的排序规则(推荐)。 不过,这存在一些风险和问题,比如: @@ -1034,7 +1034,7 @@ CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内 - 可能会导致饥饿问题,即低优先级的任务长时间得不到执行。 - 由于需要对队列中的元素进行排序操作以及保证线程安全(并发控制采用的是可重入锁 `ReentrantLock`),因此会降低性能。 -对于 OOM 这个问题的解决比较简单粗暴,就是继承`PriorityBlockingQueue` 并重写一下 `offer` 方法(入队)的逻辑,当插入的元素数量超过指定值就返回 false 。 +对于 OOM 这个问题的解决比较简单粗暴,就是继承 `PriorityBlockingQueue` 并重写一下 `offer` 方法(入队)的逻辑,当插入的元素数量超过指定值就返回 false。 饥饿问题这个可以通过优化设计来解决(比较麻烦),比如等待时间过长的任务会被移除并重新添加到队列中,但是优先级会被提升。 @@ -1085,18 +1085,18 @@ public interface Future { 我们可以通过 `FutureTask` 来理解 `Callable` 和 `Future` 之间的关系。 -`FutureTask` 提供了 `Future` 接口的基本实现,常用来封装 `Callable` 和 `Runnable`,具有取消任务、查看任务是否执行完成以及获取任务执行结果的方法。`ExecutorService.submit()` 方法返回的其实就是 `Future` 的实现类 `FutureTask` 。 +`FutureTask` 提供了 `Future` 接口的基本实现,常用来封装 `Callable` 和 `Runnable`,具有取消任务、查看任务是否执行完成以及获取任务执行结果的方法。`ExecutorService.submit()` 方法返回的其实就是 `Future` 的实现类 `FutureTask`。 ```java Future submit(Callable task); Future submit(Runnable task); ``` -`FutureTask` 不光实现了 `Future`接口,还实现了`Runnable` 接口,因此可以作为任务直接被线程执行。 +`FutureTask` 不光实现了 `Future` 接口,还实现了 `Runnable` 接口,因此可以作为任务直接被线程执行。 ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/completablefuture-class-diagram.jpg) -`FutureTask` 有两个构造函数,可传入 `Callable` 或者 `Runnable` 对象。实际上,传入 `Runnable` 对象也会在方法内部转换为`Callable` 对象。 +`FutureTask` 有两个构造函数,可传入 `Callable` 或者 `Runnable` 对象。实际上,传入 `Runnable` 对象也会在方法内部转换为 `Callable` 对象。 ```java public FutureTask(Callable callable) { @@ -1112,7 +1112,7 @@ public FutureTask(Runnable runnable, V result) { } ``` -`FutureTask`相当于对`Callable` 进行了封装,管理着任务执行的情况,存储了 `Callable` 的 `call` 方法的任务执行结果。 +`FutureTask` 相当于对 `Callable` 进行了封装,管理着任务执行的情况,存储了 `Callable` 的 `call` 方法的任务执行结果。 关于更多 `Future` 的源码细节,可以肝这篇万字解析,写的很清楚:[Java 是如何实现 Future 模式的?万字详解!](https://juejin.cn/post/6844904199625375757)。 @@ -1120,7 +1120,7 @@ public FutureTask(Runnable runnable, V result) { `Future` 在实际使用过程中存在一些局限性,比如不支持异步任务的编排组合、获取计算结果的 `get()` 方法为阻塞调用。 -Java 8 才被引入`CompletableFuture` 类可以解决`Future` 的这些缺陷。`CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。 +Java 8 才被引入 `CompletableFuture` 类可以解决 `Future` 的这些缺陷。`CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。 下面我们来简单看看 `CompletableFuture` 类的定义。 @@ -1139,9 +1139,9 @@ public class CompletableFuture implements Future, CompletionStage { ![](https://oss.javaguide.cn/javaguide/image-20210902093026059.png) -### ⭐️一个任务需要依赖另外两个任务执行完之后再执行,怎么设计? +### ⭐️ 一个任务需要依赖另外两个任务执行完之后再执行,怎么设计? -这种任务编排场景非常适合通过`CompletableFuture`实现。这里假设要实现 T3 在 T2 和 T1 执行完后执行。 +这种任务编排场景非常适合通过 `CompletableFuture` 实现。这里假设要实现 T3 在 T2 和 T1 执行完后执行。 代码如下(这里为了简化代码,用到了 Hutool 的线程工具类 `ThreadUtil` 和日期时间工具类 `DateUtil`): @@ -1168,9 +1168,9 @@ ThreadUtil.sleep(3000); 通过 `CompletableFuture` 的 `allOf()` 这个静态方法来并行运行 T1 和 T2,当 T1 和 T2 都完成后,再执行 T3。 -### ⭐️使用 CompletableFuture,有一个任务失败,如何处理异常? +### ⭐️ 使用 CompletableFuture,有一个任务失败,如何处理异常? -使用 `CompletableFuture`的时候一定要以正确的方式进行异常处理,避免异常丢失或者出现不可控问题。 +使用 `CompletableFuture` 的时候一定要以正确的方式进行异常处理,避免异常丢失或者出现不可控问题。 下面是一些建议: @@ -1180,7 +1180,7 @@ ThreadUtil.sleep(3000); - 使用 `CompletableFuture.allOf` 方法可以组合多个 `CompletableFuture`,并统一处理所有任务的异常,而不是让异常处理过于冗长或重复。 - …… -### ⭐️在使用 CompletableFuture 的时候为什么要自定义线程池? +### ⭐️ 在使用 CompletableFuture 的时候为什么要自定义线程池? `CompletableFuture` 默认使用全局共享的 `ForkJoinPool.commonPool()` 作为执行器,所有未指定执行器的异步任务都会使用该线程池。这意味着应用程序、多个库或框架(如 Spring、第三方库)若都依赖 `CompletableFuture`,默认情况下它们都会共享同一个线程池。 @@ -1208,15 +1208,15 @@ CompletableFuture.runAsync(() -> { ### AQS 是什么? -AQS (`AbstractQueuedSynchronizer` ,抽象队列同步器)是从 JDK1.5 开始提供的 Java 并发核心组件。 +AQS(`AbstractQueuedSynchronizer`,抽象队列同步器)是从 JDK1.5 开始提供的 Java 并发核心组件。 AQS 解决了开发者在实现同步器时的复杂性问题。它提供了一个通用框架,用于实现各种同步器,例如 **可重入锁**(`ReentrantLock`)、**信号量**(`Semaphore`)和 **倒计时器**(`CountDownLatch`)。通过封装底层的线程同步机制,AQS 将复杂的线程管理逻辑隐藏起来,使开发者只需专注于具体的同步逻辑。 简单来说,AQS 是一个抽象类,为同步器提供了通用的 **执行框架**。它定义了 **资源获取和释放的通用流程**,而具体的资源获取逻辑则由具体同步器通过重写模板方法来实现。 因此,可以将 AQS 看作是同步器的 **基础“底座”**,而同步器则是基于 AQS 实现的 **具体“应用”**。 -### ⭐️AQS 的原理是什么? +### ⭐️ AQS 的原理是什么? -AQS 核心思想是,如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的工作线程,并且将共享资源设置为锁定状态。如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制,这个机制 AQS 是基于 **CLH 锁** (Craig, Landin, and Hagersten locks) 进一步优化实现的。 +AQS 核心思想是,如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的工作线程,并且将共享资源设置为锁定状态。如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制,这个机制 AQS 是基于 **CLH 锁**(Craig, Landin, and Hagersten locks) 进一步优化实现的。 **CLH 锁** 对自旋锁进行了改进,是基于单链表的自旋锁。在多线程场景下,会将请求获取锁的线程组织成一个单向队列,每个等待的线程会通过自旋访问前一个线程节点的状态,前一个节点释放锁之后,当前节点才可以获取锁。**CLH 锁** 的队列结构如下图所示。 @@ -1226,8 +1226,8 @@ AQS 中使用的 **等待队列** 是 CLH 锁队列的变体(接下来简称 AQS 的 CLH 变体队列是一个双向队列,会暂时获取不到锁的线程将被加入到该队列中,CLH 变体队列和原本的 CLH 锁队列的区别主要有两点: -- 由 **自旋** 优化为 **自旋 + 阻塞** :自旋操作的性能很高,但大量的自旋操作比较占用 CPU 资源,因此在 CLH 变体队列中会先通过自旋尝试获取锁,如果失败再进行阻塞等待。 -- 由 **单向队列** 优化为 **双向队列** :在 CLH 变体队列中,会对等待的线程进行阻塞操作,当队列前边的线程释放锁之后,需要对后边的线程进行唤醒,因此增加了 `next` 指针,成为了双向队列。 +- 由 **自旋** 优化为 **自旋 + 阻塞**:自旋操作的性能很高,但大量的自旋操作比较占用 CPU 资源,因此在 CLH 变体队列中会先通过自旋尝试获取锁,如果失败再进行阻塞等待。 +- 由 **单向队列** 优化为 **双向队列**:在 CLH 变体队列中,会对等待的线程进行阻塞操作,当队列前边的线程释放锁之后,需要对后边的线程进行唤醒,因此增加了 `next` 指针,成为了双向队列。 AQS 将每条请求共享资源的线程封装成一个 CLH 变体队列的一个结点(Node)来实现锁的分配。在 CLH 变体队列中,一个节点表示一个线程,它保存着线程的引用(thread)、 当前节点在队列中的状态(waitStatus)、前驱节点(prev)、后继节点(next)。 @@ -1248,7 +1248,7 @@ AQS 使用 **int 成员变量 `state` 表示同步状态**,通过内置的 ** private volatile int state; ``` -另外,状态信息 `state` 可以通过 `protected` 类型的`getState()`、`setState()`和`compareAndSetState()` 进行操作。并且,这几个方法都是 `final` 修饰的,在子类中无法被重写。 +另外,状态信息 `state` 可以通过 `protected` 类型的 `getState()`、`setState()` 和 `compareAndSetState()` 进行操作。并且,这几个方法都是 `final` 修饰的,在子类中无法被重写。 ```java //返回同步状态的当前值 @@ -1265,13 +1265,13 @@ protected final boolean compareAndSetState(int expect, int update) { } ``` -以 `ReentrantLock` 为例,`state` 初始值为 0,表示未锁定状态。A 线程 `lock()` 时,会调用 `tryAcquire()` 独占该锁并将 `state+1` 。此后,其他线程再 `tryAcquire()` 时就会失败,直到 A 线程 `unlock()` 到 `state=`0(即释放锁)为止,其它线程才有机会获取该锁。当然,释放锁之前,A 线程自己是可以重复获取此锁的(`state` 会累加),这就是可重入的概念。但要注意,获取多少次就要释放多少次,这样才能保证 state 是能回到零态的。 +以 `ReentrantLock` 为例,`state` 初始值为 0,表示未锁定状态。A 线程 `lock()` 时,会调用 `tryAcquire()` 独占该锁并将 `state+1`。此后,其他线程再 `tryAcquire()` 时就会失败,直到 A 线程 `unlock()` 到 `state=`0(即释放锁)为止,其它线程才有机会获取该锁。当然,释放锁之前,A 线程自己是可以重复获取此锁的(`state` 会累加),这就是可重入的概念。但要注意,获取多少次就要释放多少次,这样才能保证 state 是能回到零态的。 -再以 `CountDownLatch` 以例,任务分为 N 个子线程去执行,`state` 也初始化为 N(注意 N 要与线程个数一致)。这 N 个子线程是并行执行的,每个子线程执行完后`countDown()` 一次,state 会 CAS(Compare and Swap) 减 1。等到所有子线程都执行完后(即 `state=0` ),会 `unpark()` 主调用线程,然后主调用线程就会从 `await()` 函数返回,继续后续动作。 +再以 `CountDownLatch` 以例,任务分为 N 个子线程去执行,`state` 也初始化为 N(注意 N 要与线程个数一致)。这 N 个子线程是并行执行的,每个子线程执行完后 `countDown()` 一次,state 会 CAS(Compare and Swap) 减 1。等到所有子线程都执行完后(即 `state=0` ),会 `unpark()` 主调用线程,然后主调用线程就会从 `await()` 函数返回,继续后续动作。 ### Semaphore 有什么用? -`synchronized` 和 `ReentrantLock` 都是一次只允许一个线程访问某个资源,而`Semaphore`(信号量)可以用来控制同时访问特定资源的线程数量。 +`synchronized` 和 `ReentrantLock` 都是一次只允许一个线程访问某个资源,而 `Semaphore`(信号量)可以用来控制同时访问特定资源的线程数量。 Semaphore 的使用简单,我们这里假设有 N(N>5) 个线程来获取 `Semaphore` 中的共享资源,下面的代码表示同一时刻 N 个线程中只有 5 个线程能获取到共享资源,其他线程都会阻塞,只有获取到共享资源的线程才能执行。等到有线程释放了共享资源,其他阻塞的线程才能获取到。 @@ -1311,7 +1311,7 @@ public Semaphore(int permits, boolean fair) { `Semaphore` 是共享锁的一种实现,它默认构造 AQS 的 `state` 值为 `permits`,你可以将 `permits` 的值理解为许可证的数量,只有拿到许可证的线程才能执行。 -调用`semaphore.acquire()` ,线程尝试获取许可证,如果 `state >= 0` 的话,则表示可以获取成功。如果获取成功的话,使用 CAS 操作去修改 `state` 的值 `state=state-1`。如果 `state<0` 的话,则表示许可证数量不足。此时会创建一个 Node 节点加入阻塞队列,挂起当前线程。 +调用 `semaphore.acquire()`,线程尝试获取许可证,如果 `state >= 0` 的话,则表示可以获取成功。如果获取成功的话,使用 CAS 操作去修改 `state` 的值 `state=state-1`。如果 `state<0` 的话,则表示许可证数量不足。此时会创建一个 Node 节点加入阻塞队列,挂起当前线程。 ```java /** @@ -1333,7 +1333,7 @@ public final void acquireSharedInterruptibly(int arg) } ``` -调用`semaphore.release();` ,线程尝试释放许可证,并使用 CAS 操作去修改 `state` 的值 `state=state+1`。释放许可证成功之后,同时会唤醒同步队列中的一个线程。被唤醒的线程会重新尝试去修改 `state` 的值 `state=state-1` ,如果 `state>=0` 则获取令牌成功,否则重新进入阻塞队列,挂起线程。 +调用 `semaphore.release();`,线程尝试释放许可证,并使用 CAS 操作去修改 `state` 的值 `state=state+1`。释放许可证成功之后,同时会唤醒同步队列中的一个线程。被唤醒的线程会重新尝试去修改 `state` 的值 `state=state-1`,如果 `state>=0` 则获取令牌成功,否则重新进入阻塞队列,挂起线程。 ```java // 释放一个许可证 @@ -1355,21 +1355,21 @@ public final boolean releaseShared(int arg) { ### CountDownLatch 有什么用? -`CountDownLatch` 允许 `任意数量` 个线程阻塞在一个地方,直至`count`个线程的任务都执行完毕(`count`次countDown方法)。 +`CountDownLatch` 允许 `任意数量` 个线程阻塞在一个地方,直至`count` 个线程的任务都执行完毕(`count` 次 countDown 方法)。 `CountDownLatch` 是一次性的,计数器的值只能在构造方法中初始化一次,之后没有任何机制再次对其设置值,当 `CountDownLatch` 使用完毕后,它不能再次被使用。 ### CountDownLatch 的原理是什么? -`CountDownLatch` 是共享锁的一种实现,它默认构造 AQS 的 `state` 值为 `count`。当线程使用 `countDown()` 方法时,其实使用了`tryReleaseShared`方法以 CAS 的操作来减少 `state`,直至 `state` 为 0 。当调用 `await()` 方法的时候,如果 `state` 不为 0,那就证明任务还没有执行完毕,`await()` 方法就会一直阻塞,也就是说 `await()` 方法之后的语句不会被执行。直到`count` 个线程调用了`countDown()`使 state 值被减为 0,或者调用`await()`的线程被中断,该线程才会从阻塞中被唤醒,`await()` 方法之后的语句得到执行。 +`CountDownLatch` 是共享锁的一种实现,它默认构造 AQS 的 `state` 值为 `count`。当线程使用 `countDown()` 方法时,其实使用了 `tryReleaseShared` 方法以 CAS 的操作来减少 `state`,直至 `state` 为 0。当调用 `await()` 方法的时候,如果 `state` 不为 0,那就证明任务还没有执行完毕,`await()` 方法就会一直阻塞,也就是说 `await()` 方法之后的语句不会被执行。直到 `count` 个线程调用了 `countDown()` 使 state 值被减为 0,或者调用 `await()` 的线程被中断,该线程才会从阻塞中被唤醒,`await()` 方法之后的语句得到执行。 ### 用过 CountDownLatch 么?什么场景下用的? -`CountDownLatch` 的作用就是 允许 `任意数量` 个线程阻塞在一个地方,直至`count`个线程的任务都执行完毕(`count`次countDown方法)。之前在项目中,有一个使用多线程读取多个文件处理的场景,我用到了 `CountDownLatch` 。具体场景是下面这样的: +`CountDownLatch` 的作用就是 允许 `任意数量` 个线程阻塞在一个地方,直至`count` 个线程的任务都执行完毕(`count` 次 countDown 方法)。之前在项目中,有一个使用多线程读取多个文件处理的场景,我用到了 `CountDownLatch`。具体场景是下面这样的: 我们要读取处理 6 个文件,这 6 个任务都是没有执行顺序依赖的任务,但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。 -为此我们定义了一个线程池和 count 为 6 的`CountDownLatch`对象 。使用线程池处理读取任务,每一个线程处理完之后就将 count-1,调用`CountDownLatch`对象的 `countDown()`方法,直到所有文件读取完之后,才会接着执行后面的逻辑。 +为此我们定义了一个线程池和 count 为 6 的 `CountDownLatch` 对象。使用线程池处理读取任务,每一个线程处理完之后就将 count-1,调用 `CountDownLatch` 对象的 `countDown()` 方法,直到所有文件读取完之后,才会接着执行后面的逻辑。 伪代码是下面这样的: @@ -1482,7 +1482,7 @@ public CyclicBarrier(int parties, Runnable barrierAction) { 其中,`parties` 就代表了有拦截的线程的数量,当拦截的线程数量达到这个值的时候就打开栅栏,让所有线程通过。 -2、当调用 `CyclicBarrier` 对象调用 `await()` 方法时,实际上调用的是 `dowait(false, 0L)`方法。 `await()` 方法就像树立起一个栅栏的行为一样,将线程挡住了,当拦住的线程数量达到 `parties` 的值时,栅栏才会打开,线程才得以通过执行。 +2、当调用 `CyclicBarrier` 对象调用 `await()` 方法时,实际上调用的是 `dowait(false, 0L)` 方法。 `await()` 方法就像树立起一个栅栏的行为一样,将线程挡住了,当拦住的线程数量达到 `parties` 的值时,栅栏才会打开,线程才得以通过执行。 ```java public int await() throws InterruptedException, BrokenBarrierException { @@ -1494,7 +1494,7 @@ public int await() throws InterruptedException, BrokenBarrierException { } ``` -`dowait(false, 0L)`方法源码分析如下: +`dowait(false, 0L)` 方法源码分析如下: ```java // 当线程数量或者请求数量达到 count 时 await 之后的方法才会被执行。上面的示例中 count 的值就为 5。 @@ -1590,7 +1590,7 @@ public int await() throws InterruptedException, BrokenBarrierException { - 《深入理解 Java 虚拟机》 - 《实战 Java 高并发程序设计》 -- Java 线程池的实现原理及其在业务中的最佳实践:阿里云开发者: +- Java 线程池的实现原理及其在业务中的最佳实践:阿里云开发者: - 带你了解下 SynchronousQueue(并发队列专题): - 阻塞队列 — DelayedWorkQueue 源码分析: - Java 多线程(三)——FutureTask/CompletableFuture: diff --git a/docs/java/concurrent/java-thread-pool-best-practices.md b/docs/java/concurrent/java-thread-pool-best-practices.md index fd4a7ffa7c7..ec3253159f9 100644 --- a/docs/java/concurrent/java-thread-pool-best-practices.md +++ b/docs/java/concurrent/java-thread-pool-best-practices.md @@ -14,17 +14,17 @@ head: ## 1、正确声明线程池 -**线程池必须手动通过 `ThreadPoolExecutor` 的构造函数来声明,避免使用`Executors` 类创建线程池,会有 OOM 风险。** +**线程池必须手动通过 `ThreadPoolExecutor` 的构造函数来声明,避免使用 `Executors` 类创建线程池,会有 OOM 风险。** -`Executors` 返回线程池对象的弊端如下(后文会详细介绍到): +`Executors` 返回线程池对象的弊端如下(后文会详细介绍到): - **`FixedThreadPool` 和 `SingleThreadExecutor`**:使用的是阻塞队列 `LinkedBlockingQueue`,任务队列的默认长度和最大长度为 `Integer.MAX_VALUE`,可以看作是无界队列,可能堆积大量的请求,从而导致 OOM。 -- **`CachedThreadPool`**:使用的是同步队列 `SynchronousQueue`,允许创建的线程数量为 `Integer.MAX_VALUE` ,可能会创建大量线程,从而导致 OOM。 -- **`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`** : 使用的无界的延迟阻塞队列`DelayedWorkQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求,从而导致 OOM。 +- **`CachedThreadPool`**:使用的是同步队列 `SynchronousQueue`,允许创建的线程数量为 `Integer.MAX_VALUE`,可能会创建大量线程,从而导致 OOM。 +- **`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`** : 使用的无界的延迟阻塞队列 `DelayedWorkQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求,从而导致 OOM。 说白了就是:**使用有界队列,控制线程创建数量。** -除了避免 OOM 的原因之外,不推荐使用 `Executors`提供的两种快捷的线程池的原因还有: +除了避免 OOM 的原因之外,不推荐使用 `Executors` 提供的两种快捷的线程池的原因还有: - 实际使用中需要根据自己机器的性能、业务场景来手动配置线程池的参数比如核心线程数、使用的任务队列、饱和策略等等。 - 我们应该显示地给我们的线程池命名,这样有助于我们定位问题。 @@ -33,11 +33,11 @@ head: 你可以通过一些手段来检测线程池的运行状态比如 SpringBoot 中的 Actuator 组件。 -除此之外,我们还可以利用 `ThreadPoolExecutor` 的相关 API 做一个简陋的监控。从下图可以看出, `ThreadPoolExecutor`提供了获取线程池当前的线程数和活跃线程数、已经执行完成的任务数、正在排队中的任务数等等。 +除此之外,我们还可以利用 `ThreadPoolExecutor` 的相关 API 做一个简陋的监控。从下图可以看出, `ThreadPoolExecutor` 提供了获取线程池当前的线程数和活跃线程数、已经执行完成的任务数、正在排队中的任务数等等。 ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpool-methods-information.png) -下面是一个简单的 Demo。`printThreadPoolStatus()`会每隔一秒打印出线程池的线程数、活跃线程数、完成的任务数、以及队列中的任务数。 +下面是一个简单的 Demo。`printThreadPoolStatus()` 会每隔一秒打印出线程池的线程数、活跃线程数、完成的任务数、以及队列中的任务数。 ```java /** @@ -64,13 +64,13 @@ public static void printThreadPoolStatus(ThreadPoolExecutor threadPool) { 一般建议是不同的业务使用不同的线程池,配置线程池的时候根据当前业务的情况对当前线程池进行配置,因为不同的业务的并发以及对资源的使用情况都不同,重心优化系统性能瓶颈相关的业务。 -**我们再来看一个真实的事故案例!** (本案例来源自:[《线程池运用不当的一次线上事故》](https://heapdump.cn/article/646639) ,很精彩的一个案例) +**我们再来看一个真实的事故案例!** (本案例来源自:[《线程池运用不当的一次线上事故》](https://heapdump.cn/article/646639),很精彩的一个案例) ![案例代码概览](https://oss.javaguide.cn/github/javaguide/java/concurrent/production-accident-threadpool-sharing-example.png) 上面的代码可能会存在死锁的情况,为什么呢?画个图给大家捋一捋。 -试想这样一种极端情况:假如我们线程池的核心线程数为 **n**,父任务(扣费任务)数量为 **n**,父任务下面有两个子任务(扣费任务下的子任务),其中一个已经执行完成,另外一个被放在了任务队列中。由于父任务把线程池核心线程资源用完,所以子任务因为无法获取到线程资源无法正常执行,一直被阻塞在队列中。父任务等待子任务执行完成,而子任务等待父任务释放线程池资源,这也就造成了 **“死锁”** 。 +试想这样一种极端情况:假如我们线程池的核心线程数为 **n**,父任务(扣费任务)数量为 **n**,父任务下面有两个子任务(扣费任务下的子任务),其中一个已经执行完成,另外一个被放在了任务队列中。由于父任务把线程池核心线程资源用完,所以子任务因为无法获取到线程资源无法正常执行,一直被阻塞在队列中。父任务等待子任务执行完成,而子任务等待父任务释放线程池资源,这也就造成了 **“死锁”**。 ![线程池使用不当导致死锁](https://oss.javaguide.cn/github/javaguide/java/concurrent/production-accident-threadpool-sharing-deadlock.png) @@ -149,7 +149,7 @@ public final class NamingThreadFactory implements ThreadFactory { 有一个简单并且适用面比较广的公式: - **CPU 密集型任务 (N):** 这种任务消耗的主要是 CPU 资源,线程数应设置为 N(CPU 核心数)。由于任务主要瓶颈在于 CPU 计算能力,与核心数相等的线程数能够最大化 CPU 利用率,过多线程反而会导致竞争和上下文切换开销。 -- **I/O 密集型任务(M \* N):** 这类任务大部分时间处理 I/O 交互,线程在等待 I/O 时不占用 CPU。 为了充分利用 CPU 资源,线程数可以设置为 M \* N,其中 N 是 CPU 核心数,M 是一个大于 1 的倍数,建议默认设置为 2 ,具体取值取决于 I/O 等待时间和任务特点,需要通过测试和监控找到最佳平衡点。 +- **I/O 密集型任务(M \* N):** 这类任务大部分时间处理 I/O 交互,线程在等待 I/O 时不占用 CPU。 为了充分利用 CPU 资源,线程数可以设置为 M \* N,其中 N 是 CPU 核心数,M 是一个大于 1 的倍数,建议默认设置为 2,具体取值取决于 I/O 等待时间和任务特点,需要通过测试和监控找到最佳平衡点。 CPU 密集型任务不再推荐 N+1,原因如下: @@ -192,9 +192,9 @@ IO 密集型任务下,几乎全是线程等待时间,从理论上来说, ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpoolexecutor-methods.png) -格外需要注意的是`corePoolSize`, 程序运行期间的时候,我们调用 `setCorePoolSize()`这个方法的话,线程池会首先判断当前工作线程数是否大于`corePoolSize`,如果大于的话就会回收工作线程。 +格外需要注意的是 `corePoolSize`, 程序运行期间的时候,我们调用 `setCorePoolSize()` 这个方法的话,线程池会首先判断当前工作线程数是否大于 `corePoolSize`,如果大于的话就会回收工作线程。 -另外,你也看到了上面并没有动态指定队列长度的方法,美团的方式是自定义了一个叫做 `ResizableCapacityLinkedBlockIngQueue` 的队列(主要就是把`LinkedBlockingQueue`的 capacity 字段的 final 关键字修饰给去掉了,让它变为可变的)。 +另外,你也看到了上面并没有动态指定队列长度的方法,美团的方式是自定义了一个叫做 `ResizableCapacityLinkedBlockIngQueue` 的队列(主要就是把 `LinkedBlockingQueue` 的 capacity 字段的 final 关键字修饰给去掉了,让它变为可变的)。 最终实现的可动态修改线程池参数效果如下。👏👏👏 @@ -214,7 +214,7 @@ IO 密集型任务下,几乎全是线程等待时间,从理论上来说, - **`shutdown()`** :关闭线程池,线程池的状态变为 `SHUTDOWN`。线程池不再接受新任务了,但是队列里的任务得执行完毕。 - **`shutdownNow()`** :关闭线程池,线程池的状态变为 `STOP`。线程池会终止当前正在运行的任务,停止处理排队的任务并返回正在等待执行的 List。 -调用完 `shutdownNow` 和 `shuwdown` 方法后,并不代表线程池已经完成关闭操作,它只是异步的通知线程池进行关闭处理。如果要同步等待线程池彻底关闭后才继续往下执行,需要调用`awaitTermination`方法进行同步等待。 +调用完 `shutdownNow` 和 `shuwdown` 方法后,并不代表线程池已经完成关闭操作,它只是异步的通知线程池进行关闭处理。如果要同步等待线程池彻底关闭后才继续往下执行,需要调用 `awaitTermination` 方法进行同步等待。 在调用 `awaitTermination()` 方法时,应该设置合理的超时时间,以避免程序长时间阻塞而导致性能问题。另外。由于线程池中的任务可能会被取消或抛出异常,因此在使用 `awaitTermination()` 方法时还需要进行异常处理。`awaitTermination()` 方法会抛出 `InterruptedException` 异常,需要捕获并处理该异常,以避免程序崩溃或者无法正常退出。 @@ -290,7 +290,7 @@ public class ThreadPoolExecutorConfig { ### 线程池和 ThreadLocal 共用的坑 -线程池和 `ThreadLocal`共用,可能会导致线程从`ThreadLocal`获取到的是旧值/脏数据。这是因为线程池会复用线程对象,与线程对象绑定的类的静态属性 `ThreadLocal` 变量也会被重用,这就导致一个线程可能获取到其他线程的`ThreadLocal` 值。 +线程池和 `ThreadLocal` 共用,可能会导致线程从 `ThreadLocal` 获取到的是旧值/脏数据。这是因为线程池会复用线程对象,与线程对象绑定的类的静态属性 `ThreadLocal` 变量也会被重用,这就导致一个线程可能获取到其他线程的 `ThreadLocal` 值。 不要以为代码中没有显示使用线程池就不存在线程池了,像常用的 Web 服务器 Tomcat 处理任务为了提高并发量,就使用到了线程池,并且使用的是基于原生 Java 线程池改进完善得到的自定义线程池。 @@ -300,8 +300,8 @@ public class ThreadPoolExecutorConfig { server.tomcat.max-threads=1 ``` -解决上述问题比较建议的办法是使用阿里巴巴开源的 `TransmittableThreadLocal`(`TTL`)。`TransmittableThreadLocal`类继承并加强了 JDK 内置的`InheritableThreadLocal`类,在使用线程池等会池化复用线程的执行组件情况下,提供`ThreadLocal`值的传递功能,解决异步执行时上下文传递的问题。 +解决上述问题比较建议的办法是使用阿里巴巴开源的 `TransmittableThreadLocal`(`TTL`)。`TransmittableThreadLocal` 类继承并加强了 JDK 内置的 `InheritableThreadLocal` 类,在使用线程池等会池化复用线程的执行组件情况下,提供 `ThreadLocal` 值的传递功能,解决异步执行时上下文传递的问题。 -`TransmittableThreadLocal` 项目地址: 。 +`TransmittableThreadLocal` 项目地址:。 diff --git a/docs/java/concurrent/java-thread-pool-summary.md b/docs/java/concurrent/java-thread-pool-summary.md index 8eef8cd61e8..c71551aaf3d 100644 --- a/docs/java/concurrent/java-thread-pool-summary.md +++ b/docs/java/concurrent/java-thread-pool-summary.md @@ -38,17 +38,17 @@ head: **1、任务(`Runnable` /`Callable`)** -执行任务需要实现的 **`Runnable` 接口** 或 **`Callable`接口**。**`Runnable` 接口**或 **`Callable` 接口** 实现类都可以被 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。 +执行任务需要实现的 **`Runnable` 接口** 或 **`Callable` 接口**。**`Runnable` 接口**或 **`Callable` 接口** 实现类都可以被 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。 **2、任务的执行(`Executor`)** -如下图所示,包括任务执行机制的核心接口 **`Executor`** ,以及继承自 `Executor` 接口的 **`ExecutorService` 接口。`ThreadPoolExecutor`** 和 **`ScheduledThreadPoolExecutor`** 这两个关键类实现了 **`ExecutorService`** 接口。 +如下图所示,包括任务执行机制的核心接口 **`Executor`**,以及继承自 `Executor` 接口的 **`ExecutorService` 接口。`ThreadPoolExecutor`** 和 **`ScheduledThreadPoolExecutor`** 这两个关键类实现了 **`ExecutorService`** 接口。 ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/executor-class-diagram.png) 这里提了很多底层的类关系,但是,实际上我们需要更多关注的是 `ThreadPoolExecutor` 这个类,这个类在我们实际使用线程池的过程中,使用频率还是非常高的。 -**注意:** 通过查看 `ScheduledThreadPoolExecutor` 源代码我们发现 `ScheduledThreadPoolExecutor` 实际上是继承了 `ThreadPoolExecutor` 并实现了 `ScheduledExecutorService` ,而 `ScheduledExecutorService` 又实现了 `ExecutorService`,正如我们上面给出的类关系图显示的一样。 +**注意:** 通过查看 `ScheduledThreadPoolExecutor` 源代码我们发现 `ScheduledThreadPoolExecutor` 实际上是继承了 `ThreadPoolExecutor` 并实现了 `ScheduledExecutorService`,而 `ScheduledExecutorService` 又实现了 `ExecutorService`,正如我们上面给出的类关系图显示的一样。 `ThreadPoolExecutor` 类描述: @@ -70,16 +70,16 @@ public class ScheduledThreadPoolExecutor **`Future`** 接口以及 `Future` 接口的实现类 **`FutureTask`** 类都可以代表异步计算的结果。 -当我们把 **`Runnable`接口** 或 **`Callable` 接口** 的实现类提交给 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。(调用 `submit()` 方法时会返回一个 **`FutureTask`** 对象) +当我们把 **`Runnable` 接口** 或 **`Callable` 接口** 的实现类提交给 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。(调用 `submit()` 方法时会返回一个 **`FutureTask`** 对象) **`Executor` 框架的使用示意图**: ![Executor 框架的使用示意图](./images/java-thread-pool-summary/Executor框架的使用示意图.png) 1. 主线程首先要创建实现 `Runnable` 或者 `Callable` 接口的任务对象。 -2. 把创建完成的实现 `Runnable`/`Callable`接口的 对象直接交给 `ExecutorService` 执行: `ExecutorService.execute(Runnable command)`)或者也可以把 `Runnable` 对象或`Callable` 对象提交给 `ExecutorService` 执行(`ExecutorService.submit(Runnable task)`或 `ExecutorService.submit(Callable task)`)。 -3. 如果执行 `ExecutorService.submit(…)`,`ExecutorService` 将返回一个实现`Future`接口的对象(我们刚刚也提到过了执行 `execute()`方法和 `submit()`方法的区别,`submit()`会返回一个 `FutureTask 对象)。由于 FutureTask` 实现了 `Runnable`,我们也可以创建 `FutureTask`,然后直接交给 `ExecutorService` 执行。 -4. 最后,主线程可以执行 `FutureTask.get()`方法来等待任务执行完成。主线程也可以执行 `FutureTask.cancel(boolean mayInterruptIfRunning)`来取消此任务的执行。 +2. 把创建完成的实现 `Runnable`/`Callable` 接口的 对象直接交给 `ExecutorService` 执行: `ExecutorService.execute(Runnable command)`)或者也可以把 `Runnable` 对象或 `Callable` 对象提交给 `ExecutorService` 执行(`ExecutorService.submit(Runnable task)` 或 `ExecutorService.submit(Callable task)`)。 +3. 如果执行 `ExecutorService.submit(…)`,`ExecutorService` 将返回一个实现 `Future` 接口的对象(我们刚刚也提到过了执行 `execute()` 方法和 `submit()` 方法的区别,`submit()` 会返回一个 `FutureTask 对象)。由于 FutureTask` 实现了 `Runnable`,我们也可以创建 `FutureTask`,然后直接交给 `ExecutorService` 执行。 +4. 最后,主线程可以执行 `FutureTask.get()` 方法来等待任务执行完成。主线程也可以执行 `FutureTask.cancel(boolean mayInterruptIfRunning)` 来取消此任务的执行。 ## ThreadPoolExecutor 类介绍(重要) @@ -125,9 +125,9 @@ public class ScheduledThreadPoolExecutor - `maximumPoolSize` : 任务队列中存放的任务达到队列容量的时候,当前可以同时运行的线程数量变为最大线程数。 - `workQueue`: 新任务来的时候会先判断当前运行的线程数量是否达到核心线程数,如果达到的话,新任务就会被存放在队列中。 -`ThreadPoolExecutor`其他常见参数 : +`ThreadPoolExecutor` 其他常见参数 : -- `keepAliveTime`:线程池中的线程数量大于 `corePoolSize` 的时候,如果这时没有新的任务提交,核心线程外的线程不会立即销毁,而是会等待,直到等待的时间超过了 `keepAliveTime`才会被回收销毁。 +- `keepAliveTime`:线程池中的线程数量大于 `corePoolSize` 的时候,如果这时没有新的任务提交,核心线程外的线程不会立即销毁,而是会等待,直到等待的时间超过了 `keepAliveTime` 才会被回收销毁。 - `unit` : `keepAliveTime` 参数的时间单位。 - `threadFactory` :executor 创建新线程的时候会用到。 - `handler` :拒绝策略(后面会单独详细介绍一下)。 @@ -166,14 +166,14 @@ public class ScheduledThreadPoolExecutor 如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时,`ThreadPoolExecutor` 定义一些策略: -- `ThreadPoolExecutor.AbortPolicy`:抛出 `RejectedExecutionException`来拒绝新任务的处理。 -- `ThreadPoolExecutor.CallerRunsPolicy`:调用执行自己的线程运行任务,也就是直接在调用`execute`方法的线程中运行(`run`)被拒绝的任务,如果执行程序已关闭,则会丢弃该任务。因此这种策略会降低对于新任务提交速度,影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话,你可以选择这个策略。 +- `ThreadPoolExecutor.AbortPolicy`:抛出 `RejectedExecutionException` 来拒绝新任务的处理。 +- `ThreadPoolExecutor.CallerRunsPolicy`:调用执行自己的线程运行任务,也就是直接在调用 `execute` 方法的线程中运行(`run`)被拒绝的任务,如果执行程序已关闭,则会丢弃该任务。因此这种策略会降低对于新任务提交速度,影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话,你可以选择这个策略。 - `ThreadPoolExecutor.DiscardPolicy`:不处理新任务,直接丢弃掉。 - `ThreadPoolExecutor.DiscardOldestPolicy`:此策略将丢弃最早的未处理的任务请求。 举个例子: -举个例子:Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候,当我们不指定 `RejectedExecutionHandler` 拒绝策略来配置线程池的时候,默认使用的是 `AbortPolicy`。在这种拒绝策略下,如果队列满了,`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 异常来拒绝新来的任务 ,这代表你将丢失对这个任务的处理。如果不想丢弃任务的话,可以使用`CallerRunsPolicy`。`CallerRunsPolicy` 和其他的几个策略不同,它既不会抛弃任务,也不会抛出异常,而是将任务回退给调用者,使用调用者的线程来执行任务 +举个例子:Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候,当我们不指定 `RejectedExecutionHandler` 拒绝策略来配置线程池的时候,默认使用的是 `AbortPolicy`。在这种拒绝策略下,如果队列满了,`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 异常来拒绝新来的任务,这代表你将丢失对这个任务的处理。如果不想丢弃任务的话,可以使用 `CallerRunsPolicy`。`CallerRunsPolicy` 和其他的几个策略不同,它既不会抛弃任务,也不会抛出异常,而是将任务回退给调用者,使用调用者的线程来执行任务 ```java public static class CallerRunsPolicy implements RejectedExecutionHandler { @@ -207,19 +207,19 @@ public static class CallerRunsPolicy implements RejectedExecutionHandler { 在 Java 中,创建线程池主要有两种方式: -**方式一:通过 `ThreadPoolExecutor` 构造函数直接创建 (推荐)** +**方式一:通过 `ThreadPoolExecutor` 构造函数直接创建(推荐)** ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/threadpoolexecutor-construtors.png) 这是最推荐的方式,因为它允许开发者明确指定线程池的核心参数,对线程池的运行行为有更精细的控制,从而避免资源耗尽的风险。 -**方式二:通过 `Executors` 工具类创建 (不推荐用于生产环境)** +**方式二:通过 `Executors` 工具类创建(不推荐用于生产环境)** -`Executors`工具类提供的创建线程池的方法如下图所示: +`Executors` 工具类提供的创建线程池的方法如下图所示: ![](https://oss.javaguide.cn/github/javaguide/java/concurrent/executors-new-thread-pool-methods.png) -可以看出,通过`Executors`工具类可以创建多种类型的线程池,包括: +可以看出,通过 `Executors` 工具类可以创建多种类型的线程池,包括: - `FixedThreadPool`:固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时,线程池中若有空闲线程,则立即执行。若没有,则新的任务会被暂存在一个任务队列中,待有线程空闲时,便处理在任务队列中的任务。 - `SingleThreadExecutor`: 只有一个线程的线程池。若多余一个任务被提交到该线程池,任务会被保存在一个任务队列中,待线程空闲,按先入先出的顺序执行队列中的任务。 @@ -228,11 +228,11 @@ public static class CallerRunsPolicy implements RejectedExecutionHandler { 《阿里巴巴 Java 开发手册》强制线程池不允许使用 `Executors` 去创建,而是通过 `ThreadPoolExecutor` 构造函数的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险 -`Executors` 返回线程池对象的弊端如下(后文会详细介绍到): +`Executors` 返回线程池对象的弊端如下(后文会详细介绍到): - `FixedThreadPool` 和 `SingleThreadExecutor`:使用的是阻塞队列 `LinkedBlockingQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可以看作是无界的,可能堆积大量的请求,从而导致 OOM。 -- `CachedThreadPool`:使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE` ,如果任务数量过多且执行速度较慢,可能会创建大量的线程,从而导致 OOM。 -- `ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`:使用的无界的延迟阻塞队列`DelayedWorkQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求,从而导致 OOM。 +- `CachedThreadPool`:使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE`,如果任务数量过多且执行速度较慢,可能会创建大量的线程,从而导致 OOM。 +- `ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`:使用的无界的延迟阻塞队列 `DelayedWorkQueue`,任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求,从而导致 OOM。 ```java public static ExecutorService newFixedThreadPool(int nThreads) { @@ -270,13 +270,13 @@ public ScheduledThreadPoolExecutor(int corePoolSize) { 不同的线程池会选用不同的阻塞队列,我们可以结合内置线程池来分析。 -- 容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界队列):`FixedThreadPool` 和 `SingleThreadExector` 。`FixedThreadPool`最多只能创建核心线程数的线程(核心线程数和最大线程数相等),`SingleThreadExector`只能创建一个线程(核心线程数和最大线程数都是 1),二者的任务队列永远不会被放满。 -- `SynchronousQueue`(同步队列):`CachedThreadPool` 。`SynchronousQueue` 没有容量,不存储元素,目的是保证对于提交的任务,如果有空闲线程,则使用空闲线程来处理;否则新建一个线程来处理任务。也就是说,`CachedThreadPool` 的最大线程数是 `Integer.MAX_VALUE` ,可以理解为线程数是可以无限扩展的,可能会创建大量线程,从而导致 OOM。 -- `DelayedWorkQueue`(延迟阻塞队列):`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor` 。`DelayedWorkQueue` 的内部元素并不是按照放入的时间排序,而是会按照延迟的时间长短对任务进行排序,内部采用的是“堆”的数据结构,可以保证每次出队的任务都是当前队列中执行时间最靠前的。`DelayedWorkQueue` 添加元素满了之后会自动扩容原来容量的 1/2,即永远不会阻塞,最大扩容可达 `Integer.MAX_VALUE`,所以最多只能创建核心线程数的线程。 +- 容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界队列):`FixedThreadPool` 和 `SingleThreadExector`。`FixedThreadPool` 最多只能创建核心线程数的线程(核心线程数和最大线程数相等),`SingleThreadExector` 只能创建一个线程(核心线程数和最大线程数都是 1),二者的任务队列永远不会被放满。 +- `SynchronousQueue`(同步队列):`CachedThreadPool`。`SynchronousQueue` 没有容量,不存储元素,目的是保证对于提交的任务,如果有空闲线程,则使用空闲线程来处理;否则新建一个线程来处理任务。也就是说,`CachedThreadPool` 的最大线程数是 `Integer.MAX_VALUE`,可以理解为线程数是可以无限扩展的,可能会创建大量线程,从而导致 OOM。 +- `DelayedWorkQueue`(延迟阻塞队列):`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor`。`DelayedWorkQueue` 的内部元素并不是按照放入的时间排序,而是会按照延迟的时间长短对任务进行排序,内部采用的是“堆”的数据结构,可以保证每次出队的任务都是当前队列中执行时间最靠前的。`DelayedWorkQueue` 添加元素满了之后会自动扩容原来容量的 1/2,即永远不会阻塞,最大扩容可达 `Integer.MAX_VALUE`,所以最多只能创建核心线程数的线程。 ## 线程池原理分析(重要) -我们上面讲解了 `Executor`框架以及 `ThreadPoolExecutor` 类,下面让我们实战一下,来通过写一个 `ThreadPoolExecutor` 的小 Demo 来回顾上面的内容。 +我们上面讲解了 `Executor` 框架以及 `ThreadPoolExecutor` 类,下面让我们实战一下,来通过写一个 `ThreadPoolExecutor` 的小 Demo 来回顾上面的内容。 ### 线程池示例代码 @@ -407,7 +407,7 @@ Finished all threads // 任务全部执行完了才会跳出来,因为executo 现在,我们就分析上面的输出内容来简单分析一下线程池原理。 -为了搞懂线程池的原理,我们需要首先分析一下 `execute`方法。 在示例代码中,我们使用 `executor.execute(worker)`来提交一个任务到线程池中去。 +为了搞懂线程池的原理,我们需要首先分析一下 `execute` 方法。 在示例代码中,我们使用 `executor.execute(worker)` 来提交一个任务到线程池中去。 这个方法非常重要,下面我们来看看它的源码: @@ -462,7 +462,7 @@ Finished all threads // 任务全部执行完了才会跳出来,因为executo 3. 如果向任务队列投放任务失败(任务队列已经满了),并且当前工作线程总数小于最大线程数,就新建一个非核心线程来执行任务。 4. 如果当前工作线程总数已经等同于最大线程数,任务队列也无法继续接收任务,那么当前任务会被拒绝,拒绝策略会调用 `RejectedExecutionHandler.rejectedExecution()` 方法。 -> **补充说明**:很多人误以为非核心线程只在任务队列满的时候才会被创建,之后就"闲着"等销毁。实际上,非核心线程执行完初始任务后,并不会立刻销毁,而是会**主动从任务队列中拉取任务执行**(通过 `getTask()` 方法)。具体来说,核心线程使用 `workQueue.take()` 阻塞等待任务,而非核心线程使用 `workQueue.poll(keepAliveTime, unit)` ——如果在存活时间内从队列中取到了任务,就会继续执行;只有超时没有取到任务,非核心线程才会被回收。这意味着,即使新任务被放入了队列,空闲的非核心线程也会抢先从队列中取走任务来执行,而不是等队列满了才被动响应。 +> **补充说明**:很多人误以为非核心线程只在任务队列满的时候才会被创建,之后就“闲着”等销毁。实际上,非核心线程执行完初始任务后,并不会立刻销毁,而是会**主动从任务队列中拉取任务执行**(通过 `getTask()` 方法)。具体来说,核心线程使用 `workQueue.take()` 阻塞等待任务,而非核心线程使用 `workQueue.poll(keepAliveTime, unit)` ——如果在存活时间内从队列中取到了任务,就会继续执行;只有超时没有取到任务,非核心线程才会被回收。这意味着,即使新任务被放入了队列,空闲的非核心线程也会抢先从队列中取走任务来执行,而不是等队列满了才被动响应。 ![图解线程池实现原理](https://oss.javaguide.cn/github/javaguide/java/concurrent/thread-pool-principle.png) @@ -577,13 +577,13 @@ Finished all threads // 任务全部执行完了才会跳出来,因为executo 没搞懂的话,也没关系,可以看看我的分析: -> 我们在代码中模拟了 10 个任务,我们配置的核心线程数为 5、等待队列容量为 100 ,所以每次只可能存在 5 个任务同时执行,剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务中如果有任务被执行完了,线程池就会去拿新的任务执行。 +> 我们在代码中模拟了 10 个任务,我们配置的核心线程数为 5、等待队列容量为 100,所以每次只可能存在 5 个任务同时执行,剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务中如果有任务被执行完了,线程池就会去拿新的任务执行。 ### 几个常见的对比 #### `Runnable` vs `Callable` -`Runnable`自 Java 1.0 以来一直存在,但`Callable`仅在 Java 1.5 中引入,目的就是为了来处理`Runnable`不支持的用例。`Runnable` 接口不会返回结果或抛出检查异常,但是 `Callable` 接口可以。所以,如果任务不需要返回结果或抛出异常推荐使用 `Runnable` 接口,这样代码看起来会更加简洁。 +`Runnable` 自 Java 1.0 以来一直存在,但 `Callable` 仅在 Java 1.5 中引入,目的就是为了来处理 `Runnable` 不支持的用例。`Runnable` 接口不会返回结果或抛出检查异常,但是 `Callable` 接口可以。所以,如果任务不需要返回结果或抛出异常推荐使用 `Runnable` 接口,这样代码看起来会更加简洁。 工具类 `Executors` 可以实现将 `Runnable` 对象转换成 `Callable` 对象。(`Executors.callable(Runnable task)` 或 `Executors.callable(Runnable task, Object result)`)。 @@ -616,12 +616,12 @@ public interface Callable { #### `execute()` vs `submit()` -`execute()` 和 `submit()`是两种提交任务到线程池的方法,有一些区别: +`execute()` 和 `submit()` 是两种提交任务到线程池的方法,有一些区别: -- **返回值**:`execute()` 方法用于提交不需要返回值的任务。通常用于执行 `Runnable` 任务,无法判断任务是否被线程池成功执行。`submit()` 方法用于提交需要返回值的任务。可以提交 `Runnable` 或 `Callable` 任务。`submit()` 方法返回一个 `Future` 对象,通过这个 `Future` 对象可以判断任务是否执行成功,并获取任务的返回值(`get()`方法会阻塞当前线程直到任务完成, `get(long timeout,TimeUnit unit)`多了一个超时时间,如果在 `timeout` 时间内任务还没有执行完,就会抛出 `java.util.concurrent.TimeoutException`)。 -- **异常处理**:在使用 `submit()` 方法时,可以通过 `Future` 对象处理任务执行过程中抛出的异常;而在使用 `execute()` 方法时,异常处理需要通过自定义的 `ThreadFactory` (在线程工厂创建线程的时候设置`UncaughtExceptionHandler`对象来 处理异常)或 `ThreadPoolExecutor` 的 `afterExecute()` 方法来处理 +- **返回值**:`execute()` 方法用于提交不需要返回值的任务。通常用于执行 `Runnable` 任务,无法判断任务是否被线程池成功执行。`submit()` 方法用于提交需要返回值的任务。可以提交 `Runnable` 或 `Callable` 任务。`submit()` 方法返回一个 `Future` 对象,通过这个 `Future` 对象可以判断任务是否执行成功,并获取任务的返回值(`get()` 方法会阻塞当前线程直到任务完成, `get(long timeout,TimeUnit unit)` 多了一个超时时间,如果在 `timeout` 时间内任务还没有执行完,就会抛出 `java.util.concurrent.TimeoutException`)。 +- **异常处理**:在使用 `submit()` 方法时,可以通过 `Future` 对象处理任务执行过程中抛出的异常;而在使用 `execute()` 方法时,异常处理需要通过自定义的 `ThreadFactory`(在线程工厂创建线程的时候设置 `UncaughtExceptionHandler` 对象来 处理异常)或 `ThreadPoolExecutor` 的 `afterExecute()` 方法来处理 -示例 1:使用 `get()`方法获取返回值。 +示例 1:使用 `get()` 方法获取返回值。 ```java // 这里只是为了演示使用,推荐使用 `ThreadPoolExecutor` 构造方法来创建线程池。 @@ -647,7 +647,7 @@ executorService.shutdown(); abc ``` -示例 2:使用 `get(long timeout,TimeUnit unit)`方法获取返回值。 +示例 2:使用 `get(long timeout,TimeUnit unit)` 方法获取返回值。 ```java ExecutorService executorService = Executors.newFixedThreadPool(3); @@ -715,7 +715,7 @@ Exception in thread "main" java.util.concurrent.TimeoutException 从上面源代码可以看出新创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 都被设置为 `nThreads`,这个 `nThreads` 参数是我们使用的时候自己传递的。 -即使 `maximumPoolSize` 的值比 `corePoolSize` 大,也至多只会创建 `corePoolSize` 个线程。这是因为`FixedThreadPool` 使用的是容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界队列),队列永远不会被放满。 +即使 `maximumPoolSize` 的值比 `corePoolSize` 大,也至多只会创建 `corePoolSize` 个线程。这是因为 `FixedThreadPool` 使用的是容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界队列),队列永远不会被放满。 #### 执行任务过程介绍 @@ -729,14 +729,14 @@ Exception in thread "main" java.util.concurrent.TimeoutException 2. 当前工作线程总数达到 `corePoolSize` 后,如果再来新任务的话,会将任务加入 `LinkedBlockingQueue`; 3. 线程池中的线程执行完 手头的任务后,会在循环中反复从 `LinkedBlockingQueue` 中获取任务来执行; -#### 为什么不推荐使用`FixedThreadPool`? +#### 为什么不推荐使用 `FixedThreadPool`? `FixedThreadPool` 使用无界队列 `LinkedBlockingQueue`(队列的容量为 Integer.MAX_VALUE)作为线程池的工作队列会对线程池带来如下影响: 1. 当线程池中的线程数达到 `corePoolSize` 后,新任务将在无界队列中等待,因此线程池中的线程数不会超过 `corePoolSize`; -2. 由于使用无界队列时 `maximumPoolSize` 将是一个无效参数,因为不可能存在任务队列满的情况。所以,通过创建 `FixedThreadPool`的源码可以看出创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 被设置为同一个值。 +2. 由于使用无界队列时 `maximumPoolSize` 将是一个无效参数,因为不可能存在任务队列满的情况。所以,通过创建 `FixedThreadPool` 的源码可以看出创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 被设置为同一个值。 3. 由于 1 和 2,使用无界队列时 `keepAliveTime` 将是一个无效参数; -4. 运行中的 `FixedThreadPool`(未执行 `shutdown()`或 `shutdownNow()`)不会拒绝任务,在任务比较多的时候会导致 OOM(内存溢出)。 +4. 运行中的 `FixedThreadPool`(未执行 `shutdown()` 或 `shutdownNow()`)不会拒绝任务,在任务比较多的时候会导致 OOM(内存溢出)。 ### SingleThreadExecutor @@ -778,9 +778,9 @@ Exception in thread "main" java.util.concurrent.TimeoutException 1. 如果当前运行的线程数少于 `corePoolSize`,则创建一个新的线程执行任务; 2. 当前线程池中有一个运行的线程后,将任务加入 `LinkedBlockingQueue` -3. 线程执行完当前的任务后,会在循环中反复从`LinkedBlockingQueue` 中获取任务来执行; +3. 线程执行完当前的任务后,会在循环中反复从 `LinkedBlockingQueue` 中获取任务来执行; -#### 为什么不推荐使用`SingleThreadExecutor`? +#### 为什么不推荐使用 `SingleThreadExecutor`? `SingleThreadExecutor` 和 `FixedThreadPool` 一样,使用的都是容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`(无界队列)。`SingleThreadExecutor` 使用无界队列作为线程池的工作队列会对线程池带来的影响与 `FixedThreadPool` 相同。说简单点,就是可能会导致 OOM。 @@ -811,7 +811,7 @@ Exception in thread "main" java.util.concurrent.TimeoutException } ``` -`CachedThreadPool` 的`corePoolSize` 被设置为空(0),`maximumPoolSize`被设置为 `Integer.MAX_VALUE`,即它是无界的,这也就意味着如果主线程提交任务的速度高于 `maximumPool` 中线程处理任务的速度时,`CachedThreadPool` 会不断创建新的线程。极端情况下,这样会导致耗尽 cpu 和内存资源。 +`CachedThreadPool` 的 `corePoolSize` 被设置为空(0),`maximumPoolSize` 被设置为 `Integer.MAX_VALUE`,即它是无界的,这也就意味着如果主线程提交任务的速度高于 `maximumPool` 中线程处理任务的速度时,`CachedThreadPool` 会不断创建新的线程。极端情况下,这样会导致耗尽 cpu 和内存资源。 #### 执行任务过程介绍 @@ -821,12 +821,12 @@ Exception in thread "main" java.util.concurrent.TimeoutException **上图说明:** -1. 首先执行 `SynchronousQueue.offer(Runnable task)` 提交任务到任务队列。如果当前 `maximumPool` 中有闲线程正在执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`,那么主线程执行 offer 操作与空闲线程执行的 `poll` 操作配对成功,主线程把任务交给空闲线程执行,`execute()`方法执行完成,否则执行下面的步骤 2; +1. 首先执行 `SynchronousQueue.offer(Runnable task)` 提交任务到任务队列。如果当前 `maximumPool` 中有闲线程正在执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`,那么主线程执行 offer 操作与空闲线程执行的 `poll` 操作配对成功,主线程把任务交给空闲线程执行,`execute()` 方法执行完成,否则执行下面的步骤 2; 2. 当初始 `maximumPool` 为空,或者 `maximumPool` 中没有空闲线程时,将没有线程执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`。这种情况下,步骤 1 将失败,此时 `CachedThreadPool` 会创建新线程执行任务,execute 方法执行完成; -#### 为什么不推荐使用`CachedThreadPool`? +#### 为什么不推荐使用 `CachedThreadPool`? -`CachedThreadPool` 使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE` ,可能会创建大量线程,从而导致 OOM。 +`CachedThreadPool` 使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE`,可能会创建大量线程,从而导致 OOM。 ### ScheduledThreadPool @@ -844,7 +844,7 @@ public ScheduledThreadPoolExecutor(int corePoolSize) { } ``` -`ScheduledThreadPool` 是通过 `ScheduledThreadPoolExecutor` 创建的,使用的`DelayedWorkQueue`(延迟阻塞队列)作为线程池的任务队列。 +`ScheduledThreadPool` 是通过 `ScheduledThreadPoolExecutor` 创建的,使用的 `DelayedWorkQueue`(延迟阻塞队列)作为线程池的任务队列。 `DelayedWorkQueue` 的内部元素并不是按照放入的时间排序,而是会按照延迟的时间长短对任务进行排序,内部采用的是“堆”的数据结构,可以保证每次出队的任务都是当前队列中执行时间最靠前的。`DelayedWorkQueue` 添加元素满了之后会自动扩容原来容量的 1/2,即永远不会阻塞,最大扩容可达 `Integer.MAX_VALUE`,所以最多只能创建核心线程数的线程。 @@ -858,11 +858,11 @@ public class ScheduledThreadPoolExecutor #### ScheduledThreadPoolExecutor 和 Timer 对比 -- `Timer` 对系统时钟的变化敏感,`ScheduledThreadPoolExecutor`不是; +- `Timer` 对系统时钟的变化敏感,`ScheduledThreadPoolExecutor` 不是; - `Timer` 只有一个执行线程,因此长时间运行的任务可以延迟其他任务。 `ScheduledThreadPoolExecutor` 可以配置任意数量的线程。 此外,如果你想(通过提供 `ThreadFactory`),你可以完全控制创建的线程; -- 在`TimerTask` 中抛出的运行时异常会杀死一个线程,从而导致 `Timer` 死机即计划任务将不再运行。`ScheduledThreadExecutor` 不仅捕获运行时异常,还允许您在需要时处理它们(通过重写 `afterExecute` 方法`ThreadPoolExecutor`)。抛出异常的任务将被取消,但其他任务将继续运行。 +- 在 `TimerTask` 中抛出的运行时异常会杀死一个线程,从而导致 `Timer` 死机即计划任务将不再运行。`ScheduledThreadExecutor` 不仅捕获运行时异常,还允许您在需要时处理它们(通过重写 `afterExecute` 方法 `ThreadPoolExecutor`)。抛出异常的任务将被取消,但其他任务将继续运行。 -关于定时任务的详细介绍,可以看这篇文章:[Java 定时任务详解](https://javaguide.cn/system-design/schedule-task.html) 。 +关于定时任务的详细介绍,可以看这篇文章:[Java 定时任务详解](https://javaguide.cn/system-design/schedule-task.html)。 ## 线程池最佳实践 diff --git a/docs/java/concurrent/jmm.md b/docs/java/concurrent/jmm.md index 578381714cf..c2c614fd19c 100644 --- a/docs/java/concurrent/jmm.md +++ b/docs/java/concurrent/jmm.md @@ -32,7 +32,7 @@ JMM 主要定义了对于一个共享变量,当一个线程执行写操作后 现代的 CPU Cache 通常分为三层,分别叫 L1,L2,L3 Cache。有些 CPU 可能还有 L4 Cache,这里不做讨论,并不常见 -**CPU Cache 的工作方式:** 先复制一份数据到 CPU Cache 中,当 CPU 需要用到的时候就可以直接从 CPU Cache 中读取数据,当运算完成后,再将运算得到的数据写回 Main Memory 中。但是,这样存在 **内存缓存不一致性的问题** !比如我执行一个 i++ 操作的话,如果两个线程同时执行的话,假设两个线程从 CPU Cache 中读取的 i=1,两个线程做了 i++ 运算完之后再写回 Main Memory 之后 i=2,而正确结果应该是 i=3。 +**CPU Cache 的工作方式:** 先复制一份数据到 CPU Cache 中,当 CPU 需要用到的时候就可以直接从 CPU Cache 中读取数据,当运算完成后,再将运算得到的数据写回 Main Memory 中。但是,这样存在 **内存缓存不一致性的问题**!比如我执行一个 i++ 操作的话,如果两个线程同时执行的话,假设两个线程从 CPU Cache 中读取的 i=1,两个线程做了 i++ 运算完之后再写回 Main Memory 之后 i=2,而正确结果应该是 i=3。 **CPU 为了解决内存缓存不一致性问题可以通过制定缓存一致协议(比如 [MESI 协议](https://zh.wikipedia.org/wiki/MESI%E5%8D%8F%E8%AE%AE))或者其他手段来解决。** 这个缓存一致性协议指的是在 CPU 高速缓存与主内存交互的时候需要遵守的原则和规范。不同的 CPU 中,使用的缓存一致性协议通常也会有所不同。 @@ -44,7 +44,7 @@ JMM 主要定义了对于一个共享变量,当一个线程执行写操作后 ## 指令重排序 -说完了 CPU 缓存模型,我们再来看看另外一个比较重要的概念 **指令重排序** 。 +说完了 CPU 缓存模型,我们再来看看另外一个比较重要的概念 **指令重排序**。 为了提升执行速度/性能,计算机在执行程序代码的时候,会对指令进行重排序。 @@ -59,7 +59,7 @@ JMM 主要定义了对于一个共享变量,当一个线程执行写操作后 Java 源代码会经历 **编译器优化重排 —> 指令并行重排 —> 内存系统重排** 的过程,最终才变成操作系统可执行的指令序列。 -**指令重排序可以保证串行语义一致,但是没有义务保证多线程间的语义也一致** ,所以在多线程下,指令重排序可能会导致一些问题。 +**指令重排序可以保证串行语义一致,但是没有义务保证多线程间的语义也一致**,所以在多线程下,指令重排序可能会导致一些问题。 对于编译器优化重排和处理器的指令重排序(指令并行重排和内存系统重排都属于是处理器级别的指令重排序),处理该问题的方式不一样。 @@ -73,7 +73,7 @@ Java 源代码会经历 **编译器优化重排 —> 指令并行重排 —> 内 ### 什么是 JMM?为什么需要 JMM? -Java 是最早尝试提供内存模型的编程语言。由于早期内存模型存在一些缺陷(比如非常容易削弱编译器的优化能力),从 Java5 开始,Java 开始使用新的内存模型 [《JSR-133:Java Memory Model and Thread Specification》](http://www.cs.umd.edu/~pugh/java/memoryModel/CommunityReview.pdf) 。 +Java 是最早尝试提供内存模型的编程语言。由于早期内存模型存在一些缺陷(比如非常容易削弱编译器的优化能力),从 Java5 开始,Java 开始使用新的内存模型 [《JSR-133:Java Memory Model and Thread Specification》](http://www.cs.umd.edu/~pugh/java/memoryModel/CommunityReview.pdf)。 一般来说,编程语言也可以直接复用操作系统层面的内存模型。不过,不同的操作系统内存模型不同。如果直接复用操作系统层面的内存模型,就可能会导致同样一套代码换了一个操作系统就无法执行了。Java 语言是跨平台的,它需要自己提供一套内存模型以屏蔽系统差异。 @@ -87,7 +87,7 @@ JMM 说白了就是定义了一些规范来解决这些问题,开发者可以 **Java 内存模型(JMM)** 抽象了线程和主内存之间的关系,就比如说线程之间的共享变量必须存储在主内存中。 -在 JDK1.2 之前,Java 的内存模型实现总是从 **主存** (即共享内存)读取变量,是不需要进行特别的注意的。而在当前的 Java 内存模型下,线程可以把变量保存 **本地内存** (比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。 +在 JDK1.2 之前,Java 的内存模型实现总是从 **主存**(即共享内存)读取变量,是不需要进行特别的注意的。而在当前的 Java 内存模型下,线程可以把变量保存 **本地内存**(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。 这和我们上面讲到的 CPU 缓存模型非常相似。 @@ -117,8 +117,8 @@ Java 内存模型的抽象示意图如下: - **锁定(lock)**: 作用于主内存中的变量,将他标记为一个线程独享变量。 - **解锁(unlock)**: 作用于主内存中的变量,解除变量的锁定状态,被解除锁定状态的变量才能被其他线程锁定。 - **read(读取)**:作用于主内存的变量,它把一个变量的值从主内存传输到线程的工作内存中,以便随后的 load 动作使用。 -- **load(载入)**:把 read 操作从主内存中得到的变量值放入工作内存的变量的副本中。 -- **use(使用)**:把工作内存中的一个变量的值传给执行引擎,每当虚拟机遇到一个使用到变量的指令时都会使用该指令。 +- **load(载入)**:把 read 操作从主内存中得到的变量值放入工作内存的变量的副本中。 +- **use(使用)**:把工作内存中的一个变量的值传给执行引擎,每当虚拟机遇到一个使用到变量的指令时都会使用该指令。 - **assign(赋值)**:作用于工作内存的变量,它把一个从执行引擎接收到的值赋给工作内存的变量,每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。 - **store(存储)**:作用于工作内存的变量,它把工作内存中一个变量的值传送到主内存中,以便随后的 write 操作使用。 - **write(写入)**:作用于主内存的变量,它把 store 操作从工作内存中得到的变量的值放入主内存的变量中。 @@ -141,7 +141,7 @@ Java 内存模型的抽象示意图如下: ### happens-before 原则是什么? -happens-before 这个概念最早诞生于 Leslie Lamport 于 1978 年发表的论文[《Time,Clocks and the Ordering of Events in a Distributed System》](https://lamport.azurewebsites.net/pubs/time-clocks.pdf)。在这篇论文中,Leslie Lamport 提出了[逻辑时钟](https://writings.sh/post/logical-clocks)的概念,这也成了第一个逻辑时钟算法 。在分布式环境中,通过一系列规则来定义逻辑时钟的变化,从而能通过逻辑时钟来对分布式系统中的事件的先后顺序进行判断。**逻辑时钟并不度量时间本身,仅区分事件发生的前后顺序,其本质就是定义了一种 happens-before 关系。** +happens-before 这个概念最早诞生于 Leslie Lamport 于 1978 年发表的论文[《Time,Clocks and the Ordering of Events in a Distributed System》](https://lamport.azurewebsites.net/pubs/time-clocks.pdf)。在这篇论文中,Leslie Lamport 提出了[逻辑时钟](https://writings.sh/post/logical-clocks)的概念,这也成了第一个逻辑时钟算法。在分布式环境中,通过一系列规则来定义逻辑时钟的变化,从而能通过逻辑时钟来对分布式系统中的事件的先后顺序进行判断。**逻辑时钟并不度量时间本身,仅区分事件发生的前后顺序,其本质就是定义了一种 happens-before 关系。** 上面提到的 happens-before 这个概念诞生的背景并不是重点,简单了解即可。 @@ -152,7 +152,7 @@ JSR 133 引入了 happens-before 这个概念来描述两个操作之间的内 - 为了对编译器和处理器的约束尽可能少,只要不改变程序的执行结果(单线程程序和正确执行的多线程程序),编译器和处理器怎么进行重排序优化都行。 - 对于会改变程序执行结果的重排序,JMM 要求编译器和处理器必须禁止这种重排序。 -下面这张是我根据 《Java 并发编程的艺术》这本书中的一张 JMM 设计思想示意图重新绘制的。 +下面这张是我根据《Java 并发编程的艺术》这本书中的一张 JMM 设计思想示意图重新绘制的。 ![ JMM 设计思想](https://oss.javaguide.cn/github/javaguide/java/concurrent/jmm-design-idea.png) @@ -173,7 +173,7 @@ int totalNum = userNum + teacherNum; // 3 - 2 happens-before 3 - 1 happens-before 3 -虽然 1 happens-before 2,但对 1 和 2 进行重排序不会影响代码的执行结果,所以 JMM 是允许编译器和处理器执行这种重排序的。但 1 和 2 必须是在 3 执行之前,也就是说 1,2 happens-before 3 。 +虽然 1 happens-before 2,但对 1 和 2 进行重排序不会影响代码的执行结果,所以 JMM 是允许编译器和处理器执行这种重排序的。但 1 和 2 必须是在 3 执行之前,也就是说 1,2 happens-before 3。 **happens-before 原则表达的意义其实并不是一个操作发生在另外一个操作的前面,虽然这从程序员的角度上来说也并无大碍。更准确地来说,它更想表达的意义是前一个操作的结果对于后一个操作是可见的,无论这两个操作是否在同一个线程里。** @@ -187,7 +187,7 @@ happens-before 的规则就 8 条,说多不多,重点了解下面列举的 5 2. **解锁规则**:解锁 happens-before 于加锁; 3. **volatile 变量规则**:对一个 volatile 变量的写操作 happens-before 于后面对这个 volatile 变量的读操作。说白了就是对 volatile 变量的写操作的结果对于发生于其后的任何操作都是可见的。 4. **传递规则**:如果 A happens-before B,且 B happens-before C,那么 A happens-before C; -5. **线程启动规则**:Thread 对象的 `start()`方法 happens-before 于此线程的每一个动作。 +5. **线程启动规则**:Thread 对象的 `start()` 方法 happens-before 于此线程的每一个动作。 如果两个操作不满足上述任意一个 happens-before 规则,那么这两个操作就没有顺序的保障,JVM 可以对这两个操作进行重排序。 @@ -209,17 +209,17 @@ happens-before 与 JMM 的关系如下图所示: 一次操作或者多次操作,要么所有的操作全部都得到执行并且不会受到任何因素的干扰而中断,要么都不执行。 -在 Java 中,可以借助`synchronized`、各种 `Lock` 以及各种原子类实现原子性。 +在 Java 中,可以借助 `synchronized`、各种 `Lock` 以及各种原子类实现原子性。 -`synchronized` 和各种 `Lock` 可以保证任一时刻只有一个线程访问该代码块,因此可以保障原子性。各种原子类是利用 CAS (compare and swap) 操作(可能也会用到 `volatile`或者`final`关键字)来保证原子操作。 +`synchronized` 和各种 `Lock` 可以保证任一时刻只有一个线程访问该代码块,因此可以保障原子性。各种原子类是利用 CAS (compare and swap) 操作(可能也会用到 `volatile` 或者 `final` 关键字)来保证原子操作。 ### 可见性 当一个线程对共享变量进行了修改,那么另外的线程都是立即可以看到修改后的最新值。 -在 Java 中,可以借助`synchronized`、`volatile` 以及各种 `Lock` 实现可见性。 +在 Java 中,可以借助 `synchronized`、`volatile` 以及各种 `Lock` 实现可见性。 -如果我们将变量声明为 `volatile` ,这就指示 JVM,这个变量是共享且不稳定的,每次使用它都到主存中进行读取。 +如果我们将变量声明为 `volatile`,这就指示 JVM,这个变量是共享且不稳定的,每次使用它都到主存中进行读取。 ### 有序性 @@ -227,7 +227,7 @@ happens-before 与 JMM 的关系如下图所示: 我们上面讲重排序的时候也提到过: -> **指令重排序可以保证串行语义一致,但是没有义务保证多线程间的语义也一致** ,所以在多线程下,指令重排序可能会导致一些问题。 +> **指令重排序可以保证串行语义一致,但是没有义务保证多线程间的语义也一致**,所以在多线程下,指令重排序可能会导致一些问题。 在 Java 中,`volatile` 关键字可以禁止指令进行重排序优化。 @@ -235,7 +235,7 @@ happens-before 与 JMM 的关系如下图所示: - Java 是最早尝试提供内存模型的语言,其主要目的是为了简化多线程编程,增强程序可移植性的。 - CPU 可以通过制定缓存一致协议(比如 [MESI 协议](https://zh.wikipedia.org/wiki/MESI%E5%8D%8F%E8%AE%AE))来解决内存缓存不一致性问题。 -- 为了提升执行速度/性能,计算机在执行程序代码的时候,会对指令进行重排序。 简单来说就是系统在执行代码的时候并不一定是按照你写的代码的顺序依次执行。**指令重排序可以保证串行语义一致,但是没有义务保证多线程间的语义也一致** ,所以在多线程下,指令重排序可能会导致一些问题。 +- 为了提升执行速度/性能,计算机在执行程序代码的时候,会对指令进行重排序。 简单来说就是系统在执行代码的时候并不一定是按照你写的代码的顺序依次执行。**指令重排序可以保证串行语义一致,但是没有义务保证多线程间的语义也一致**,所以在多线程下,指令重排序可能会导致一些问题。 - 你可以把 JMM 看作是 Java 定义的并发编程相关的一组规范,除了抽象了线程和主内存之间的关系之外,其还规定了从 Java 源代码到 CPU 可执行指令的这个转化过程要遵守哪些和并发相关的原则和规范,其主要目的是为了简化多线程编程,增强程序可移植性的。 - JSR 133 引入了 happens-before 这个概念来描述两个操作之间的内存可见性。 diff --git a/docs/java/concurrent/optimistic-lock-and-pessimistic-lock.md b/docs/java/concurrent/optimistic-lock-and-pessimistic-lock.md index da10fa55a1e..0b4adede8ef 100644 --- a/docs/java/concurrent/optimistic-lock-and-pessimistic-lock.md +++ b/docs/java/concurrent/optimistic-lock-and-pessimistic-lock.md @@ -14,9 +14,9 @@ head: ## 什么是悲观锁? -悲观锁总是假设最坏的情况,认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改),所以每次在获取资源操作的时候都会上锁,这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说,**共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程**。 +悲观锁总是假设最坏的情况,认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改),所以每次在获取资源操作的时候都会上锁,这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说,**共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程**。 -像 Java 中`synchronized`和`ReentrantLock`等独占锁就是悲观锁思想的实现。 +像 Java 中 `synchronized` 和 `ReentrantLock` 等独占锁就是悲观锁思想的实现。 ```java public void performSynchronisedTask() { @@ -40,7 +40,7 @@ try { 乐观锁总是假设最好的情况,认为共享资源每次被访问的时候不会出现问题,线程可以不停地执行,无需加锁也无需等待,只是在提交修改的时候去验证对应的资源(也就是数据)是否被其它线程修改了(具体方法可以使用版本号机制或 CAS 算法)。 -在 Java 中`java.util.concurrent.atomic`包下面的原子变量类(比如`AtomicInteger`、`LongAdder`)就是使用了乐观锁的一种实现方式 **CAS** 实现的。 +在 Java 中 `java.util.concurrent.atomic` 包下面的原子变量类(比如 `AtomicInteger`、`LongAdder`)就是使用了乐观锁的一种实现方式 **CAS** 实现的。 ![JUC原子类概览](https://oss.javaguide.cn/github/javaguide/java/JUC%E5%8E%9F%E5%AD%90%E7%B1%BB%E6%A6%82%E8%A7%88-20230814005211968.png) ```java @@ -52,12 +52,12 @@ sum.increment(); 高并发的场景下,乐观锁相比悲观锁来说,不存在锁竞争造成线程阻塞,也不会有死锁问题,在性能上往往会更胜一筹。但是,如果冲突频繁发生(写占比非常多的情况),会频繁失败并重试,这样同样会非常影响性能,导致 CPU 飙升。 -不过,大量失败重试的问题也是可以解决的,像我们前面提到的 `LongAdder`以空间换时间的方式就解决了这个问题。 +不过,大量失败重试的问题也是可以解决的,像我们前面提到的 `LongAdder` 以空间换时间的方式就解决了这个问题。 理论上来说: -- 悲观锁通常多用于写比较多的情况(多写场景,竞争激烈),这样可以避免频繁失败和重试影响性能,悲观锁的开销是固定的。不过,如果乐观锁解决了频繁失败和重试这个问题的话(比如`LongAdder`),也是可以考虑使用乐观锁的,要视实际情况而定。 -- 乐观锁通常多用于写比较少的情况(多读场景,竞争较少),这样可以避免频繁加锁影响性能。不过,乐观锁主要针对的对象是单个共享变量(参考`java.util.concurrent.atomic`包下面的原子变量类)。 +- 悲观锁通常多用于写比较多的情况(多写场景,竞争激烈),这样可以避免频繁失败和重试影响性能,悲观锁的开销是固定的。不过,如果乐观锁解决了频繁失败和重试这个问题的话(比如 `LongAdder`),也是可以考虑使用乐观锁的,要视实际情况而定。 +- 乐观锁通常多用于写比较少的情况(多读场景,竞争较少),这样可以避免频繁加锁影响性能。不过,乐观锁主要针对的对象是单个共享变量(参考 `java.util.concurrent.atomic` 包下面的原子变量类)。 ## 如何实现乐观锁? @@ -67,18 +67,18 @@ sum.increment(); 一般是在数据表中加上一个数据版本号 `version` 字段,表示数据被修改的次数。当数据被修改时,`version` 值会加一。当线程 A 要更新数据值时,在读取数据的同时也会读取 `version` 值,在提交更新时,若刚才读取到的 version 值为当前数据库中的 `version` 值相等时才更新,否则重试更新操作,直到更新成功。 -**举一个简单的例子**:假设数据库中帐户信息表中有一个 version 字段,当前值为 1 ;而当前帐户余额字段( `balance` )为 \$100 。 +**举一个简单的例子**:假设数据库中帐户信息表中有一个 version 字段,当前值为 1;而当前帐户余额字段(`balance`)为 \$100。 -1. 操作员 A 此时将其读出( `version`=1 ),并从其帐户余额中扣除 $50( $100-\$50 )。 -2. 在操作员 A 操作的过程中,操作员 B 也读入此用户信息( `version`=1 ),并从其帐户余额中扣除 $20 ( $100-\$20 )。 -3. 操作员 A 完成了修改工作,将数据版本号( `version`=1 ),连同帐户扣除后余额( `balance`=\$50 ),提交至数据库更新,此时由于提交数据版本等于数据库记录当前版本,数据被更新,数据库记录 `version` 更新为 2 。 -4. 操作员 B 完成了操作,也将版本号( `version`=1 )试图向数据库提交数据( `balance`=\$80 ),但此时比对数据库记录版本时发现,操作员 B 提交的数据版本号为 1 ,而数据库记录当前版本为 2 ,不满足 “ 提交版本必须等于当前版本才能执行更新 ” 的乐观锁策略,因此,操作员 B 的提交被驳回。 +1. 操作员 A 此时将其读出(`version`=1),并从其帐户余额中扣除 $50($100-\$50)。 +2. 在操作员 A 操作的过程中,操作员 B 也读入此用户信息(`version`=1),并从其帐户余额中扣除 $20($100-\$20)。 +3. 操作员 A 完成了修改工作,将数据版本号(`version`=1),连同帐户扣除后余额(`balance`=\$50),提交至数据库更新,此时由于提交数据版本等于数据库记录当前版本,数据被更新,数据库记录 `version` 更新为 2。 +4. 操作员 B 完成了操作,也将版本号(`version`=1)试图向数据库提交数据(`balance`=\$80),但此时比对数据库记录版本时发现,操作员 B 提交的数据版本号为 1,而数据库记录当前版本为 2,不满足 “ 提交版本必须等于当前版本才能执行更新 ” 的乐观锁策略,因此,操作员 B 的提交被驳回。 这样就避免了操作员 B 用基于 `version`=1 的旧数据修改的结果覆盖操作员 A 的操作结果的可能。 ### CAS 算法 -CAS 的全称是 **Compare And Swap(比较与交换)** ,用于实现乐观锁,被广泛应用于各大框架中。CAS 的思想很简单,就是用一个预期值和要更新的变量值进行比较,两值相等才会进行更新。 +CAS 的全称是 **Compare And Swap(比较与交换)**,用于实现乐观锁,被广泛应用于各大框架中。CAS 的思想很简单,就是用一个预期值和要更新的变量值进行比较,两值相等才会进行更新。 CAS 是一个原子操作,底层依赖于一条 CPU 的原子指令。 @@ -94,7 +94,7 @@ CAS 涉及到三个操作数: **举一个简单的例子**:线程 A 要修改变量 i 的值为 6,i 原值为 1(V = 1,E=1,N=6,假设不存在 ABA 问题)。 -1. i 与 1 进行比较,如果相等, 则说明没被其他线程修改,可以被设置为 6 。 +1. i 与 1 进行比较,如果相等, 则说明没被其他线程修改,可以被设置为 6。 2. i 与 1 进行比较,如果不相等,则说明被其他线程修改,当前线程放弃更新,CAS 操作失败。 当多个线程同时使用 CAS 操作一个变量时,只有一个会胜出,并成功更新,其余均会失败,但失败的线程并不会被挂起,仅是被告知失败,并且允许再次尝试,当然也允许失败的线程放弃操作。 diff --git a/docs/java/concurrent/reentrantlock.md b/docs/java/concurrent/reentrantlock.md index 7e4490057c9..5016a7d0805 100644 --- a/docs/java/concurrent/reentrantlock.md +++ b/docs/java/concurrent/reentrantlock.md @@ -223,7 +223,7 @@ private volatile int state; ![](https://p1.meituan.net/travelcube/b8b53a70984668bc68653efe9531573e78636.png) -> 🐛 修正(参见:[issue#1761](https://github.com/Snailclimb/JavaGuide/issues/1761)): 图中的一处小错误,(AQS)CAS 修改共享资源 State 成功之后应该是获取锁成功(非公平锁)。 +> 🐛 修正(参见:[issue#1761](https://github.com/Snailclimb/JavaGuide/issues/1761)): 图中的一处小错误,(AQS)CAS 修改共享资源 State 成功之后应该是获取锁成功(非公平锁)。 > > 对应的源码如下: > diff --git a/docs/java/concurrent/threadlocal.md b/docs/java/concurrent/threadlocal.md index 5a92034bbb0..8a4ba1f0f09 100644 --- a/docs/java/concurrent/threadlocal.md +++ b/docs/java/concurrent/threadlocal.md @@ -18,28 +18,28 @@ head: **全文共 10000+字,31 张图,这篇文章同样耗费了不少的时间和精力才创作完成,原创不易,请大家点点关注+在看,感谢。** -对于`ThreadLocal`,大家的第一反应可能是很简单呀,线程的变量副本,每个线程隔离。那这里有几个问题大家可以思考一下: - -- `ThreadLocal`的 key 是**弱引用**,那么在 `ThreadLocal.get()`的时候,发生**GC**之后,key 是否为**null**? -- `ThreadLocal`中`ThreadLocalMap`的**数据结构**? -- `ThreadLocalMap`的**Hash 算法**? -- `ThreadLocalMap`中**Hash 冲突**如何解决? -- `ThreadLocalMap`的**扩容机制**? -- `ThreadLocalMap`中**过期 key 的清理机制**?**探测式清理**和**启发式清理**流程? -- `ThreadLocalMap.set()`方法实现原理? -- `ThreadLocalMap.get()`方法实现原理? -- 项目中`ThreadLocal`使用情况?遇到的坑? +对于 `ThreadLocal`,大家的第一反应可能是很简单呀,线程的变量副本,每个线程隔离。那这里有几个问题大家可以思考一下: + +- `ThreadLocal` 的 key 是**弱引用**,那么在 `ThreadLocal.get()` 的时候,发生**GC**之后,key 是否为**null**? +- `ThreadLocal` 中 `ThreadLocalMap` 的**数据结构**? +- `ThreadLocalMap` 的**Hash 算法**? +- `ThreadLocalMap` 中**Hash 冲突**如何解决? +- `ThreadLocalMap` 的**扩容机制**? +- `ThreadLocalMap` 中**过期 key 的清理机制**?**探测式清理**和**启发式清理**流程? +- `ThreadLocalMap.set()` 方法实现原理? +- `ThreadLocalMap.get()` 方法实现原理? +- 项目中 `ThreadLocal` 使用情况?遇到的坑? - …… -上述的一些问题你是否都已经掌握的很清楚了呢?本文将围绕这些问题使用图文方式来剖析`ThreadLocal`的**点点滴滴**。 +上述的一些问题你是否都已经掌握的很清楚了呢?本文将围绕这些问题使用图文方式来剖析 `ThreadLocal` 的**点点滴滴**。 ### 目录 -**注明:** 本文源码基于`JDK 1.8` +**注明:** 本文源码基于 `JDK 1.8` -### `ThreadLocal`代码演示 +### `ThreadLocal` 代码演示 -我们先看下`ThreadLocal`使用示例: +我们先看下 `ThreadLocal` 使用示例: ```java public class ThreadLocalTest { @@ -74,34 +74,34 @@ public class ThreadLocalTest { size: 0 ``` -`ThreadLocal`对象可以提供线程局部变量,每个线程`Thread`拥有一份自己的**副本变量**,多个线程互不干扰。 +`ThreadLocal` 对象可以提供线程局部变量,每个线程 `Thread` 拥有一份自己的**副本变量**,多个线程互不干扰。 -### `ThreadLocal`的数据结构 +### `ThreadLocal` 的数据结构 ![](./images/thread-local/2.png) -`Thread`类有一个类型为`ThreadLocal.ThreadLocalMap`的实例变量`threadLocals`,也就是说每个线程有一个自己的`ThreadLocalMap`。 +`Thread` 类有一个类型为 `ThreadLocal.ThreadLocalMap` 的实例变量 `threadLocals`,也就是说每个线程有一个自己的 `ThreadLocalMap`。 -`ThreadLocalMap`有自己的独立实现,可以简单地将它的`key`视作`ThreadLocal`,`value`为代码中放入的值(实际上`key`并不是`ThreadLocal`本身,而是它的一个**弱引用**)。 +`ThreadLocalMap` 有自己的独立实现,可以简单地将它的 `key` 视作 `ThreadLocal`,`value` 为代码中放入的值(实际上 `key` 并不是 `ThreadLocal` 本身,而是它的一个**弱引用**)。 -每个线程在往`ThreadLocal`里放值的时候,都会往自己的`ThreadLocalMap`里存,读也是以`ThreadLocal`作为引用,在自己的`map`里找对应的`key`,从而实现了**线程隔离**。 +每个线程在往 `ThreadLocal` 里放值的时候,都会往自己的 `ThreadLocalMap` 里存,读也是以 `ThreadLocal` 作为引用,在自己的 `map` 里找对应的 `key`,从而实现了**线程隔离**。 -`ThreadLocalMap`有点类似`HashMap`的结构,只是`HashMap`是由**数组+链表**实现的,而`ThreadLocalMap`中并没有**链表**结构。 +`ThreadLocalMap` 有点类似 `HashMap` 的结构,只是 `HashMap` 是由**数组+链表**实现的,而 `ThreadLocalMap` 中并没有**链表**结构。 -我们还要注意`Entry`, 它的`key`是`ThreadLocal k` ,继承自`WeakReference`, 也就是我们常说的弱引用类型。 +我们还要注意 `Entry`, 它的 `key` 是 `ThreadLocal k`,继承自 `WeakReference`, 也就是我们常说的弱引用类型。 ### GC 之后 key 是否为 null? -回应开头的那个问题, `ThreadLocal` 的`key`是弱引用,那么在`ThreadLocal.get()`的时候,发生`GC`之后,`key`是否是`null`? +回应开头的那个问题, `ThreadLocal` 的 `key` 是弱引用,那么在 `ThreadLocal.get()` 的时候,发生 `GC` 之后,`key` 是否是 `null`? -为了搞清楚这个问题,我们需要搞清楚`Java`的**四种引用类型**: +为了搞清楚这个问题,我们需要搞清楚 `Java` 的**四种引用类型**: - **强引用**:我们常常 new 出来的对象就是强引用类型,只要强引用存在,垃圾回收器将永远不会回收被引用的对象,哪怕内存不足的时候 - **软引用**:使用 SoftReference 修饰的对象被称为软引用,软引用指向的对象在内存要溢出的时候被回收 - **弱引用**:使用 WeakReference 修饰的对象被称为弱引用,只要发生垃圾回收,若这个对象只被弱引用指向,那么就会被回收 - **虚引用**:虚引用是最弱的引用,在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知 -接着再来看下代码,我们使用反射的方式来看看`GC`后`ThreadLocal`中的数据情况:(下面代码来源自: 本地运行演示 GC 回收场景) +接着再来看下代码,我们使用反射的方式来看看 `GC` 后 `ThreadLocal` 中的数据情况:(下面代码来源自: 本地运行演示 GC 回收场景) ```java public class ThreadLocalDemo { @@ -159,29 +159,29 @@ public class ThreadLocalDemo { ![](./images/thread-local/3.png) -如图所示,因为这里创建的`ThreadLocal`并没有指向任何值,也就是没有任何引用: +如图所示,因为这里创建的 `ThreadLocal` 并没有指向任何值,也就是没有任何引用: ```java new ThreadLocal<>().set(s); ``` -所以这里在`GC`之后,`key`就会被回收,我们看到上面`debug`中的`referent=null`, 如果**改动一下代码:** +所以这里在 `GC` 之后,`key` 就会被回收,我们看到上面 `debug` 中的 `referent=null`, 如果**改动一下代码:** ![](./images/thread-local/4.png) -这个问题刚开始看,如果没有过多思考,**弱引用**,还有**垃圾回收**,那么肯定会觉得是`null`。 +这个问题刚开始看,如果没有过多思考,**弱引用**,还有**垃圾回收**,那么肯定会觉得是 `null`。 -其实是不对的,因为题目说的是在做 `ThreadLocal.get()` 操作,证明其实还是有**强引用**存在的,所以 `key` 并不为 `null`,如下图所示,`ThreadLocal`的**强引用**仍然是存在的。 +其实是不对的,因为题目说的是在做 `ThreadLocal.get()` 操作,证明其实还是有**强引用**存在的,所以 `key` 并不为 `null`,如下图所示,`ThreadLocal` 的**强引用**仍然是存在的。 ![](./images/thread-local/5.png) 如果我们的**强引用**不存在的话,那么 `key` 就会被回收,也就是会出现我们 `value` 没被回收,`key` 被回收,导致 `value` 永远存在,出现内存泄漏。 -### `ThreadLocal.set()`方法源码详解 +### `ThreadLocal.set()` 方法源码详解 ![](./images/thread-local/6.png) -`ThreadLocal`中的`set`方法原理如上图所示,很简单,主要是判断`ThreadLocalMap`是否存在,然后使用`ThreadLocal`中的`set`方法进行数据处理。 +`ThreadLocal` 中的 `set` 方法原理如上图所示,很简单,主要是判断 `ThreadLocalMap` 是否存在,然后使用 `ThreadLocal` 中的 `set` 方法进行数据处理。 代码如下: @@ -200,19 +200,19 @@ void createMap(Thread t, T firstValue) { } ``` -主要的核心逻辑还是在`ThreadLocalMap`中的,一步步往下看,后面还有更详细的剖析。 +主要的核心逻辑还是在 `ThreadLocalMap` 中的,一步步往下看,后面还有更详细的剖析。 ### `ThreadLocalMap` Hash 算法 -既然是`Map`结构,那么`ThreadLocalMap`当然也要实现自己的`hash`算法来解决散列表数组冲突问题。 +既然是 `Map` 结构,那么 `ThreadLocalMap` 当然也要实现自己的 `hash` 算法来解决散列表数组冲突问题。 ```java int i = key.threadLocalHashCode & (len-1); ``` -`ThreadLocalMap`中`hash`算法很简单,这里`i`就是当前 key 在散列表中对应的数组下标位置。 +`ThreadLocalMap` 中 `hash` 算法很简单,这里 `i` 就是当前 key 在散列表中对应的数组下标位置。 -这里最关键的就是`threadLocalHashCode`值的计算,`ThreadLocal`中有一个属性为`HASH_INCREMENT = 0x61c88647` +这里最关键的就是 `threadLocalHashCode` 值的计算,`ThreadLocal` 中有一个属性为 `HASH_INCREMENT = 0x61c88647` ```java public class ThreadLocal { @@ -239,9 +239,9 @@ public class ThreadLocal { } ``` -每当创建一个`ThreadLocal`对象,这个`ThreadLocal.nextHashCode` 这个值就会增长 `0x61c88647` 。 +每当创建一个 `ThreadLocal` 对象,这个 `ThreadLocal.nextHashCode` 这个值就会增长 `0x61c88647`。 -这个值很特殊,它是**斐波那契数** 也叫 **黄金分割数**。`hash`增量为 这个数字,带来的好处就是 `hash` **分布非常均匀**。 +这个值很特殊,它是**斐波那契数** 也叫 **黄金分割数**。`hash` 增量为 这个数字,带来的好处就是 `hash` **分布非常均匀**。 我们自己可以尝试下: @@ -251,87 +251,87 @@ public class ThreadLocal { ### `ThreadLocalMap` Hash 冲突 -> **注明:** 下面所有示例图中,**绿色块**`Entry`代表**正常数据**,**灰色块**代表`Entry`的`key`值为`null`,**已被垃圾回收**。**白色块**表示`Entry`为`null`。 +> **注明:** 下面所有示例图中,**绿色块**`Entry` 代表**正常数据**,**灰色块**代表 `Entry` 的 `key` 值为 `null`,**已被垃圾回收**。**白色块**表示 `Entry` 为 `null`。 -虽然`ThreadLocalMap`中使用了**黄金分割数**来作为`hash`计算因子,大大减少了`Hash`冲突的概率,但是仍然会存在冲突。 +虽然 `ThreadLocalMap` 中使用了**黄金分割数**来作为 `hash` 计算因子,大大减少了 `Hash` 冲突的概率,但是仍然会存在冲突。 -`HashMap`中解决冲突的方法是在数组上构造一个**链表**结构,冲突的数据挂载到链表上,如果链表长度超过一定数量则会转化成**红黑树**。 +`HashMap` 中解决冲突的方法是在数组上构造一个**链表**结构,冲突的数据挂载到链表上,如果链表长度超过一定数量则会转化成**红黑树**。 而 `ThreadLocalMap` 中并没有链表结构,所以这里不能使用 `HashMap` 解决冲突的方式了。 ![](./images/thread-local/7.png) -如上图所示,如果我们插入一个`value=27`的数据,通过 `hash` 计算后应该落入槽位 4 中,而槽位 4 已经有了 `Entry` 数据。 +如上图所示,如果我们插入一个 `value=27` 的数据,通过 `hash` 计算后应该落入槽位 4 中,而槽位 4 已经有了 `Entry` 数据。 此时就会线性向后查找,一直找到 `Entry` 为 `null` 的槽位才会停止查找,将当前元素放入此槽位中。当然迭代过程中还有其他的情况,比如遇到了 `Entry` 不为 `null` 且 `key` 值相等的情况,还有 `Entry` 中的 `key` 值为 `null` 的情况等等都会有不同的处理,后面会一一详细讲解。 -这里还画了一个`Entry`中的`key`为`null`的数据(**Entry=2 的灰色块数据**),因为`key`值是**弱引用**类型,所以会有这种数据存在。在`set`过程中,如果遇到了`key`过期的`Entry`数据,实际上是会进行一轮**探测式清理**操作的,具体操作方式后面会讲到。 +这里还画了一个 `Entry` 中的 `key` 为 `null` 的数据(**Entry=2 的灰色块数据**),因为 `key` 值是**弱引用**类型,所以会有这种数据存在。在 `set` 过程中,如果遇到了 `key` 过期的 `Entry` 数据,实际上是会进行一轮**探测式清理**操作的,具体操作方式后面会讲到。 -### `ThreadLocalMap.set()`详解 +### `ThreadLocalMap.set()` 详解 -#### `ThreadLocalMap.set()`原理图解 +#### `ThreadLocalMap.set()` 原理图解 -看完了`ThreadLocal` **hash 算法**后,我们再来看`set`是如何实现的。 +看完了 `ThreadLocal` **hash 算法**后,我们再来看 `set` 是如何实现的。 -往`ThreadLocalMap`中`set`数据(**新增**或者**更新**数据)分为好几种情况,针对不同的情况我们画图来说明。 +往 `ThreadLocalMap` 中 `set` 数据(**新增**或者**更新**数据)分为好几种情况,针对不同的情况我们画图来说明。 -**第一种情况:** 通过`hash`计算后的槽位对应的`Entry`数据为空: +**第一种情况:** 通过 `hash` 计算后的槽位对应的 `Entry` 数据为空: ![](./images/thread-local/9.png) 这里直接将数据放到该槽位即可。 -**第二种情况:** 槽位数据不为空,`key`值与当前`ThreadLocal`通过`hash`计算获取的`key`值一致: +**第二种情况:** 槽位数据不为空,`key` 值与当前 `ThreadLocal` 通过 `hash` 计算获取的 `key` 值一致: ![](./images/thread-local/10.png) 这里直接更新该槽位的数据。 -**第三种情况:** 槽位数据不为空,往后遍历过程中,在找到`Entry`为`null`的槽位之前,没有遇到`key`过期的`Entry`: +**第三种情况:** 槽位数据不为空,往后遍历过程中,在找到 `Entry` 为 `null` 的槽位之前,没有遇到 `key` 过期的 `Entry`: ![](./images/thread-local/11.png) -遍历散列数组,线性往后查找,如果找到`Entry`为`null`的槽位,则将数据放入该槽位中,或者往后遍历过程中,遇到了**key 值相等**的数据,直接更新即可。 +遍历散列数组,线性往后查找,如果找到 `Entry` 为 `null` 的槽位,则将数据放入该槽位中,或者往后遍历过程中,遇到了**key 值相等**的数据,直接更新即可。 -**第四种情况:** 槽位数据不为空,往后遍历过程中,在找到`Entry`为`null`的槽位之前,遇到`key`过期的`Entry`,如下图,往后遍历过程中,遇到了`index=7`的槽位数据`Entry`的`key=null`: +**第四种情况:** 槽位数据不为空,往后遍历过程中,在找到 `Entry` 为 `null` 的槽位之前,遇到 `key` 过期的 `Entry`,如下图,往后遍历过程中,遇到了 `index=7` 的槽位数据 `Entry` 的 `key=null`: ![](./images/thread-local/12.png) -散列数组下标为 7 位置对应的`Entry`数据`key`为`null`,表明此数据`key`值已经被垃圾回收掉了,此时就会执行`replaceStaleEntry()`方法,该方法含义是**替换过期数据的逻辑**,以**index=7**位起点开始遍历,进行探测式数据清理工作。 +散列数组下标为 7 位置对应的 `Entry` 数据 `key` 为 `null`,表明此数据 `key` 值已经被垃圾回收掉了,此时就会执行 `replaceStaleEntry()` 方法,该方法含义是**替换过期数据的逻辑**,以**index=7**位起点开始遍历,进行探测式数据清理工作。 初始化探测式清理过期数据扫描的开始位置:`slotToExpunge = staleSlot = 7` -以当前`staleSlot`开始 向前迭代查找,找其他过期的数据,然后更新过期数据起始扫描下标`slotToExpunge`。`for`循环迭代,直到碰到`Entry`为`null`结束。 +以当前 `staleSlot` 开始 向前迭代查找,找其他过期的数据,然后更新过期数据起始扫描下标 `slotToExpunge`。`for` 循环迭代,直到碰到 `Entry` 为 `null` 结束。 -如果找到了过期的数据,继续向前迭代,直到遇到`Entry=null`的槽位才停止迭代,如下图所示,**slotToExpunge 被更新为 0**: +如果找到了过期的数据,继续向前迭代,直到遇到 `Entry=null` 的槽位才停止迭代,如下图所示,**slotToExpunge 被更新为 0**: ![](./images/thread-local/13.png) -以当前节点(`index=7`)向前迭代,检测是否有过期的`Entry`数据,如果有则更新`slotToExpunge`值。碰到`null`则结束探测。以上图为例`slotToExpunge`被更新为 0。 +以当前节点(`index=7`)向前迭代,检测是否有过期的 `Entry` 数据,如果有则更新 `slotToExpunge` 值。碰到 `null` 则结束探测。以上图为例 `slotToExpunge` 被更新为 0。 -上面向前迭代的操作是为了更新探测清理过期数据的起始下标`slotToExpunge`的值,这个值在后面会讲解,它是用来判断当前过期槽位`staleSlot`之前是否还有过期元素。 +上面向前迭代的操作是为了更新探测清理过期数据的起始下标 `slotToExpunge` 的值,这个值在后面会讲解,它是用来判断当前过期槽位 `staleSlot` 之前是否还有过期元素。 -接着开始以`staleSlot`位置(`index=7`)向后迭代,**如果找到了相同 key 值的 Entry 数据:** +接着开始以 `staleSlot` 位置(`index=7`)向后迭代,**如果找到了相同 key 值的 Entry 数据:** ![](./images/thread-local/14.png) -从当前节点`staleSlot`向后查找`key`值相等的`Entry`元素,找到后更新`Entry`的值并交换`staleSlot`元素的位置(`staleSlot`位置为过期元素),更新`Entry`数据,然后开始进行过期`Entry`的清理工作,如下图所示: +从当前节点 `staleSlot` 向后查找 `key` 值相等的 `Entry` 元素,找到后更新 `Entry` 的值并交换 `staleSlot` 元素的位置(`staleSlot` 位置为过期元素),更新 `Entry` 数据,然后开始进行过期 `Entry` 的清理工作,如下图所示: ![](https://oss.javaguide.cn/java-guide-blog/view.png)向后遍历过程中,如果没有找到相同 key 值的 Entry 数据: ![](./images/thread-local/15.png) -从当前节点`staleSlot`向后查找`key`值相等的`Entry`元素,直到`Entry`为`null`则停止寻找。通过上图可知,此时`table`中没有`key`值相同的`Entry`。 +从当前节点 `staleSlot` 向后查找 `key` 值相等的 `Entry` 元素,直到 `Entry` 为 `null` 则停止寻找。通过上图可知,此时 `table` 中没有 `key` 值相同的 `Entry`。 -创建新的`Entry`,替换`table[stableSlot]`位置: +创建新的 `Entry`,替换 `table[stableSlot]` 位置: ![](./images/thread-local/16.png) -替换完成后也是进行过期元素清理工作,清理工作主要是有两个方法:`expungeStaleEntry()`和`cleanSomeSlots()`,具体细节后面会讲到,请继续往后看。 +替换完成后也是进行过期元素清理工作,清理工作主要是有两个方法:`expungeStaleEntry()` 和 `cleanSomeSlots()`,具体细节后面会讲到,请继续往后看。 -#### `ThreadLocalMap.set()`源码详解 +#### `ThreadLocalMap.set()` 源码详解 -上面已经用图的方式解析了`set()`实现的原理,其实已经很清晰了,我们接着再看下源码: +上面已经用图的方式解析了 `set()` 实现的原理,其实已经很清晰了,我们接着再看下源码: `java.lang.ThreadLocal`.`ThreadLocalMap.set()`: @@ -364,7 +364,7 @@ private void set(ThreadLocal key, Object value) { } ``` -这里会通过`key`来计算在散列表中的对应位置,然后以当前`key`对应的桶的位置向后查找,找到可以使用的桶。 +这里会通过 `key` 来计算在散列表中的对应位置,然后以当前 `key` 对应的桶的位置向后查找,找到可以使用的桶。 ```java Entry[] tab = table; @@ -376,9 +376,9 @@ int i = key.threadLocalHashCode & (len-1); 1. `k = key` 说明是替换操作,可以使用 2. 碰到一个过期的桶,执行替换逻辑,占用过期桶 -3. 查找过程中,碰到桶中`Entry=null`的情况,直接使用 +3. 查找过程中,碰到桶中 `Entry=null` 的情况,直接使用 -接着就是执行`for`循环遍历,向后查找,我们先看下`nextIndex()`、`prevIndex()`方法实现: +接着就是执行 `for` 循环遍历,向后查找,我们先看下 `nextIndex()`、`prevIndex()` 方法实现: ![](./images/thread-local/17.png) @@ -392,20 +392,20 @@ private static int prevIndex(int i, int len) { } ``` -接着看剩下`for`循环中的逻辑: +接着看剩下 `for` 循环中的逻辑: -1. 遍历当前`key`值对应的桶中`Entry`数据为空,这说明散列数组这里没有数据冲突,跳出`for`循环,直接`set`数据到对应的桶中 -2. 如果`key`值对应的桶中`Entry`数据不为空 - 2.1 如果`k = key`,说明当前`set`操作是一个替换操作,做替换逻辑,直接返回 - 2.2 如果`key = null`,说明当前桶位置的`Entry`是过期数据,执行`replaceStaleEntry()`方法(核心方法),然后返回 -3. `for`循环执行完毕,继续往下执行说明向后迭代的过程中遇到了`entry`为`null`的情况 - 3.1 在`Entry`为`null`的桶中创建一个新的`Entry`对象 - 3.2 执行`++size`操作 -4. 调用`cleanSomeSlots()`做一次启发式清理工作,清理散列数组中`Entry`的`key`过期的数据 - 4.1 如果清理工作完成后,未清理到任何数据,且`size`超过了阈值(数组长度的 2/3),进行`rehash()`操作 - 4.2 `rehash()`中会先进行一轮探测式清理,清理过期`key`,清理完成后如果**size >= threshold - threshold / 4**,就会执行真正的扩容逻辑(扩容逻辑往后看) +1. 遍历当前 `key` 值对应的桶中 `Entry` 数据为空,这说明散列数组这里没有数据冲突,跳出 `for` 循环,直接 `set` 数据到对应的桶中 +2. 如果 `key` 值对应的桶中 `Entry` 数据不为空 + 2.1 如果 `k = key`,说明当前 `set` 操作是一个替换操作,做替换逻辑,直接返回 + 2.2 如果 `key = null`,说明当前桶位置的 `Entry` 是过期数据,执行 `replaceStaleEntry()` 方法(核心方法),然后返回 +3. `for` 循环执行完毕,继续往下执行说明向后迭代的过程中遇到了 `entry` 为 `null` 的情况 + 3.1 在 `Entry` 为 `null` 的桶中创建一个新的 `Entry` 对象 + 3.2 执行 `++size` 操作 +4. 调用 `cleanSomeSlots()` 做一次启发式清理工作,清理散列数组中 `Entry` 的 `key` 过期的数据 + 4.1 如果清理工作完成后,未清理到任何数据,且 `size` 超过了阈值(数组长度的 2/3),进行 `rehash()` 操作 + 4.2 `rehash()` 中会先进行一轮探测式清理,清理过期 `key`,清理完成后如果**size >= threshold - threshold / 4**,就会执行真正的扩容逻辑(扩容逻辑往后看) -接着重点看下`replaceStaleEntry()`方法,`replaceStaleEntry()`方法提供替换过期数据的功能,我们可以对应上面**第四种情况**的原理图来再回顾下,具体代码如下: +接着重点看下 `replaceStaleEntry()` 方法,`replaceStaleEntry()` 方法提供替换过期数据的功能,我们可以对应上面**第四种情况**的原理图来再回顾下,具体代码如下: `java.lang.ThreadLocal.ThreadLocalMap.replaceStaleEntry()`: @@ -454,7 +454,7 @@ private void replaceStaleEntry(ThreadLocal key, Object value, } ``` -`slotToExpunge`表示开始探测式清理过期数据的开始下标,默认从当前的`staleSlot`开始。以当前的`staleSlot`开始,向前迭代查找,找到没有过期的数据,`for`循环一直碰到`Entry`为`null`才会结束。如果向前找到了过期数据,更新探测清理过期数据的开始下标为 i,即`slotToExpunge=i` +`slotToExpunge` 表示开始探测式清理过期数据的开始下标,默认从当前的 `staleSlot` 开始。以当前的 `staleSlot` 开始,向前迭代查找,找到没有过期的数据,`for` 循环一直碰到 `Entry` 为 `null` 才会结束。如果向前找到了过期数据,更新探测清理过期数据的开始下标为 i,即 `slotToExpunge=i` ```java for (int i = prevIndex(staleSlot, len); @@ -467,8 +467,8 @@ for (int i = prevIndex(staleSlot, len); } ``` -接着开始从`staleSlot`向后查找,也是碰到`Entry`为`null`的桶结束。 -如果迭代过程中,**碰到 k == key**,这说明这里是替换逻辑,替换新数据并且交换当前`staleSlot`位置。如果`slotToExpunge == staleSlot`,这说明`replaceStaleEntry()`一开始向前查找过期数据时并未找到过期的`Entry`数据,接着向后查找过程中也未发现过期数据,修改开始探测式清理过期数据的下标为当前循环的 index,即`slotToExpunge = i`。最后调用`cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);`进行启发式过期数据清理。 +接着开始从 `staleSlot` 向后查找,也是碰到 `Entry` 为 `null` 的桶结束。 +如果迭代过程中,**碰到 k == key**,这说明这里是替换逻辑,替换新数据并且交换当前 `staleSlot` 位置。如果 `slotToExpunge == staleSlot`,这说明 `replaceStaleEntry()` 一开始向前查找过期数据时并未找到过期的 `Entry` 数据,接着向后查找过程中也未发现过期数据,修改开始探测式清理过期数据的下标为当前循环的 index,即 `slotToExpunge = i`。最后调用 `cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);` 进行启发式过期数据清理。 ```java if (k == key) { @@ -485,62 +485,62 @@ if (k == key) { } ``` -`cleanSomeSlots()`和`expungeStaleEntry()`方法后面都会细讲,这两个是和清理相关的方法,一个是过期`key`相关`Entry`的启发式清理(`Heuristically scan`),另一个是过期`key`相关`Entry`的探测式清理。 +`cleanSomeSlots()` 和 `expungeStaleEntry()` 方法后面都会细讲,这两个是和清理相关的方法,一个是过期 `key` 相关 `Entry` 的启发式清理(`Heuristically scan`),另一个是过期 `key` 相关 `Entry` 的探测式清理。 -**如果 k != key**则会接着往下走,`k == null`说明当前遍历的`Entry`是一个过期数据,`slotToExpunge == staleSlot`说明,一开始的向前查找数据并未找到过期的`Entry`。如果条件成立,则更新`slotToExpunge` 为当前位置,这个前提是前驱节点扫描时未发现过期数据。 +**如果 k != key**则会接着往下走,`k == null` 说明当前遍历的 `Entry` 是一个过期数据,`slotToExpunge == staleSlot` 说明,一开始的向前查找数据并未找到过期的 `Entry`。如果条件成立,则更新 `slotToExpunge` 为当前位置,这个前提是前驱节点扫描时未发现过期数据。 ```java if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; ``` -往后迭代的过程中如果没有找到`k == key`的数据,且碰到`Entry`为`null`的数据,则结束当前的迭代操作。此时说明这里是一个添加的逻辑,将新的数据添加到`table[staleSlot]` 对应的`slot`中。 +往后迭代的过程中如果没有找到 `k == key` 的数据,且碰到 `Entry` 为 `null` 的数据,则结束当前的迭代操作。此时说明这里是一个添加的逻辑,将新的数据添加到 `table[staleSlot]` 对应的 `slot` 中。 ```java tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); ``` -最后判断除了`staleSlot`以外,还发现了其他过期的`slot`数据,就要开启清理数据的逻辑: +最后判断除了 `staleSlot` 以外,还发现了其他过期的 `slot` 数据,就要开启清理数据的逻辑: ```java if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); ``` -### `ThreadLocalMap`过期 key 的探测式清理流程 +### `ThreadLocalMap` 过期 key 的探测式清理流程 -上面我们有提及`ThreadLocalMap`的两种过期`key`数据清理方式:**探测式清理**和**启发式清理**。 +上面我们有提及 `ThreadLocalMap` 的两种过期 `key` 数据清理方式:**探测式清理**和**启发式清理**。 -我们先讲下探测式清理,也就是`expungeStaleEntry`方法,遍历散列数组,从开始位置向后探测清理过期数据,将过期数据的`Entry`设置为`null`,沿途中碰到未过期的数据则将此数据`rehash`后重新在`table`数组中定位,如果定位的位置已经有了数据,则会将未过期的数据放到最靠近此位置的`Entry=null`的桶中,使`rehash`后的`Entry`数据距离正确的桶的位置更近一些。操作逻辑如下: +我们先讲下探测式清理,也就是 `expungeStaleEntry` 方法,遍历散列数组,从开始位置向后探测清理过期数据,将过期数据的 `Entry` 设置为 `null`,沿途中碰到未过期的数据则将此数据 `rehash` 后重新在 `table` 数组中定位,如果定位的位置已经有了数据,则会将未过期的数据放到最靠近此位置的 `Entry=null` 的桶中,使 `rehash` 后的 `Entry` 数据距离正确的桶的位置更近一些。操作逻辑如下: ![](./images/thread-local/18.png) -如上图,`set(27)` 经过 hash 计算后应该落到`index=4`的桶中,由于`index=4`桶已经有了数据,所以往后迭代最终数据放入到`index=7`的桶中,放入后一段时间后`index=5`中的`Entry`数据`key`变为了`null` +如上图,`set(27)` 经过 hash 计算后应该落到 `index=4` 的桶中,由于 `index=4` 桶已经有了数据,所以往后迭代最终数据放入到 `index=7` 的桶中,放入后一段时间后 `index=5` 中的 `Entry` 数据 `key` 变为了 `null` ![](./images/thread-local/19.png) -如果再有其他数据`set`到`map`中,就会触发**探测式清理**操作。 +如果再有其他数据 `set` 到 `map` 中,就会触发**探测式清理**操作。 -如上图,执行**探测式清理**后,`index=5`的数据被清理掉,继续往后迭代,到`index=7`的元素时,经过`rehash`后发现该元素正确的`index=4`,而此位置已经有了数据,往后查找离`index=4`最近的`Entry=null`的节点(刚被探测式清理掉的数据:`index=5`),找到后移动`index= 7`的数据到`index=5`中,此时桶的位置离正确的位置`index=4`更近了。 +如上图,执行**探测式清理**后,`index=5` 的数据被清理掉,继续往后迭代,到 `index=7` 的元素时,经过 `rehash` 后发现该元素正确的 `index=4`,而此位置已经有了数据,往后查找离 `index=4` 最近的 `Entry=null` 的节点(刚被探测式清理掉的数据:`index=5`),找到后移动 `index= 7` 的数据到 `index=5` 中,此时桶的位置离正确的位置 `index=4` 更近了。 -经过一轮探测式清理后,`key`过期的数据会被清理掉,没过期的数据经过`rehash`重定位后所处的桶位置理论上更接近`i= key.hashCode & (tab.len - 1)`的位置。这种优化会提高整个散列表查询性能。 +经过一轮探测式清理后,`key` 过期的数据会被清理掉,没过期的数据经过 `rehash` 重定位后所处的桶位置理论上更接近 `i= key.hashCode & (tab.len - 1)` 的位置。这种优化会提高整个散列表查询性能。 -接着看下`expungeStaleEntry()`具体流程,我们还是以先原理图后源码讲解的方式来一步步梳理: +接着看下 `expungeStaleEntry()` 具体流程,我们还是以先原理图后源码讲解的方式来一步步梳理: ![](./images/thread-local/20.png) -我们假设`expungeStaleEntry(3)` 来调用此方法,如上图所示,我们可以看到`ThreadLocalMap`中`table`的数据情况,接着执行清理操作: +我们假设 `expungeStaleEntry(3)` 来调用此方法,如上图所示,我们可以看到 `ThreadLocalMap` 中 `table` 的数据情况,接着执行清理操作: ![](./images/thread-local/21.png) -第一步是清空当前`staleSlot`位置的数据,`index=3`位置的`Entry`变成了`null`。然后接着往后探测: +第一步是清空当前 `staleSlot` 位置的数据,`index=3` 位置的 `Entry` 变成了 `null`。然后接着往后探测: ![](./images/thread-local/22.png) 执行完第二步后,index=4 的元素挪到 index=3 的槽位中。 -继续往后迭代检查,碰到正常数据,计算该数据位置是否偏移,如果被偏移,则重新计算`slot`位置,目的是让正常数据尽可能存放在正确位置或离正确位置更近的位置 +继续往后迭代检查,碰到正常数据,计算该数据位置是否偏移,如果被偏移,则重新计算 `slot` 位置,目的是让正常数据尽可能存放在正确位置或离正确位置更近的位置 ![](./images/thread-local/23.png) @@ -580,8 +580,8 @@ private int expungeStaleEntry(int staleSlot) { } ``` -这里我们还是以`staleSlot=3` 来做示例说明,首先是将`tab[staleSlot]`槽位的数据清空,然后设置`size--` -接着以`staleSlot`位置往后迭代,如果遇到`k==null`的过期数据,也是清空该槽位数据,然后`size--` +这里我们还是以 `staleSlot=3` 来做示例说明,首先是将 `tab[staleSlot]` 槽位的数据清空,然后设置 `size--` +接着以 `staleSlot` 位置往后迭代,如果遇到 `k==null` 的过期数据,也是清空该槽位数据,然后 `size--` ```java ThreadLocal k = e.get(); @@ -593,7 +593,7 @@ if (k == null) { } ``` -如果`key`没有过期,重新计算当前`key`的下标位置是不是当前槽位下标位置,如果不是,那么说明产生了`hash`冲突,此时以新计算出来正确的槽位位置往后迭代,找到最近一个可以存放`entry`的位置。 +如果 `key` 没有过期,重新计算当前 `key` 的下标位置是不是当前槽位下标位置,如果不是,那么说明产生了 `hash` 冲突,此时以新计算出来正确的槽位位置往后迭代,找到最近一个可以存放 `entry` 的位置。 ```java int h = k.threadLocalHashCode & (len - 1); @@ -607,18 +607,18 @@ if (h != i) { } ``` -这里是处理正常的产生`Hash`冲突的数据,经过迭代后,有过`Hash`冲突数据的`Entry`位置会更靠近正确位置,这样的话,查询的时候 效率才会更高。 +这里是处理正常的产生 `Hash` 冲突的数据,经过迭代后,有过 `Hash` 冲突数据的 `Entry` 位置会更靠近正确位置,这样的话,查询的时候 效率才会更高。 -### `ThreadLocalMap`扩容机制 +### `ThreadLocalMap` 扩容机制 -在`ThreadLocalMap.set()`方法的最后,如果执行完启发式清理工作后,未清理到任何数据,且当前散列数组中`Entry`的数量已经达到了列表的扩容阈值`(len*2/3)`,就开始执行`rehash()`逻辑: +在 `ThreadLocalMap.set()` 方法的最后,如果执行完启发式清理工作后,未清理到任何数据,且当前散列数组中 `Entry` 的数量已经达到了列表的扩容阈值 `(len*2/3)`,就开始执行 `rehash()` 逻辑: ```java if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); ``` -接着看下`rehash()`具体实现: +接着看下 `rehash()` 具体实现: ```java private void rehash() { @@ -639,17 +639,17 @@ private void expungeStaleEntries() { } ``` -这里首先是会进行探测式清理工作,从`table`的起始位置往后清理,上面有分析清理的详细流程。清理完成之后,`table`中可能有一些`key`为`null`的`Entry`数据被清理掉,所以此时通过判断`size >= threshold - threshold / 4` 也就是`size >= threshold * 3/4` 来决定是否扩容。 +这里首先是会进行探测式清理工作,从 `table` 的起始位置往后清理,上面有分析清理的详细流程。清理完成之后,`table` 中可能有一些 `key` 为 `null` 的 `Entry` 数据被清理掉,所以此时通过判断 `size >= threshold - threshold / 4` 也就是 `size >= threshold * 3/4` 来决定是否扩容。 -我们还记得上面进行`rehash()`的阈值是`size >= threshold`,所以当面试官套路我们`ThreadLocalMap`扩容机制的时候 我们一定要说清楚这两个步骤: +我们还记得上面进行 `rehash()` 的阈值是 `size >= threshold`,所以当面试官套路我们 `ThreadLocalMap` 扩容机制的时候 我们一定要说清楚这两个步骤: ![](./images/thread-local/24.png) -接着看看具体的`resize()`方法,为了方便演示,我们以`oldTab.len=8`来举例: +接着看看具体的 `resize()` 方法,为了方便演示,我们以 `oldTab.len=8` 来举例: ![](./images/thread-local/25.png) -扩容后的`tab`的大小为`oldLen * 2`,然后遍历老的散列表,重新计算`hash`位置,然后放到新的`tab`数组中,如果出现`hash`冲突则往后寻找最近的`entry`为`null`的槽位,遍历完成之后,`oldTab`中所有的`entry`数据都已经放入到新的`tab`中了。重新计算`tab`下次扩容的**阈值**,具体代码如下: +扩容后的 `tab` 的大小为 `oldLen * 2`,然后遍历老的散列表,重新计算 `hash` 位置,然后放到新的 `tab` 数组中,如果出现 `hash` 冲突则往后寻找最近的 `entry` 为 `null` 的槽位,遍历完成之后,`oldTab` 中所有的 `entry` 数据都已经放入到新的 `tab` 中了。重新计算 `tab` 下次扩容的**阈值**,具体代码如下: ```java private void resize() { @@ -681,27 +681,27 @@ private void resize() { } ``` -### `ThreadLocalMap.get()`详解 +### `ThreadLocalMap.get()` 详解 -上面已经看完了`set()`方法的源码,其中包括`set`数据、清理数据、优化数据桶的位置等操作,接着看看`get()`操作的原理。 +上面已经看完了 `set()` 方法的源码,其中包括 `set` 数据、清理数据、优化数据桶的位置等操作,接着看看 `get()` 操作的原理。 -#### `ThreadLocalMap.get()`图解 +#### `ThreadLocalMap.get()` 图解 -**第一种情况:** 通过查找`key`值计算出散列表中`slot`位置,然后该`slot`位置中的`Entry.key`和查找的`key`一致,则直接返回: +**第一种情况:** 通过查找 `key` 值计算出散列表中 `slot` 位置,然后该 `slot` 位置中的 `Entry.key` 和查找的 `key` 一致,则直接返回: ![](./images/thread-local/26.png) -**第二种情况:** `slot`位置中的`Entry.key`和要查找的`key`不一致: +**第二种情况:** `slot` 位置中的 `Entry.key` 和要查找的 `key` 不一致: ![](./images/thread-local/27.png) -我们以`get(ThreadLocal1)`为例,通过`hash`计算后,正确的`slot`位置应该是 4,而`index=4`的槽位已经有了数据,且`key`值不等于`ThreadLocal1`,所以需要继续往后迭代查找。 +我们以 `get(ThreadLocal1)` 为例,通过 `hash` 计算后,正确的 `slot` 位置应该是 4,而 `index=4` 的槽位已经有了数据,且 `key` 值不等于 `ThreadLocal1`,所以需要继续往后迭代查找。 -迭代到`index=5`的数据时,此时`Entry.key=null`,触发一次探测式数据回收操作,执行`expungeStaleEntry()`方法,执行完后,`index 5,8`的数据都会被回收,而`index 6,7`的数据都会前移。`index 6,7`前移之后,继续从 `index=5` 往后迭代,于是就在 `index=6` 找到了`key`值相等的`Entry`数据,如下图所示: +迭代到 `index=5` 的数据时,此时 `Entry.key=null`,触发一次探测式数据回收操作,执行 `expungeStaleEntry()` 方法,执行完后,`index 5,8` 的数据都会被回收,而 `index 6,7` 的数据都会前移。`index 6,7` 前移之后,继续从 `index=5` 往后迭代,于是就在 `index=6` 找到了 `key` 值相等的 `Entry` 数据,如下图所示: ![](./images/thread-local/28.png) -#### `ThreadLocalMap.get()`源码详解 +#### `ThreadLocalMap.get()` 源码详解 `java.lang.ThreadLocal.ThreadLocalMap.getEntry()`: @@ -733,11 +733,11 @@ private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) { } ``` -### `ThreadLocalMap`过期 key 的启发式清理流程 +### `ThreadLocalMap` 过期 key 的启发式清理流程 -上面多次提及到`ThreadLocalMap`过期 key 的两种清理方式:**探测式清理(expungeStaleEntry())**、**启发式清理(cleanSomeSlots())** +上面多次提及到 `ThreadLocalMap` 过期 key 的两种清理方式:**探测式清理(expungeStaleEntry())**、**启发式清理(cleanSomeSlots())** -探测式清理是以当前`Entry` 往后清理,遇到值为`null`则结束清理,属于**线性探测清理**。 +探测式清理是以当前 `Entry` 往后清理,遇到值为 `null` 则结束清理,属于**线性探测清理**。 而启发式清理被作者定义为:**Heuristically scan some cells looking for stale entries**. @@ -765,9 +765,9 @@ private boolean cleanSomeSlots(int i, int n) { ### `InheritableThreadLocal` -我们使用`ThreadLocal`的时候,在异步场景下是无法给子线程共享父线程中创建的线程副本数据的。 +我们使用 `ThreadLocal` 的时候,在异步场景下是无法给子线程共享父线程中创建的线程副本数据的。 -为了解决这个问题,JDK 中还有一个`InheritableThreadLocal`类,我们来看一个例子: +为了解决这个问题,JDK 中还有一个 `InheritableThreadLocal` 类,我们来看一个例子: ```java public class InheritableThreadLocalDemo { @@ -795,7 +795,7 @@ public class InheritableThreadLocalDemo { 子线程获取父类inheritableThreadLocal数据:父类数据:inheritableThreadLocal ``` -实现原理是子线程是通过在父线程中通过调用`new Thread()`方法来创建子线程,`Thread#init`方法在`Thread`的构造方法中被调用。在`init`方法中拷贝父线程数据到子线程中: +实现原理是子线程是通过在父线程中通过调用 `new Thread()` 方法来创建子线程,`Thread#init` 方法在 `Thread` 的构造方法中被调用。在 `init` 方法中拷贝父线程数据到子线程中: ```java private void init(ThreadGroup g, Runnable target, String name, @@ -813,25 +813,25 @@ private void init(ThreadGroup g, Runnable target, String name, } ``` -但`InheritableThreadLocal`仍然有缺陷,一般我们做异步化处理都是使用的线程池,而`InheritableThreadLocal`是在`new Thread`中的`init()`方法给赋值的,而线程池是线程复用的逻辑,所以这里会存在问题。 +但 `InheritableThreadLocal` 仍然有缺陷,一般我们做异步化处理都是使用的线程池,而 `InheritableThreadLocal` 是在 `new Thread` 中的 `init()` 方法给赋值的,而线程池是线程复用的逻辑,所以这里会存在问题。 -当然,有问题出现就会有解决问题的方案,阿里巴巴开源了一个`TransmittableThreadLocal`组件就可以解决这个问题,这里就不再延伸,感兴趣的可自行查阅资料。 +当然,有问题出现就会有解决问题的方案,阿里巴巴开源了一个 `TransmittableThreadLocal` 组件就可以解决这个问题,这里就不再延伸,感兴趣的可自行查阅资料。 -### `ThreadLocal`项目中使用实战 +### `ThreadLocal` 项目中使用实战 -#### `ThreadLocal`使用场景 +#### `ThreadLocal` 使用场景 -我们现在项目中日志记录用的是`ELK+Logstash`,最后在`Kibana`中进行展示和检索。 +我们现在项目中日志记录用的是 `ELK+Logstash`,最后在 `Kibana` 中进行展示和检索。 现在都是分布式系统统一对外提供服务,项目间调用的关系可以通过 `traceId` 来关联,但是不同项目之间如何传递 `traceId` 呢? 这里我们使用 `org.slf4j.MDC` 来实现此功能,内部就是通过 `ThreadLocal` 来实现的,具体实现如下: -当前端发送请求到**服务 A**时,**服务 A**会生成一个类似`UUID`的`traceId`字符串,将此字符串放入当前线程的`ThreadLocal`中,在调用**服务 B**的时候,将`traceId`写入到请求的`Header`中,**服务 B**在接收请求时会先判断请求的`Header`中是否有`traceId`,如果存在则写入自己线程的`ThreadLocal`中。 +当前端发送请求到**服务 A**时,**服务 A**会生成一个类似 `UUID` 的 `traceId` 字符串,将此字符串放入当前线程的 `ThreadLocal` 中,在调用**服务 B**的时候,将 `traceId` 写入到请求的 `Header` 中,**服务 B**在接收请求时会先判断请求的 `Header` 中是否有 `traceId`,如果存在则写入自己线程的 `ThreadLocal` 中。 ![](./images/thread-local/30.png) -图中的`requestId`即为我们各个系统链路关联的`traceId`,系统间互相调用,通过这个`requestId`即可找到对应链路,这里还有会有一些其他场景: +图中的 `requestId` 即为我们各个系统链路关联的 `traceId`,系统间互相调用,通过这个 `requestId` 即可找到对应链路,这里还有会有一些其他场景: ![](./images/thread-local/31.png) @@ -887,7 +887,7 @@ public class LogInterceptor extends HandlerInterceptorAdapter { #### 线程池异步调用,requestId 传递 -因为`MDC`是基于`ThreadLocal`去实现的,异步过程中,子线程并没有办法获取到父线程`ThreadLocal`存储的数据,所以这里可以自定义线程池执行器,修改其中的`run()`方法: +因为 `MDC` 是基于 `ThreadLocal` 去实现的,异步过程中,子线程并没有办法获取到父线程 `ThreadLocal` 存储的数据,所以这里可以自定义线程池执行器,修改其中的 `run()` 方法: ```java public class MyThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { @@ -914,6 +914,6 @@ public class MyThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { #### 使用 MQ 发送消息给第三方系统 -在 MQ 发送的消息体中自定义属性`requestId`,接收方消费消息后,自己解析`requestId`使用即可。 +在 MQ 发送的消息体中自定义属性 `requestId`,接收方消费消息后,自己解析 `requestId` 使用即可。 diff --git a/docs/java/io/io-basis.md b/docs/java/io/io-basis.md index a6c4c712fa6..0020dca4a2b 100755 --- a/docs/java/io/io-basis.md +++ b/docs/java/io/io-basis.md @@ -24,13 +24,13 @@ Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来 ### InputStream(字节输入流) -`InputStream`用于从源头(通常是文件)读取数据(字节信息)到内存中,`java.io.InputStream`抽象类是所有字节输入流的父类。 +`InputStream` 用于从源头(通常是文件)读取数据(字节信息)到内存中,`java.io.InputStream` 抽象类是所有字节输入流的父类。 `InputStream` 常用方法: -- `read()`:返回输入流中下一个字节的数据。返回的值介于 0 到 255 之间。如果未读取任何字节,则代码返回 `-1` ,表示文件结束。 -- `read(byte b[ ])` : 从输入流中读取一些字节存储到数组 `b` 中。如果数组 `b` 的长度为零,则不读取。如果没有可用字节读取,返回 `-1`。如果有可用字节读取,则最多读取的字节数最多等于 `b.length` , 返回读取的字节数。这个方法等价于 `read(b, 0, b.length)`。 -- `read(byte b[], int off, int len)`:在`read(byte b[ ])` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字节数)。 +- `read()`:返回输入流中下一个字节的数据。返回的值介于 0 到 255 之间。如果未读取任何字节,则代码返回 `-1`,表示文件结束。 +- `read(byte b[ ])` : 从输入流中读取一些字节存储到数组 `b` 中。如果数组 `b` 的长度为零,则不读取。如果没有可用字节读取,返回 `-1`。如果有可用字节读取,则最多读取的字节数最多等于 `b.length`, 返回读取的字节数。这个方法等价于 `read(b, 0, b.length)`。 +- `read(byte b[], int off, int len)`:在 `read(byte b[ ])` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字节数)。 - `skip(long n)`:忽略输入流中的 n 个字节 ,返回实际忽略的字节数。 - `available()`:返回输入流中可以读取的字节数。 - `close()`:关闭输入流释放相关的系统资源。 @@ -73,7 +73,7 @@ The actual number of bytes skipped:2 The content read from file:JavaGuide ``` -不过,一般我们是不会直接单独使用 `FileInputStream` ,通常会配合 `BufferedInputStream`(字节缓冲输入流,后文会讲到)来使用。 +不过,一般我们是不会直接单独使用 `FileInputStream`,通常会配合 `BufferedInputStream`(字节缓冲输入流,后文会讲到)来使用。 像下面这段代码在我们的项目中就比较常见,我们通过 `readAllBytes()` 读取输入流所有字节并将其直接赋值给一个 `String` 对象。 @@ -85,7 +85,7 @@ String result = new String(bufferedInputStream.readAllBytes()); System.out.println(result); ``` -`DataInputStream` 用于读取指定类型数据,不能单独使用,必须结合其它流,比如 `FileInputStream` 。 +`DataInputStream` 用于读取指定类型数据,不能单独使用,必须结合其它流,比如 `FileInputStream`。 ```java FileInputStream fileInputStream = new FileInputStream("input.txt"); @@ -97,7 +97,7 @@ dataInputStream.readInt(); dataInputStream.readUTF(); ``` -`ObjectInputStream` 用于从输入流中读取 Java 对象(反序列化),`ObjectOutputStream` 用于将对象写入到输出流(序列化)。 +`ObjectInputStream` 用于从输入流中读取 Java 对象(反序列化),`ObjectOutputStream` 用于将对象写入到输出流(序列化)。 ```java ObjectInputStream input = new ObjectInputStream(new FileInputStream("object.data")); @@ -109,13 +109,13 @@ input.close(); ### OutputStream(字节输出流) -`OutputStream`用于将数据(字节信息)写入到目的地(通常是文件),`java.io.OutputStream`抽象类是所有字节输出流的父类。 +`OutputStream` 用于将数据(字节信息)写入到目的地(通常是文件),`java.io.OutputStream` 抽象类是所有字节输出流的父类。 `OutputStream` 常用方法: - `write(int b)`:将特定字节写入输出流。 -- `write(byte b[ ])` : 将数组`b` 写入到输出流,等价于 `write(b, 0, b.length)` 。 -- `write(byte[] b, int off, int len)` : 在`write(byte b[ ])` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字节数)。 +- `write(byte b[ ])` : 将数组 `b` 写入到输出流,等价于 `write(b, 0, b.length)`。 +- `write(byte[] b, int off, int len)` : 在 `write(byte b[ ])` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字节数)。 - `flush()`:刷新此输出流并强制写出所有缓冲的输出字节。 - `close()`:关闭输出流释放相关的系统资源。 @@ -143,7 +143,7 @@ FileOutputStream fileOutputStream = new FileOutputStream("output.txt"); BufferedOutputStream bos = new BufferedOutputStream(fileOutputStream) ``` -**`DataOutputStream`** 用于写入指定类型数据,不能单独使用,必须结合其它流,比如 `FileOutputStream` 。 +**`DataOutputStream`** 用于写入指定类型数据,不能单独使用,必须结合其它流,比如 `FileOutputStream`。 ```java // 输出流 @@ -193,15 +193,15 @@ Unicode 本身只是一种字符集,它为每个字符分配一个唯一的数 ### Reader(字符输入流) -`Reader`用于从源头(通常是文件)读取数据(字符信息)到内存中,`java.io.Reader`抽象类是所有字符输入流的父类。 +`Reader` 用于从源头(通常是文件)读取数据(字符信息)到内存中,`java.io.Reader` 抽象类是所有字符输入流的父类。 `Reader` 用于读取文本, `InputStream` 用于读取原始字节。 `Reader` 常用方法: - `read()` : 从输入流读取一个字符。 -- `read(char[] cbuf)` : 从输入流中读取一些字符,并将它们存储到字符数组 `cbuf`中,等价于 `read(cbuf, 0, cbuf.length)` 。 -- `read(char[] cbuf, int off, int len)`:在`read(char[] cbuf)` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字符数)。 +- `read(char[] cbuf)` : 从输入流中读取一些字符,并将它们存储到字符数组 `cbuf` 中,等价于 `read(cbuf, 0, cbuf.length)`。 +- `read(char[] cbuf, int off, int len)`:在 `read(char[] cbuf)` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字符数)。 - `skip(long n)`:忽略输入流中的 n 个字符 ,返回实际忽略的字符数。 - `close()` : 关闭输入流并释放相关的系统资源。 @@ -245,15 +245,15 @@ The content read from file:我是Guide。 ### Writer(字符输出流) -`Writer`用于将数据(字符信息)写入到目的地(通常是文件),`java.io.Writer`抽象类是所有字符输出流的父类。 +`Writer` 用于将数据(字符信息)写入到目的地(通常是文件),`java.io.Writer` 抽象类是所有字符输出流的父类。 `Writer` 常用方法: - `write(int c)` : 写入单个字符。 -- `write(char[] cbuf)`:写入字符数组 `cbuf`,等价于`write(cbuf, 0, cbuf.length)`。 -- `write(char[] cbuf, int off, int len)`:在`write(char[] cbuf)` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字符数)。 -- `write(String str)`:写入字符串,等价于 `write(str, 0, str.length())` 。 -- `write(String str, int off, int len)`:在`write(String str)` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字符数)。 +- `write(char[] cbuf)`:写入字符数组 `cbuf`,等价于 `write(cbuf, 0, cbuf.length)`。 +- `write(char[] cbuf, int off, int len)`:在 `write(char[] cbuf)` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字符数)。 +- `write(String str)`:写入字符串,等价于 `write(str, 0, str.length())`。 +- `write(String str, int off, int len)`:在 `write(String str)` 方法的基础上增加了 `off` 参数(偏移量)和 `len` 参数(要读取的最大字符数)。 - `append(CharSequence csq)`:将指定的字符序列附加到指定的 `Writer` 对象并返回该 `Writer` 对象。 - `append(char c)`:将指定的字符附加到指定的 `Writer` 对象并返回该 `Writer` 对象。 - `flush()`:刷新此输出流并强制写出所有缓冲的输出字符。 @@ -288,7 +288,7 @@ try (Writer output = new FileWriter("output.txt")) { IO 操作是很消耗性能的,缓冲流将数据加载至缓冲区,一次性读取/写入多个字节,从而避免频繁的 IO 操作,提高流的传输效率。 -字节缓冲流这里采用了装饰器模式来增强 `InputStream` 和`OutputStream`子类对象的功能。 +字节缓冲流这里采用了装饰器模式来增强 `InputStream` 和 `OutputStream` 子类对象的功能。 举个例子,我们可以通过 `BufferedInputStream`(字节缓冲输入流)来增强 `FileInputStream` 的功能。 @@ -444,11 +444,11 @@ try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("o } ``` -类似于 `BufferedInputStream` ,`BufferedOutputStream` 内部也维护了一个缓冲区,并且,这个缓存区的大小也是 **8192** 字节。 +类似于 `BufferedInputStream`,`BufferedOutputStream` 内部也维护了一个缓冲区,并且,这个缓存区的大小也是 **8192** 字节。 ## 字符缓冲流 -`BufferedReader` (字符缓冲输入流)和 `BufferedWriter`(字符缓冲输出流)类似于 `BufferedInputStream`(字节缓冲输入流)和`BufferedOutputStream`(字节缓冲输入流),内部都维护了一个字节数组作为缓冲区。不过,前者主要是用来操作字符信息。 +`BufferedReader`(字符缓冲输入流)和 `BufferedWriter`(字符缓冲输出流)类似于 `BufferedInputStream`(字节缓冲输入流)和 `BufferedOutputStream`(字节缓冲输入流),内部都维护了一个字节数组作为缓冲区。不过,前者主要是用来操作字符信息。 ## 打印流 @@ -459,9 +459,9 @@ System.out.print("Hello!"); System.out.println("Hello!"); ``` -`System.out` 实际是用于获取一个 `PrintStream` 对象,`print`方法实际调用的是 `PrintStream` 对象的 `write` 方法。 +`System.out` 实际是用于获取一个 `PrintStream` 对象,`print` 方法实际调用的是 `PrintStream` 对象的 `write` 方法。 -`PrintStream` 属于字节打印流,与之对应的是 `PrintWriter` (字符打印流)。`PrintStream` 是 `OutputStream` 的子类,`PrintWriter` 是 `Writer` 的子类。 +`PrintStream` 属于字节打印流,与之对应的是 `PrintWriter`(字符打印流)。`PrintStream` 是 `OutputStream` 的子类,`PrintWriter` 是 `Writer` 的子类。 ```java public class PrintStream extends FilterOutputStream @@ -473,7 +473,7 @@ public class PrintWriter extends Writer { ## 随机访问流 -这里要介绍的随机访问流指的是支持随意跳转到文件的任意位置进行读写的 `RandomAccessFile` 。 +这里要介绍的随机访问流指的是支持随意跳转到文件的任意位置进行读写的 `RandomAccessFile`。 `RandomAccessFile` 的构造方法如下,我们可以指定 `mode`(读写模式)。 @@ -527,7 +527,7 @@ System.out.println("读取之前的偏移量:" + randomAccessFile.getFilePoint 读取之前的偏移量:0,当前读取到的字符A,读取之后的偏移量:1 ``` -`input.txt` 文件内容变为 `ABCDEFGHIJK` 。 +`input.txt` 文件内容变为 `ABCDEFGHIJK`。 `RandomAccessFile` 的 `write` 方法在写入对象的时候如果对应的位置已经有数据的话,会将其覆盖掉。 @@ -536,9 +536,9 @@ RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'}); ``` -假设运行上面这段程序之前 `input.txt` 文件内容变为 `ABCD` ,运行之后则变为 `HIJK` 。 +假设运行上面这段程序之前 `input.txt` 文件内容变为 `ABCD`,运行之后则变为 `HIJK`。 -`RandomAccessFile` 比较常见的一个应用就是实现大文件的 **断点续传** 。何谓断点续传?简单来说就是上传文件中途暂停或失败(比如遇到网络问题)之后,不需要重新上传,只需要上传那些未成功上传的文件分片即可。分片(先将文件切分成多个文件分片)上传是断点续传的基础。 +`RandomAccessFile` 比较常见的一个应用就是实现大文件的 **断点续传**。何谓断点续传?简单来说就是上传文件中途暂停或失败(比如遇到网络问题)之后,不需要重新上传,只需要上传那些未成功上传的文件分片即可。分片(先将文件切分成多个文件分片)上传是断点续传的基础。 `RandomAccessFile` 可以帮助我们合并文件分片,示例代码如下: @@ -548,6 +548,6 @@ randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'}); ![](https://oss.javaguide.cn/github/javaguide/java/image-20220428104115362.png) -`RandomAccessFile` 的实现依赖于 `FileDescriptor` (文件描述符) 和 `FileChannel` (内存映射文件)。 +`RandomAccessFile` 的实现依赖于 `FileDescriptor`(文件描述符) 和 `FileChannel`(内存映射文件)。 diff --git a/docs/java/io/io-design-patterns.md b/docs/java/io/io-design-patterns.md index f7397bb1a93..36a0fe0ad5d 100644 --- a/docs/java/io/io-design-patterns.md +++ b/docs/java/io/io-design-patterns.md @@ -19,9 +19,9 @@ head: 装饰器模式通过组合替代继承来扩展原始类的功能,在一些继承关系比较复杂的场景(IO 这一场景各种类的继承关系就比较复杂)更加实用。 -对于字节流来说, `FilterInputStream` (对应输入流)和`FilterOutputStream`(对应输出流)是装饰器模式的核心,分别用于增强 `InputStream` 和`OutputStream`子类对象的功能。 +对于字节流来说, `FilterInputStream`(对应输入流)和 `FilterOutputStream`(对应输出流)是装饰器模式的核心,分别用于增强 `InputStream` 和 `OutputStream` 子类对象的功能。 -我们常见的`BufferedInputStream`(字节缓冲输入流)、`DataInputStream` 等等都是`FilterInputStream` 的子类,`BufferedOutputStream`(字节缓冲输出流)、`DataOutputStream`等等都是`FilterOutputStream`的子类。 +我们常见的 `BufferedInputStream`(字节缓冲输入流)、`DataInputStream` 等等都是 `FilterInputStream` 的子类,`BufferedOutputStream`(字节缓冲输出流)、`DataOutputStream` 等等都是 `FilterOutputStream` 的子类。 举个例子,我们可以通过 `BufferedInputStream`(字节缓冲输入流)来增强 `FileInputStream` 的功能。 @@ -41,7 +41,7 @@ public BufferedInputStream(InputStream in, int size) { } ``` -可以看出,`BufferedInputStream` 的构造函数其中的一个参数就是 `InputStream` 。 +可以看出,`BufferedInputStream` 的构造函数其中的一个参数就是 `InputStream`。 `BufferedInputStream` 代码示例: @@ -57,15 +57,15 @@ try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("inpu } ``` -这个时候,你可能会想了:**为啥我们不直接弄一个`BufferedFileInputStream`(字符缓冲文件输入流)呢?** +这个时候,你可能会想了:**为啥我们不直接弄一个 `BufferedFileInputStream`(字符缓冲文件输入流)呢?** ```java BufferedFileInputStream bfis = new BufferedFileInputStream("input.txt"); ``` -如果 `InputStream`的子类比较少的话,这样做是没问题的。不过, `InputStream`的子类实在太多,继承关系也太复杂了。如果我们为每一个子类都定制一个对应的缓冲输入流,那岂不是太麻烦了。 +如果 `InputStream` 的子类比较少的话,这样做是没问题的。不过, `InputStream` 的子类实在太多,继承关系也太复杂了。如果我们为每一个子类都定制一个对应的缓冲输入流,那岂不是太麻烦了。 -如果你对 IO 流比较熟悉的话,你会发现`ZipInputStream` 和`ZipOutputStream` 还可以分别增强 `BufferedInputStream` 和 `BufferedOutputStream` 的能力。 +如果你对 IO 流比较熟悉的话,你会发现 `ZipInputStream` 和 `ZipOutputStream` 还可以分别增强 `BufferedInputStream` 和 `BufferedOutputStream` 的能力。 ```java BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName)); @@ -75,7 +75,7 @@ BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileNam ZipOutputStream zipOut = new ZipOutputStream(bos); ``` -`ZipInputStream` 和`ZipOutputStream` 分别继承自`InflaterInputStream` 和`DeflaterOutputStream`。 +`ZipInputStream` 和 `ZipOutputStream` 分别继承自 `InflaterInputStream` 和 `DeflaterOutputStream`。 ```java public @@ -90,9 +90,9 @@ class DeflaterOutputStream extends FilterOutputStream { 这也是装饰器模式很重要的一个特征,那就是可以对原始类嵌套使用多个装饰器。 -为了实现这一效果,装饰器类需要跟原始类继承相同的抽象类或者实现相同的接口。上面介绍到的这些 IO 相关的装饰类和原始类共同的父类是 `InputStream` 和`OutputStream`。 +为了实现这一效果,装饰器类需要跟原始类继承相同的抽象类或者实现相同的接口。上面介绍到的这些 IO 相关的装饰类和原始类共同的父类是 `InputStream` 和 `OutputStream`。 -对于字符流来说,`BufferedReader` 可以用来增加 `Reader` (字符输入流)子类的功能,`BufferedWriter` 可以用来增加 `Writer` (字符输出流)子类的功能。 +对于字符流来说,`BufferedReader` 可以用来增加 `Reader`(字符输入流)子类的功能,`BufferedWriter` 可以用来增加 `Writer`(字符输出流)子类的功能。 ```java BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), "UTF-8")); @@ -104,13 +104,13 @@ IO 流中的装饰器模式应用的例子实在是太多了,不需要特意 **适配器(Adapter Pattern)模式** 主要用于接口互不兼容的类的协调工作,你可以将其联想到我们日常经常使用的电源适配器。 -适配器模式中存在被适配的对象或者类称为 **适配者(Adaptee)** ,作用于适配者的对象或者类称为**适配器(Adapter)** 。适配器分为对象适配器和类适配器。类适配器使用继承关系来实现,对象适配器使用组合关系来实现。 +适配器模式中存在被适配的对象或者类称为 **适配者(Adaptee)**,作用于适配者的对象或者类称为**适配器(Adapter)**。适配器分为对象适配器和类适配器。类适配器使用继承关系来实现,对象适配器使用组合关系来实现。 IO 流中的字符流和字节流的接口不同,它们之间可以协调工作就是基于适配器模式来做的,更准确点来说是对象适配器。通过适配器,我们可以将字节流对象适配成一个字符流对象,这样我们可以直接通过字节流对象来读取或者写入字符数据。 -`InputStreamReader` 和 `OutputStreamWriter` 就是两个适配器(Adapter), 同时,它们两个也是字节流和字符流之间的桥梁。`InputStreamReader` 使用 `StreamDecoder` (流解码器)对字节进行解码,**实现字节流到字符流的转换,** `OutputStreamWriter` 使用`StreamEncoder`(流编码器)对字符进行编码,实现字符流到字节流的转换。 +`InputStreamReader` 和 `OutputStreamWriter` 就是两个适配器(Adapter), 同时,它们两个也是字节流和字符流之间的桥梁。`InputStreamReader` 使用 `StreamDecoder`(流解码器)对字节进行解码,**实现字节流到字符流的转换,** `OutputStreamWriter` 使用 `StreamEncoder`(流编码器)对字符进行编码,实现字符流到字节流的转换。 -`InputStream` 和 `OutputStream` 的子类是被适配者, `InputStreamReader` 和 `OutputStreamWriter`是适配器。 +`InputStream` 和 `OutputStream` 的子类是被适配者, `InputStreamReader` 和 `OutputStreamWriter` 是适配器。 ```java // InputStreamReader 是适配器,FileInputStream 是被适配的类 @@ -167,7 +167,7 @@ public class OutputStreamWriter extends Writer { **装饰器模式** 更侧重于动态地增强原始类的功能,装饰器类需要跟原始类继承相同的抽象类或者实现相同的接口。并且,装饰器模式支持对原始类嵌套使用多个装饰器。 -**适配器模式** 更侧重于让接口不兼容而不能交互的类可以一起工作,当我们调用适配器对应的方法时,适配器内部会调用适配者类或者和适配类相关的类的方法,这个过程透明的。就比如说 `StreamDecoder` (流解码器)和`StreamEncoder`(流编码器)就是分别基于 `InputStream` 和 `OutputStream` 来获取 `FileChannel`对象并调用对应的 `read` 方法和 `write` 方法进行字节数据的读取和写入。 +**适配器模式** 更侧重于让接口不兼容而不能交互的类可以一起工作,当我们调用适配器对应的方法时,适配器内部会调用适配者类或者和适配类相关的类的方法,这个过程透明的。就比如说 `StreamDecoder`(流解码器)和 `StreamEncoder`(流编码器)就是分别基于 `InputStream` 和 `OutputStream` 来获取 `FileChannel` 对象并调用对应的 `read` 方法和 `write` 方法进行字节数据的读取和写入。 ```java StreamDecoder(InputStream in, Object lock, CharsetDecoder dec) { @@ -181,7 +181,7 @@ StreamDecoder(InputStream in, Object lock, CharsetDecoder dec) { 另外,`FutureTask` 类使用了适配器模式,`Executors` 的内部类 `RunnableAdapter` 实现属于适配器,用于将 `Runnable` 适配成 `Callable`。 -`FutureTask`参数包含 `Runnable` 的一个构造方法: +`FutureTask` 参数包含 `Runnable` 的一个构造方法: ```java public FutureTask(Runnable runnable, V result) { @@ -191,7 +191,7 @@ public FutureTask(Runnable runnable, V result) { } ``` -`Executors`中对应的方法和适配器: +`Executors` 中对应的方法和适配器: ```java // 实际调用的是 Executors 的内部类 RunnableAdapter 的构造方法 @@ -217,7 +217,7 @@ static final class RunnableAdapter implements Callable { ## 工厂模式 -工厂模式用于创建对象,NIO 中大量用到了工厂模式,比如 `Files` 类的 `newInputStream` 方法用于创建 `InputStream` 对象(静态工厂)、 `Paths` 类的 `get` 方法创建 `Path` 对象(静态工厂)、`ZipFileSystem` 类(`sun.nio`包下的类,属于 `java.nio` 相关的一些内部实现)的 `getPath` 的方法创建 `Path` 对象(简单工厂)。 +工厂模式用于创建对象,NIO 中大量用到了工厂模式,比如 `Files` 类的 `newInputStream` 方法用于创建 `InputStream` 对象(静态工厂)、 `Paths` 类的 `get` 方法创建 `Path` 对象(静态工厂)、`ZipFileSystem` 类(`sun.nio` 包下的类,属于 `java.nio` 相关的一些内部实现)的 `getPath` 的方法创建 `Path` 对象(简单工厂)。 ```java InputStream is = Files.newInputStream(Paths.get(generatorLogoPath)) @@ -229,7 +229,7 @@ NIO 中的文件目录监听服务使用到了观察者模式。 NIO 中的文件目录监听服务基于 `WatchService` 接口和 `Watchable` 接口。`WatchService` 属于观察者,`Watchable` 属于被观察者。 -`Watchable` 接口定义了一个用于将对象注册到 `WatchService`(监控服务) 并绑定监听事件的方法 `register` 。 +`Watchable` 接口定义了一个用于将对象注册到 `WatchService`(监控服务) 并绑定监听事件的方法 `register`。 ```java public interface Path @@ -257,7 +257,7 @@ WatchKey watchKey = path.register( watchService, StandardWatchEventKinds...); ``` -`Path` 类 `register` 方法的第二个参数 `events` (需要监听的事件)为可变长参数,也就是说我们可以同时监听多种事件。 +`Path` 类 `register` 方法的第二个参数 `events`(需要监听的事件)为可变长参数,也就是说我们可以同时监听多种事件。 ```java WatchKey register(WatchService watcher, @@ -271,7 +271,7 @@ WatchKey register(WatchService watcher, - `StandardWatchEventKinds.ENTRY_DELETE` : 文件删除。 - `StandardWatchEventKinds.ENTRY_MODIFY` : 文件修改。 -`register` 方法返回 `WatchKey` 对象,通过`WatchKey` 对象可以获取事件的具体信息比如文件目录下是创建、删除还是修改了文件、创建、删除或者修改的文件的具体名称是什么。 +`register` 方法返回 `WatchKey` 对象,通过 `WatchKey` 对象可以获取事件的具体信息比如文件目录下是创建、删除还是修改了文件、创建、删除或者修改的文件的具体名称是什么。 ```java WatchKey key; diff --git a/docs/java/io/io-model.md b/docs/java/io/io-model.md index 3b24d33b90b..992e91e6b60 100644 --- a/docs/java/io/io-model.md +++ b/docs/java/io/io-model.md @@ -11,7 +11,7 @@ head: content: Java IO模型,BIO,NIO,AIO,阻塞IO,非阻塞IO,多路复用,Reactor模式,Proactor模式 --- -IO 模型这块确实挺难理解的,需要太多计算机底层知识。写这篇文章用了挺久,就非常希望能把我所知道的讲出来吧!希望朋友们能有收获!为了写这篇文章,还翻看了一下《UNIX 网络编程》这本书,太难了,我滴乖乖!心痛~ +IO 模型这块确实挺难理解的,需要太多计算机底层知识。写这篇文章用了挺久,就非常希望能把我所知道的讲出来吧!希望朋友们能有收获!为了写这篇文章,还翻看了一下《UNIX 网络编程》这本书,太难了,我滴乖乖!心痛~ _个人能力有限。如果文章有任何需要补充/完善/修改的地方,欢迎在评论区指出,共同进步!_ @@ -23,7 +23,7 @@ I/O 一直是很多小伙伴难以理解的一个知识点,这篇文章我会 ### 何为 I/O? -I/O(**I**nput/**O**utput) 即**输入/输出** 。 +I/O(**I**nput/**O**utput) 即**输入/输出**。 **我们先从计算机结构的角度来解读一下 I/O。** @@ -39,7 +39,7 @@ I/O(**I**nput/**O**utput) 即**输入/输出** 。 **我们再先从应用程序的角度来解读一下 I/O。** -根据大学里学到的操作系统相关的知识:为了保证操作系统的稳定性和安全性,一个进程的地址空间划分为 **用户空间(User space)** 和 **内核空间(Kernel space )** 。 +根据大学里学到的操作系统相关的知识:为了保证操作系统的稳定性和安全性,一个进程的地址空间划分为 **用户空间(User space)** 和 **内核空间(Kernel space)**。 像我们平常运行的应用程序都是运行在用户空间,只有内核空间才能进行系统态级别的资源有关的操作,比如文件管理、进程通信、内存管理等等。也就是说,我们想要进行 IO 操作,一定是要依赖内核空间的能力。 @@ -58,7 +58,7 @@ I/O(**I**nput/**O**utput) 即**输入/输出** 。 1. 内核等待 I/O 设备准备好数据 2. 内核将数据从内核空间拷贝到用户空间。 -### 有哪些常见的 IO 模型? +### 有哪些常见的 IO 模型? UNIX 系统下, IO 模型一共有 5 种:**同步阻塞 I/O**、**同步非阻塞 I/O**、**I/O 多路复用**、**信号驱动 I/O** 和**异步 I/O**。 @@ -68,7 +68,7 @@ UNIX 系统下, IO 模型一共有 5 种:**同步阻塞 I/O**、**同步非 ### BIO (Blocking I/O) -**BIO 属于同步阻塞 IO 模型** 。 +**BIO 属于同步阻塞 IO 模型**。 同步阻塞 IO 模型中,应用程序发起 read 调用后,会一直阻塞,直到内核把数据拷贝到用户空间。 @@ -78,7 +78,7 @@ UNIX 系统下, IO 模型一共有 5 种:**同步阻塞 I/O**、**同步非 ### NIO (Non-blocking/New I/O) -Java 中的 NIO 于 Java 1.4 中引入,对应 `java.nio` 包,提供了 `Channel` , `Selector`,`Buffer` 等抽象。NIO 中的 N 可以理解为 Non-blocking,不单纯是 New。它是支持面向缓冲的,基于通道的 I/O 操作方法。 对于高负载、高并发的(网络)应用,应使用 NIO 。 +Java 中的 NIO 于 Java 1.4 中引入,对应 `java.nio` 包,提供了 `Channel` , `Selector`,`Buffer` 等抽象。NIO 中的 N 可以理解为 Non-blocking,不单纯是 New。它是支持面向缓冲的,基于通道的 I/O 操作方法。 对于高负载、高并发的(网络)应用,应使用 NIO。 Java 中的 NIO 可以看作是 **I/O 多路复用模型**。也有很多人认为,Java 中的 NIO 属于同步非阻塞 IO 模型。 @@ -110,7 +110,7 @@ IO 多路复用模型中,线程首先发起 select 调用,询问内核数据 **IO 多路复用模型,通过减少无效的系统调用,减少了对 CPU 资源的消耗。** -Java 中的 NIO ,有一个非常重要的**选择器 ( Selector )** 的概念,也可以被称为 **多路复用器**。通过它,只需要一个线程便可以管理多个客户端连接。当客户端数据到了之后,才会为其服务。 +Java 中的 NIO,有一个非常重要的**选择器 ( Selector )** 的概念,也可以被称为 **多路复用器**。通过它,只需要一个线程便可以管理多个客户端连接。当客户端数据到了之后,才会为其服务。 ![Buffer、Channel和Selector三者之间的关系](https://oss.javaguide.cn/github/javaguide/java/nio/channel-buffer-selector.png) @@ -135,6 +135,6 @@ AIO 也就是 NIO 2。Java 7 中引入了 NIO 的改进版 NIO 2,它是异步 IO - 程序员应该这样理解 IO:[https://www.jianshu.com/p/fa7bdc4f3de7](https://www.jianshu.com/p/fa7bdc4f3de7) - 10 分钟看懂, Java NIO 底层原理: - IO 模型知多少 | 理论篇: -- 《UNIX 网络编程 卷 1;套接字联网 API 》6.2 节 IO 模型 +- 《UNIX 网络编程 卷 1;套接字联网 API》6.2 节 IO 模型 diff --git a/docs/java/io/nio-basis.md b/docs/java/io/nio-basis.md index bceaea2af57..545f38d1433 100644 --- a/docs/java/io/nio-basis.md +++ b/docs/java/io/nio-basis.md @@ -17,13 +17,13 @@ head: 在传统的 Java I/O 模型(BIO)中,I/O 操作是以阻塞的方式进行的。也就是说,当一个线程执行一个 I/O 操作时,它会被阻塞直到操作完成。这种阻塞模型在处理多个并发连接时可能会导致性能瓶颈,因为需要为每个连接创建一个线程,而线程的创建和切换都是有开销的。 -为了解决这个问题,在 Java1.4 版本引入了一种新的 I/O 模型 — **NIO** (New IO,也称为 Non-blocking IO) 。NIO 弥补了同步阻塞 I/O 的不足,它在标准 Java 代码中提供了非阻塞、面向缓冲、基于通道的 I/O,可以使用少量的线程来处理多个连接,大大提高了 I/O 效率和并发。 +为了解决这个问题,在 Java1.4 版本引入了一种新的 I/O 模型 — **NIO**(New IO,也称为 Non-blocking IO)。NIO 弥补了同步阻塞 I/O 的不足,它在标准 Java 代码中提供了非阻塞、面向缓冲、基于通道的 I/O,可以使用少量的线程来处理多个连接,大大提高了 I/O 效率和并发。 下图是 BIO、NIO 和 AIO 处理客户端请求的简单对比图(关于 AIO 的介绍,可以看我写的这篇文章:[Java IO 模型详解](https://javaguide.cn/java/io/io-model.html),不是重点,了解即可)。 ![BIO、NIO 和 AIO 对比](https://oss.javaguide.cn/github/javaguide/java/nio/bio-aio-nio.png) -⚠️需要注意:使用 NIO 并不一定意味着高性能,它的性能优势主要体现在高并发和高延迟的网络环境下。当连接数较少、并发程度较低或者网络传输速度较快时,NIO 的性能并不一定优于传统的 BIO 。 +⚠️需要注意:使用 NIO 并不一定意味着高性能,它的性能优势主要体现在高并发和高延迟的网络环境下。当连接数较少、并发程度较低或者网络传输速度较快时,NIO 的性能并不一定优于传统的 BIO。 ## NIO 核心组件 @@ -51,7 +51,7 @@ NIO 主要包括以下三个核心组件: 你可以将 Buffer 理解为一个数组,`IntBuffer`、`FloatBuffer`、`CharBuffer` 等分别对应 `int[]`、`float[]`、`char[]` 等。 -为了更清晰地认识缓冲区,我们来简单看看`Buffer` 类中定义的四个成员变量: +为了更清晰地认识缓冲区,我们来简单看看 `Buffer` 类中定义的四个成员变量: ```java public abstract class Buffer { @@ -65,12 +65,12 @@ public abstract class Buffer { 这四个成员变量的具体含义如下: -1. 容量(`capacity`):`Buffer`可以存储的最大数据量,`Buffer`创建时设置且不可改变; -2. 界限(`limit`):`Buffer` 中可以读/写数据的边界。写模式下,`limit` 代表最多能写入的数据,一般等于 `capacity`(可以通过`limit(int newLimit)`方法设置);读模式下,`limit` 等于 Buffer 中实际写入的数据大小。 +1. 容量(`capacity`):`Buffer` 可以存储的最大数据量,`Buffer` 创建时设置且不可改变; +2. 界限(`limit`):`Buffer` 中可以读/写数据的边界。写模式下,`limit` 代表最多能写入的数据,一般等于 `capacity`(可以通过 `limit(int newLimit)` 方法设置);读模式下,`limit` 等于 Buffer 中实际写入的数据大小。 3. 位置(`position`):下一个可以被读写的数据的位置(索引)。从写操作模式到读操作模式切换的时候(flip),`position` 都会归零,这样就可以从头开始读写了。 -4. 标记(`mark`):`Buffer`允许将位置直接定位到该标记处,这是一个可选属性; +4. 标记(`mark`):`Buffer` 允许将位置直接定位到该标记处,这是一个可选属性; -并且,上述变量满足如下的关系:**0 <= mark <= position <= limit <= capacity** 。 +并且,上述变量满足如下的关系:**0 <= mark <= position <= limit <= capacity**。 另外,Buffer 有读模式和写模式这两种模式,分别用于从 Buffer 中读取数据或者向 Buffer 中写入数据。Buffer 被创建之后默认是写模式,调用 `flip()` 可以切换到读模式。如果要再次切换回写模式,可以调用 `clear()` 或者 `compact()` 方法。 @@ -78,9 +78,9 @@ public abstract class Buffer { ![position 、limit 和 capacity 之前的关系](https://oss.javaguide.cn/github/javaguide/java/nio/NIOBufferClassAttributes.png) -`Buffer` 对象不能通过 `new` 调用构造方法创建对象 ,只能通过静态方法实例化 `Buffer`。 +`Buffer` 对象不能通过 `new` 调用构造方法创建对象,只能通过静态方法实例化 `Buffer`。 -这里以 `ByteBuffer`为例进行介绍: +这里以 `ByteBuffer` 为例进行介绍: ```java // 分配堆内存 @@ -92,11 +92,11 @@ public static ByteBuffer allocateDirect(int capacity); Buffer 最核心的两个方法: 1. `get` : 读取缓冲区的数据 -2. `put` :向缓冲区写入数据 +2. `put`:向缓冲区写入数据 除上述两个方法之外,其他的重要方法: -- `flip` :将缓冲区从写模式切换到读模式,它会将 `limit` 的值设置为当前 `position` 的值,将 `position` 的值设置为 0。 +- `flip`:将缓冲区从写模式切换到读模式,它会将 `limit` 的值设置为当前 `position` 的值,将 `position` 的值设置为 0。 - `clear`: 清空缓冲区,将缓冲区从读模式切换到写模式,并将 `position` 的值设置为 0,将 `limit` 的值设置为 `capacity` 的值。 - …… @@ -165,7 +165,7 @@ capacity: 8, limit: 3, position: 0 capacity: 8, limit: 8, position: 0 ``` -为了帮助理解,我绘制了一张图片展示 `capacity`、`limit`和`position`每一阶段的变化。 +为了帮助理解,我绘制了一张图片展示 `capacity`、`limit` 和 `position` 每一阶段的变化。 ![capacity、limit和position每一阶段的变化](https://oss.javaguide.cn/github/javaguide/java/nio/NIOBufferClassAttributesDataChanges.png) @@ -195,8 +195,8 @@ Channel 与前面介绍的 Buffer 打交道,读操作的时候将 Channel 中 Channel 最核心的两个方法: -1. `read` :读取数据并写入到 Buffer 中。 -2. `write` :将 Buffer 中的数据写入到 Channel 中。 +1. `read`:读取数据并写入到 Buffer 中。 +2. `write`:将 Buffer 中的数据写入到 Channel 中。 这里我们以 `FileChannel` 为例演示一下是读取文件数据的。 @@ -222,7 +222,7 @@ Selector 可以监听以下四种事件类型: 3. `SelectionKey.OP_READ`:表示通道准备好进行读取的事件,即有数据可读。 4. `SelectionKey.OP_WRITE`:表示通道准备好进行写入的事件,即可以写入数据。 -`Selector`是抽象类,可以通过调用此类的 `open()` 静态方法来创建 Selector 实例。Selector 可以同时监控多个 `SelectableChannel` 的 `IO` 状况,是非阻塞 `IO` 的核心。 +`Selector` 是抽象类,可以通过调用此类的 `open()` 静态方法来创建 Selector 实例。Selector 可以同时监控多个 `SelectableChannel` 的 `IO` 状况,是非阻塞 `IO` 的核心。 一个 Selector 实例有三个 `SelectionKey` 集合: @@ -345,9 +345,9 @@ public class NioSelectorExample { ## NIO 零拷贝 -零拷贝是提升 IO 操作性能的一个常用手段,像 ActiveMQ、Kafka 、RocketMQ、QMQ、Netty 等顶级开源项目都用到了零拷贝。 +零拷贝是提升 IO 操作性能的一个常用手段,像 ActiveMQ、Kafka、RocketMQ、QMQ、Netty 等顶级开源项目都用到了零拷贝。 -零拷贝是指计算机执行 IO 操作时,CPU 不需要将数据从一个存储区域复制到另一个存储区域,从而可以减少上下文切换以及 CPU 的拷贝时间。也就是说,零拷贝主要解决操作系统在处理 I/O 操作时频繁复制数据的问题。零拷贝的常见实现技术有: `mmap+write`、`sendfile`和 `sendfile + DMA gather copy` 。 +零拷贝是指计算机执行 IO 操作时,CPU 不需要将数据从一个存储区域复制到另一个存储区域,从而可以减少上下文切换以及 CPU 的拷贝时间。也就是说,零拷贝主要解决操作系统在处理 I/O 操作时频繁复制数据的问题。零拷贝的常见实现技术有: `mmap+write`、`sendfile` 和 `sendfile + DMA gather copy`。 下图展示了各种零拷贝技术的对比图: @@ -363,7 +363,7 @@ public class NioSelectorExample { Java 对零拷贝的支持: - `MappedByteBuffer` 是 NIO 基于内存映射(`mmap`)这种零拷⻉⽅式的提供的⼀种实现,底层实际是调用了 Linux 内核的 `mmap` 系统调用。它可以将一个文件或者文件的一部分映射到内存中,形成一个虚拟内存文件,这样就可以直接操作内存中的数据,而不需要通过系统调用来读写文件。 -- `FileChannel` 的`transferTo()/transferFrom()`是 NIO 基于发送文件(`sendfile`)这种零拷贝方式的提供的一种实现,底层实际是调用了 Linux 内核的 `sendfile`系统调用。它可以直接将文件数据从磁盘发送到网络,而不需要经过用户空间的缓冲区。关于`FileChannel`的用法可以看看这篇文章:[Java NIO 文件通道 FileChannel 用法](https://www.cnblogs.com/robothy/p/14235598.html)。 +- `FileChannel` 的 `transferTo()/transferFrom()` 是 NIO 基于发送文件(`sendfile`)这种零拷贝方式的提供的一种实现,底层实际是调用了 Linux 内核的 `sendfile` 系统调用。它可以直接将文件数据从磁盘发送到网络,而不需要经过用户空间的缓冲区。关于 `FileChannel` 的用法可以看看这篇文章:[Java NIO 文件通道 FileChannel 用法](https://www.cnblogs.com/robothy/p/14235598.html)。 代码示例: diff --git a/docs/java/jvm/class-file-structure.md b/docs/java/jvm/class-file-structure.md index 15cb0ca59a1..5ed1ac1295f 100644 --- a/docs/java/jvm/class-file-structure.md +++ b/docs/java/jvm/class-file-structure.md @@ -12,13 +12,13 @@ head: ## 回顾一下字节码 -在 Java 中,JVM 可以理解的代码就叫做`字节码`(即扩展名为 `.class` 的文件),它不面向任何特定的处理器,只面向虚拟机。Java 语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效,而且,由于字节码并不针对一种特定的机器,因此,Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。 +在 Java 中,JVM 可以理解的代码就叫做 `字节码`(即扩展名为 `.class` 的文件),它不面向任何特定的处理器,只面向虚拟机。Java 语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效,而且,由于字节码并不针对一种特定的机器,因此,Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。 -Clojure(Lisp 语言的一种方言)、Groovy、Scala、JRuby、Kotlin 等语言都是运行在 Java 虚拟机之上。下图展示了不同的语言被不同的编译器编译成`.class`文件最终运行在 Java 虚拟机之上。`.class`文件的二进制格式可以使用 [WinHex](https://www.x-ways.net/winhex/) 查看。 +Clojure(Lisp 语言的一种方言)、Groovy、Scala、JRuby、Kotlin 等语言都是运行在 Java 虚拟机之上。下图展示了不同的语言被不同的编译器编译成 `.class` 文件最终运行在 Java 虚拟机之上。`.class` 文件的二进制格式可以使用 [WinHex](https://www.x-ways.net/winhex/) 查看。 ![运行在 Java 虚拟机之上的编程语言](https://oss.javaguide.cn/github/javaguide/java/basis/java-virtual-machine-program-language-os.png) -可以说`.class`文件是不同的语言在 Java 虚拟机之间的重要桥梁,同时也是支持 Java 跨平台很重要的一个原因。 +可以说 `.class` 文件是不同的语言在 Java 虚拟机之间的重要桥梁,同时也是支持 Java 跨平台很重要的一个原因。 ## Class 文件结构总结 @@ -114,7 +114,7 @@ ClassFile { | CONSTANT_MethodHandle_info | 15 | 表示方法句柄 | | CONSTANT_InvokeDynamic_info | 18 | 表示一个动态方法调用点 | -`.class` 文件可以通过`javap -v class类名` 指令来看一下其常量池中的信息(`javap -v class类名-> temp.txt`:将结果输出到 temp.txt 文件)。 +`.class` 文件可以通过 `javap -v class类名` 指令来看一下其常量池中的信息(`javap -v class类名-> temp.txt`:将结果输出到 temp.txt 文件)。 ### 访问标志(Access Flags) @@ -137,7 +137,7 @@ public class Employee { } ``` -通过`javap -v class类名` 指令来看一下类的访问标志。 +通过 `javap -v class类名` 指令来看一下类的访问标志。 ![查看类的访问标志](https://oss.javaguide.cn/github/javaguide/java/%E6%9F%A5%E7%9C%8B%E7%B1%BB%E7%9A%84%E8%AE%BF%E9%97%AE%E6%A0%87%E5%BF%97.png) @@ -154,7 +154,7 @@ Java 类的继承关系由类索引、父类索引和接口索引集合三项确 类索引用于确定这个类的全限定名,父类索引用于确定这个类的父类的全限定名,由于 Java 语言的单继承,所以父类索引只有一个,除了 `java.lang.Object` 之外,所有的 Java 类都有父类,因此除了 `java.lang.Object` 外,所有 Java 类的父类索引都不为 0。 -接口索引集合用来描述这个类实现了哪些接口,这些被实现的接口将按 `implements` (如果这个类本身是接口的话则是`extends`) 后的接口顺序从左到右排列在接口索引集合中。 +接口索引集合用来描述这个类实现了哪些接口,这些被实现的接口将按 `implements` (如果这个类本身是接口的话则是 `extends`) 后的接口顺序从左到右排列在接口索引集合中。 ### 字段表集合(Fields) @@ -165,11 +165,11 @@ Java 类的继承关系由类索引、父类索引和接口索引集合三项确 字段表(field info)用于描述接口或类中声明的变量。字段包括类级变量以及实例变量,但不包括在方法内部声明的局部变量。 -**field info(字段表) 的结构:** +**field info(字段表) 的结构:** ![字段表的结构 ](https://oss.javaguide.cn/github/javaguide/java/%E5%AD%97%E6%AE%B5%E8%A1%A8%E7%9A%84%E7%BB%93%E6%9E%84.png) -- **access_flags:** 字段的作用域(`public` ,`private`,`protected`修饰符),是实例变量还是类变量(`static`修饰符),可否被序列化(transient 修饰符),可变性(final),可见性(volatile 修饰符,是否强制从主内存读写)。 +- **access_flags:** 字段的作用域(`public` ,`private`,`protected` 修饰符),是实例变量还是类变量(`static` 修饰符),可否被序列化(transient 修饰符),可变性(final),可见性(volatile 修饰符,是否强制从主内存读写)。 - **name_index:** 对常量池的引用,表示的字段的名称; - **descriptor_index:** 对常量池的引用,表示字段和方法的描述符; - **attributes_count:** 一个字段还会拥有一些额外的属性,attributes_count 存放属性的个数; @@ -192,7 +192,7 @@ methods_count 表示方法的数量,而 method_info 表示方法表。 Class 文件存储格式中对方法的描述与对字段的描述几乎采用了完全一致的方式。方法表的结构如同字段表一样,依次包括了访问标志、名称索引、描述符索引、属性表集合几项。 -**method_info(方法表的) 结构:** +**method_info(方法表的) 结构:** ![方法表的结构](https://oss.javaguide.cn/github/javaguide/java/%E6%96%B9%E6%B3%95%E8%A1%A8%E7%9A%84%E7%BB%93%E6%9E%84.png) @@ -200,7 +200,7 @@ Class 文件存储格式中对方法的描述与对字段的描述几乎采用 ![方法表的 access_flag 取值](https://oss.javaguide.cn/github/javaguide/java/jvm/class-file-methods-access_flag.png) -注意:因为`volatile`修饰符和`transient`修饰符不可以修饰方法,所以方法表的访问标志中没有这两个对应的标志,但是增加了`synchronized`、`native`、`abstract`等关键字修饰方法,所以也就多了这些关键字对应的标志。 +注意:因为 `volatile` 修饰符和 `transient` 修饰符不可以修饰方法,所以方法表的访问标志中没有这两个对应的标志,但是增加了 `synchronized`、`native`、`abstract` 等关键字修饰方法,所以也就多了这些关键字对应的标志。 ### 属性表集合(Attributes) diff --git a/docs/java/jvm/class-loading-process.md b/docs/java/jvm/class-loading-process.md index 27c50e61121..b40bbed6269 100644 --- a/docs/java/jvm/class-loading-process.md +++ b/docs/java/jvm/class-loading-process.md @@ -36,17 +36,17 @@ head: 2. 将字节流所代表的静态存储结构转换为方法区的运行时数据结构。 3. 在内存中生成一个代表该类的 `Class` 对象,作为方法区这些数据的访问入口。 -虚拟机规范上面这 3 点并不具体,因此是非常灵活的。比如:“通过全类名获取定义此类的二进制字节流” 并没有指明具体从哪里获取( `ZIP`、 `JAR`、`EAR`、`WAR`、网络、动态代理技术运行时动态生成、其他文件生成比如 `JSP`...)、怎样获取。 +虚拟机规范上面这 3 点并不具体,因此是非常灵活的。比如:“通过全类名获取定义此类的二进制字节流” 并没有指明具体从哪里获取(`ZIP`、 `JAR`、`EAR`、`WAR`、网络、动态代理技术运行时动态生成、其他文件生成比如 `JSP`...)、怎样获取。 加载这一步主要是通过我们后面要讲到的 **类加载器** 完成的。类加载器有很多种,当我们想要加载一个类的时候,具体是哪个类加载器加载由 **双亲委派模型** 决定(不过,我们也能打破双亲委派模型)。 > 类加载器、双亲委派模型也是非常重要的知识点,这部分内容在[类加载器详解](https://javaguide.cn/java/jvm/classloader.html “类加载器详解”)这篇文章中有详细介绍到。阅读本篇文章的时候,大家知道有这么个东西就可以了。 -每个 Java 类都有一个引用指向加载它的 `ClassLoader`。不过,数组类不是通过 `ClassLoader` 创建的,而是 JVM 在需要的时候自动创建的,数组类通过`getClassLoader()`方法获取 `ClassLoader` 的时候和该数组的元素类型的 `ClassLoader` 是一致的。 +每个 Java 类都有一个引用指向加载它的 `ClassLoader`。不过,数组类不是通过 `ClassLoader` 创建的,而是 JVM 在需要的时候自动创建的,数组类通过 `getClassLoader()` 方法获取 `ClassLoader` 的时候和该数组的元素类型的 `ClassLoader` 是一致的。 一个非数组类的加载阶段(加载阶段获取类的二进制字节流的动作)是可控性最强的阶段,这一步我们可以去完成还可以自定义类加载器去控制字节流的获取方式(重写一个类加载器的 `loadClass()` 方法)。 -加载阶段与连接阶段的部分动作(如一部分字节码文件格式验证动作)是交叉进行的,加载阶段尚未结束,连接阶段可能就已经开始了。 +加载阶段与连接阶段的部分动作(如一部分字节码文件格式验证动作)是交叉进行的,加载阶段尚未结束,连接阶段可能就已经开始了。 ### 验证 @@ -54,7 +54,7 @@ head: 验证阶段这一步在整个类加载过程中耗费的资源还是相对较多的,但很有必要,可以有效防止恶意代码的执行。任何时候,程序安全都是第一位。 -不过,验证阶段也不是必须要执行的阶段。如果程序运行的全部代码(包括自己编写的、第三方包中的、从外部加载的、动态生成的等所有代码)都已经被反复使用和验证过,在生产环境的实施阶段就可以考虑使用 `-Xverify:none` 参数来关闭大部分的类验证措施,以缩短虚拟机类加载的时间。但是需要注意的是 `-Xverify:none` 和 `-noverify` 在 JDK 13 中被标记为 deprecated ,在未来版本的 JDK 中可能会被移除。 +不过,验证阶段也不是必须要执行的阶段。如果程序运行的全部代码(包括自己编写的、第三方包中的、从外部加载的、动态生成的等所有代码)都已经被反复使用和验证过,在生产环境的实施阶段就可以考虑使用 `-Xverify:none` 参数来关闭大部分的类验证措施,以缩短虚拟机类加载的时间。但是需要注意的是 `-Xverify:none` 和 `-noverify` 在 JDK 13 中被标记为 deprecated,在未来版本的 JDK 中可能会被移除。 验证阶段主要由四个检验阶段组成: @@ -84,11 +84,11 @@ head: **准备阶段是正式为类变量分配内存并设置类变量初始值的阶段**,这些内存都将在方法区中分配。对于该阶段有以下几点需要注意: -1. 这时候进行内存分配的仅包括类变量( Class Variables ,即静态变量,被 `static` 关键字修饰的变量,只与类相关,因此被称为类变量),而不包括实例变量。实例变量会在对象实例化时随着对象一块分配在 Java 堆中。 +1. 这时候进行内存分配的仅包括类变量(Class Variables,即静态变量,被 `static` 关键字修饰的变量,只与类相关,因此被称为类变量),而不包括实例变量。实例变量会在对象实例化时随着对象一块分配在 Java 堆中。 2. 从概念上讲,类变量所使用的内存都应当在 **方法区** 中进行分配。不过有一点需要注意的是:JDK 7 之前,HotSpot 使用永久代来实现方法区的时候,实现是完全符合这种逻辑概念的。 而在 JDK 7 及之后,HotSpot 已经把原本放在永久代的字符串常量池、静态变量等移动到堆中,这个时候类变量则会随着 Class 对象一起存放在 Java 堆中。相关阅读:[《深入理解 Java 虚拟机(第 3 版)》勘误#75](https://github.com/fenixsoft/jvm_book/issues/75 “《深入理解Java虚拟机(第3版)》勘误#75”) -3. 这里所设置的初始值“通常情况”下是数据类型默认的零值(如 0、0L、null、false 等),比如我们定义了`public static int value=111` ,那么 value 变量在准备阶段的初始值就是 0 而不是 111(初始化阶段才会赋值)。特殊情况:比如给 value 变量加上了 final 关键字`public static final int value=111` ,那么准备阶段 value 的值就被赋值为 111。 +3. 这里所设置的初始值“通常情况”下是数据类型默认的零值(如 0、0L、null、false 等),比如我们定义了 `public static int value=111`,那么 value 变量在准备阶段的初始值就是 0 而不是 111(初始化阶段才会赋值)。特殊情况:比如给 value 变量加上了 final 关键字 `public static final int value=111`,那么准备阶段 value 的值就被赋值为 111。 -**基本数据类型的零值**:(图片来自《深入理解 Java 虚拟机》第 3 版 7.3.3 ) +**基本数据类型的零值**:(图片来自《深入理解 Java 虚拟机》第 3 版 7.3.3) ![基本数据类型的零值](https://oss.javaguide.cn/github/javaguide/java/%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E7%9A%84%E9%9B%B6%E5%80%BC.png) @@ -106,13 +106,13 @@ head: ### 初始化 -**初始化阶段是执行初始化方法 ` ()`方法的过程,是类加载的最后一步,这一步 JVM 才开始真正执行类中定义的 Java 程序代码(字节码)。** +**初始化阶段是执行初始化方法 ` ()` 方法的过程,是类加载的最后一步,这一步 JVM 才开始真正执行类中定义的 Java 程序代码(字节码)。** -> 说明:` ()`方法是编译之后自动生成的。 +> 说明:` ()` 方法是编译之后自动生成的。 -对于` ()` 方法的调用,虚拟机会自己确保其在多线程环境中的安全性。因为 ` ()` 方法是带锁线程安全,所以在多线程环境下进行类初始化的话可能会引起多个线程阻塞,并且这种阻塞很难被发现。 +对于 ` ()` 方法的调用,虚拟机会自己确保其在多线程环境中的安全性。因为 ` ()` 方法是带锁线程安全,所以在多线程环境下进行类初始化的话可能会引起多个线程阻塞,并且这种阻塞很难被发现。 -对于初始化阶段,虚拟机严格规范了有且只有 6 种情况下,必须对类进行初始化(只有主动去使用类才会初始化类): +对于初始化阶段,虚拟机严格规范了有且只有 6 种情况下,必须对类进行初始化(只有主动去使用类才会初始化类): 1. 遇到 `new`、`getstatic`、`putstatic` 或 `invokestatic` 这 4 条字节码指令时: - `new`: 创建一个类的实例对象。 @@ -138,7 +138,7 @@ head: 所以,在 JVM 生命周期内,由 jvm 自带的类加载器加载的类是不会被卸载的。但是由我们自定义的类加载器加载的类是可能被卸载的。 -只要想通一点就好了,JDK 自带的 `BootstrapClassLoader`, `ExtClassLoader`, `AppClassLoader` 负责加载 JDK 提供的类,所以它们(类加载器的实例)肯定不会被回收。而我们自定义的类加载器的实例是可以被回收的,所以使用我们自定义加载器加载的类是可以被卸载掉的。 +只要想通一点就好了,JDK 自带的 `BootstrapClassLoader`, `ExtClassLoader`, `AppClassLoader` 负责加载 JDK 提供的类,所以它们(类加载器的实例)肯定不会被回收。而我们自定义的类加载器的实例是可以被回收的,所以使用我们自定义加载器加载的类是可以被卸载掉的。 **参考** diff --git a/docs/java/jvm/classloader.md b/docs/java/jvm/classloader.md index cab40ae33b9..a9a57f3f82a 100644 --- a/docs/java/jvm/classloader.md +++ b/docs/java/jvm/classloader.md @@ -43,7 +43,7 @@ head: > 类加载器是一个负责加载类的对象。`ClassLoader` 是一个抽象类。给定类的二进制名称,类加载器应尝试定位或生成构成类定义的数据。典型的策略是将名称转换为文件名,然后从文件系统中读取该名称的“类文件”。 > -> 每个 Java 类都有一个引用指向加载它的 `ClassLoader`。不过,数组类不是通过 `ClassLoader` 创建的,而是 JVM 在需要的时候自动创建的,数组类通过`getClassLoader()`方法获取 `ClassLoader` 的时候和该数组的元素类型的 `ClassLoader` 是一致的。 +> 每个 Java 类都有一个引用指向加载它的 `ClassLoader`。不过,数组类不是通过 `ClassLoader` 创建的,而是 JVM 在需要的时候自动创建的,数组类通过 `getClassLoader()` 方法获取 `ClassLoader` 的时候和该数组的元素类型的 `ClassLoader` 是一致的。 从上面的介绍可以看出: @@ -63,7 +63,7 @@ class Class { } ``` -简单来说,**类加载器的主要作用就是动态加载 Java 类的字节码( `.class` 文件)到 JVM 中(在内存中生成一个代表该类的 `Class` 对象)。** 字节码可以是 Java 源程序(`.java`文件)经过 `javac` 编译得来,也可以是通过工具动态生成或者通过网络下载得来。 +简单来说,**类加载器的主要作用就是动态加载 Java 类的字节码(`.class` 文件)到 JVM 中(在内存中生成一个代表该类的 `Class` 对象)。** 字节码可以是 Java 源程序(`.java` 文件)经过 `javac` 编译得来,也可以是通过工具动态生成或者通过网络下载得来。 其实除了加载类之外,类加载器还可以加载 Java 应用所需的资源如文本、图像、配置文件、视频等等文件资源。本文只讨论其核心功能:加载类。 @@ -91,22 +91,22 @@ public abstract class ClassLoader { JVM 中内置了三个重要的 `ClassLoader`: -1. **`BootstrapClassLoader`(启动类加载器)**:最顶层的加载类,由 C++实现,通常表示为 null,并且没有父级,主要用来加载 JDK 内部的核心类库( `%JAVA_HOME%/lib`目录下的 `rt.jar`、`resources.jar`、`charsets.jar`等 jar 包和类)以及被 `-Xbootclasspath`参数指定的路径下的所有类。 -2. **`ExtensionClassLoader`(扩展类加载器)**:主要负责加载 `%JRE_HOME%/lib/ext` 目录下的 jar 包和类以及被 `java.ext.dirs` 系统变量所指定的路径下的所有类。 -3. **`AppClassLoader`(应用程序类加载器)**:面向我们用户的加载器,负责加载当前应用 classpath 下的所有 jar 包和类。 +1. **`BootstrapClassLoader`(启动类加载器)**:最顶层的加载类,由 C++实现,通常表示为 null,并且没有父级,主要用来加载 JDK 内部的核心类库(`%JAVA_HOME%/lib` 目录下的 `rt.jar`、`resources.jar`、`charsets.jar` 等 jar 包和类)以及被 `-Xbootclasspath` 参数指定的路径下的所有类。 +2. **`ExtensionClassLoader`(扩展类加载器)**:主要负责加载 `%JRE_HOME%/lib/ext` 目录下的 jar 包和类以及被 `java.ext.dirs` 系统变量所指定的路径下的所有类。 +3. **`AppClassLoader`(应用程序类加载器)**:面向我们用户的加载器,负责加载当前应用 classpath 下的所有 jar 包和类。 > 🌈 拓展一下: > -> - **`rt.jar`**:rt 代表“RunTime”,`rt.jar`是 Java 基础类库,包含 Java doc 里面看到的所有的类的类文件。也就是说,我们常用内置库 `java.xxx.*`都在里面,比如`java.util.*`、`java.io.*`、`java.nio.*`、`java.lang.*`、`java.sql.*`、`java.math.*`。 +> - **`rt.jar`**:rt 代表“RunTime”,`rt.jar` 是 Java 基础类库,包含 Java doc 里面看到的所有的类的类文件。也就是说,我们常用内置库 `java.xxx.*` 都在里面,比如 `java.util.*`、`java.io.*`、`java.nio.*`、`java.lang.*`、`java.sql.*`、`java.math.*`。 > - Java 9 引入了模块系统,并且略微更改了上述的类加载器。扩展类加载器被改名为平台类加载器(platform class loader)。Java SE 中除了少数几个关键模块,比如说 `java.base` 是由启动类加载器加载之外,其他的模块均由平台类加载器所加载。 -除了这三种类加载器之外,用户还可以加入自定义的类加载器来进行拓展,以满足自己的特殊需求。就比如说,我们可以对 Java 类的字节码( `.class` 文件)进行加密,加载时再利用自定义的类加载器对其解密。 +除了这三种类加载器之外,用户还可以加入自定义的类加载器来进行拓展,以满足自己的特殊需求。就比如说,我们可以对 Java 类的字节码(`.class` 文件)进行加密,加载时再利用自定义的类加载器对其解密。 ![类加载器层次关系图](https://oss.javaguide.cn/github/javaguide/java/jvm/class-loader-parents-delegation-model.png) -除了 `BootstrapClassLoader` 是 JVM 自身的一部分之外,其他所有的类加载器都是在 JVM 外部实现的,并且全都继承自 `ClassLoader`抽象类。这样做的好处是用户可以自定义类加载器,以便让应用程序自己决定如何去获取所需的类。 +除了 `BootstrapClassLoader` 是 JVM 自身的一部分之外,其他所有的类加载器都是在 JVM 外部实现的,并且全都继承自 `ClassLoader` 抽象类。这样做的好处是用户可以自定义类加载器,以便让应用程序自己决定如何去获取所需的类。 -每个 `ClassLoader` 可以通过`getParent()`获取其父 `ClassLoader`,如果获取到的 `ClassLoader` 为`null`的话,那么该类加载器的父类加载器是 `BootstrapClassLoader` 。 +每个 `ClassLoader` 可以通过 `getParent()` 获取其父 `ClassLoader`,如果获取到的 `ClassLoader` 为 `null` 的话,那么该类加载器的父类加载器是 `BootstrapClassLoader`。 ```java public abstract class ClassLoader { @@ -121,7 +121,7 @@ public abstract class ClassLoader { } ``` -**为什么获取到 `ClassLoader` 为`null`就是 `BootstrapClassLoader` 加载的呢?** 这是因为`BootstrapClassLoader` 由 C++ 实现,由于这个 C++ 实现的类加载器在 Java 中是没有与之对应的类的,所以拿到的结果是 null。 +**为什么获取到 `ClassLoader` 为 `null` 就是 `BootstrapClassLoader` 加载的呢?** 这是因为 `BootstrapClassLoader` 由 C++ 实现,由于这个 C++ 实现的类加载器在 Java 中是没有与之对应的类的,所以拿到的结果是 null。 下面我们来看一个获取 `ClassLoader` 的小案例: @@ -158,24 +158,24 @@ public class PrintClassLoaderTree { 从输出结果可以看出: -- 我们编写的 Java 类 `PrintClassLoaderTree` 的 `ClassLoader` 是`AppClassLoader`; -- `AppClassLoader`的父 `ClassLoader` 是`ExtClassLoader`; -- `ExtClassLoader`的父`ClassLoader`是`Bootstrap ClassLoader`,因此输出结果为 null。 +- 我们编写的 Java 类 `PrintClassLoaderTree` 的 `ClassLoader` 是 `AppClassLoader`; +- `AppClassLoader` 的父 `ClassLoader` 是 `ExtClassLoader`; +- `ExtClassLoader` 的父 `ClassLoader` 是 `Bootstrap ClassLoader`,因此输出结果为 null。 ### 自定义类加载器 -我们前面也说了,除了 `BootstrapClassLoader` 其他类加载器均由 Java 实现且全部继承自`java.lang.ClassLoader`。如果我们要自定义自己的类加载器,很明显需要继承 `ClassLoader`抽象类。 +我们前面也说了,除了 `BootstrapClassLoader` 其他类加载器均由 Java 实现且全部继承自 `java.lang.ClassLoader`。如果我们要自定义自己的类加载器,很明显需要继承 `ClassLoader` 抽象类。 `ClassLoader` 类有两个关键的方法: -- `protected Class loadClass(String name, boolean resolve)`:加载指定二进制名称的类,实现了双亲委派机制 。`name` 为类的二进制名称,`resolve` 如果为 true,在加载时调用 `resolveClass(Class c)` 方法解析该类。 +- `protected Class loadClass(String name, boolean resolve)`:加载指定二进制名称的类,实现了双亲委派机制。`name` 为类的二进制名称,`resolve` 如果为 true,在加载时调用 `resolveClass(Class c)` 方法解析该类。 - `protected Class findClass(String name)`:根据类的二进制名称来查找类,默认实现是空方法。 官方 API 文档中写到: > Subclasses of `ClassLoader` are encouraged to override `findClass(String name)`, rather than this method. > -> 建议 `ClassLoader`的子类重写 `findClass(String name)`方法而不是`loadClass(String name, boolean resolve)` 方法。 +> 建议 `ClassLoader` 的子类重写 `findClass(String name)` 方法而不是 `loadClass(String name, boolean resolve)` 方法。 如果我们不想打破双亲委派模型,就重写 `ClassLoader` 类中的 `findClass()` 方法即可,无法被父类加载器加载的类最终会通过这个方法被加载。但是,如果想打破双亲委派模型则需要重写 `loadClass()` 方法。 @@ -206,7 +206,7 @@ public class PrintClassLoaderTree { 注意 ⚠️:双亲委派模型并不是一种强制性的约束,只是 JDK 官方推荐的一种方式。如果我们因为某些特殊需求想要打破双亲委派模型,也是可以的,后文会介绍具体的方法。 -其实这个双亲翻译的容易让别人误解,我们一般理解的双亲都是父母,这里的双亲更多地表达的是“父母这一辈”的人而已,并不是说真的有一个 `MotherClassLoader` 和一个`FatherClassLoader` 。个人觉得翻译成单亲委派模型更好一些,不过,国内既然翻译成了双亲委派模型并流传了,按照这个来也没问题,不要被误解了就好。 +其实这个双亲翻译的容易让别人误解,我们一般理解的双亲都是父母,这里的双亲更多地表达的是“父母这一辈”的人而已,并不是说真的有一个 `MotherClassLoader` 和一个 `FatherClassLoader`。个人觉得翻译成单亲委派模型更好一些,不过,国内既然翻译成了双亲委派模型并流传了,按照这个来也没问题,不要被误解了就好。 另外,类加载器之间的父子关系一般不是以继承的关系来实现的,而是通常使用组合关系来复用父加载器的代码。 @@ -276,7 +276,7 @@ protected Class loadClass(String name, boolean resolve) 结合上面的源码,简单总结一下双亲委派模型的执行流程: - 在类加载的时候,系统会首先判断当前类是否被加载过。已经被加载的类会直接返回,否则才会尝试加载(每个父类加载器都会走一遍这个流程)。 -- 类加载器在进行类加载的时候,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成(调用父加载器 `loadClass()`方法来加载类)。这样的话,所有的请求最终都会传送到顶层的启动类加载器 `BootstrapClassLoader` 中。 +- 类加载器在进行类加载的时候,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成(调用父加载器 `loadClass()` 方法来加载类)。这样的话,所有的请求最终都会传送到顶层的启动类加载器 `BootstrapClassLoader` 中。 - 只有当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去加载(调用自己的 `findClass()` 方法来加载类)。 - 如果子类加载器也无法加载这个类,那么它会抛出一个 `ClassNotFoundException` 异常。 @@ -296,7 +296,7 @@ JVM 区分不同类的依据是类名加上加载该类的类加载器,即使 然而,即使攻击者绕过了双亲委派模型,Java 仍然具备更底层的安全机制来保护核心类库。`ClassLoader` 的 `preDefineClass` 方法会在定义类之前进行类名校验。任何以 `"java."` 开头的类名都会触发 `SecurityException`,阻止恶意代码定义或加载伪造的核心类。 -JDK 8 中`ClassLoader#preDefineClass` 方法源码如下: +JDK 8 中 `ClassLoader#preDefineClass` 方法源码如下: ```java private ProtectionDomain preDefineClass(String name, @@ -335,13 +335,13 @@ JDK 9 中这部分逻辑有所改变,多了平台类加载器(`getPlatformCl ~~为了避免双亲委托机制,我们可以自己定义一个类加载器,然后重写 `loadClass()` 即可。~~ -**🐛 修正(参见:[issue871](https://github.com/Snailclimb/JavaGuide/issues/871) )**:自定义加载器的话,需要继承 `ClassLoader` 。如果我们不想打破双亲委派模型,就重写 `ClassLoader` 类中的 `findClass()` 方法即可,无法被父类加载器加载的类最终会通过这个方法被加载。但是,如果想打破双亲委派模型则需要重写 `loadClass()` 方法。 +**🐛 修正(参见:[issue871](https://github.com/Snailclimb/JavaGuide/issues/871))**:自定义加载器的话,需要继承 `ClassLoader`。如果我们不想打破双亲委派模型,就重写 `ClassLoader` 类中的 `findClass()` 方法即可,无法被父类加载器加载的类最终会通过这个方法被加载。但是,如果想打破双亲委派模型则需要重写 `loadClass()` 方法。 为什么是重写 `loadClass()` 方法打破双亲委派模型呢?双亲委派模型的执行流程已经解释了: -> 类加载器在进行类加载的时候,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成(调用父加载器 `loadClass()`方法来加载类)。 +> 类加载器在进行类加载的时候,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成(调用父加载器 `loadClass()` 方法来加载类)。 -重写 `loadClass()`方法之后,我们就可以改变传统双亲委派模型的执行流程。例如,子类加载器可以在委派给父类加载器之前,先自己尝试加载这个类,或者在父类加载器返回之后,再尝试从其他地方加载这个类。具体的规则由我们自己实现,根据项目需求定制化。 +重写 `loadClass()` 方法之后,我们就可以改变传统双亲委派模型的执行流程。例如,子类加载器可以在委派给父类加载器之前,先自己尝试加载这个类,或者在父类加载器返回之后,再尝试从其他地方加载这个类。具体的规则由我们自己实现,根据项目需求定制化。 我们比较熟悉的 Tomcat 服务器为了能够优先加载 Web 应用目录下的类,然后再加载其他目录下的类,就自定义了类加载器 `WebAppClassLoader` 来打破双亲委托机制。这也是 Tomcat 下 Web 应用之间的类实现隔离的具体原理。 @@ -351,20 +351,20 @@ Tomcat 的类加载器的层次结构如下: Tomcat 这四个自定义的类加载器对应的目录如下: -- `CommonClassLoader`对应`/common/*` -- `CatalinaClassLoader`对应`/server/*` -- `SharedClassLoader`对应 `/shared/*` -- `WebAppClassloader`对应 `/webapps//WEB-INF/*` +- `CommonClassLoader` 对应 `/common/*` +- `CatalinaClassLoader` 对应 `/server/*` +- `SharedClassLoader` 对应 `/shared/*` +- `WebAppClassloader` 对应 `/webapps//WEB-INF/*` 从图中的委派关系中可以看出: -- `CommonClassLoader`作为 `CatalinaClassLoader` 和 `SharedClassLoader` 的父加载器。`CommonClassLoader` 能加载的类都可以被 `CatalinaClassLoader` 和 `SharedClassLoader` 使用。因此,`CommonClassLoader` 是为了实现公共类库(可以被所有 Web 应用和 Tomcat 内部组件使用的类库)的共享和隔离。 -- `CatalinaClassLoader` 和 `SharedClassLoader` 能加载的类则与对方相互隔离。`CatalinaClassLoader` 用于加载 Tomcat 自身的类,为了隔离 Tomcat 本身的类和 Web 应用的类。`SharedClassLoader` 作为 `WebAppClassLoader` 的父加载器,专门来加载 Web 应用之间共享的类,但是在Tomcat的默认配置下`catalina.properties`配置文件的`shared.loader= `值为空,所以`SharedClassLoader` 并不生效,`SharedClassLoader` 实际上会退化为 `CommonClassLoader`,`SharedClassLoader`比较合适用来加载多个web应用间共享的类库,比如整个公司级别的监控、日志等。 +- `CommonClassLoader` 作为 `CatalinaClassLoader` 和 `SharedClassLoader` 的父加载器。`CommonClassLoader` 能加载的类都可以被 `CatalinaClassLoader` 和 `SharedClassLoader` 使用。因此,`CommonClassLoader` 是为了实现公共类库(可以被所有 Web 应用和 Tomcat 内部组件使用的类库)的共享和隔离。 +- `CatalinaClassLoader` 和 `SharedClassLoader` 能加载的类则与对方相互隔离。`CatalinaClassLoader` 用于加载 Tomcat 自身的类,为了隔离 Tomcat 本身的类和 Web 应用的类。`SharedClassLoader` 作为 `WebAppClassLoader` 的父加载器,专门来加载 Web 应用之间共享的类,但是在 Tomcat 的默认配置下 `catalina.properties` 配置文件的 `shared.loader= ` 值为空,所以 `SharedClassLoader` 并不生效,`SharedClassLoader` 实际上会退化为 `CommonClassLoader`,`SharedClassLoader` 比较合适用来加载多个 web 应用间共享的类库,比如整个公司级别的监控、日志等。 - 每个 Web 应用都会创建一个单独的 `WebAppClassLoader`,并在启动 Web 应用的线程里设置线程线程上下文类加载器为 `WebAppClassLoader`。各个 `WebAppClassLoader` 实例之间相互隔离,进而实现 Web 应用之间的类隔。 单纯依靠自定义类加载器没办法满足某些场景的要求,例如,有些情况下,高层的类加载器需要加载低层的加载器才能加载的类。 -比如,SPI 中,SPI 的接口(如 `java.sql.Driver`)是由 Java 核心库提供的,由`BootstrapClassLoader` 加载。而 SPI 的实现(如`com.mysql.cj.jdbc.Driver`)是由第三方供应商提供的,它们是由应用程序类加载器或者自定义类加载器来加载的。默认情况下,一个类及其依赖类由同一个类加载器加载。所以,加载 SPI 的接口的类加载器(`BootstrapClassLoader`)也会用来加载 SPI 的实现。按照双亲委派模型,`BootstrapClassLoader` 是无法找到 SPI 的实现类的,因为它无法委托给子类加载器去尝试加载。 +比如,SPI 中,SPI 的接口(如 `java.sql.Driver`)是由 Java 核心库提供的,由 `BootstrapClassLoader` 加载。而 SPI 的实现(如 `com.mysql.cj.jdbc.Driver`)是由第三方供应商提供的,它们是由应用程序类加载器或者自定义类加载器来加载的。默认情况下,一个类及其依赖类由同一个类加载器加载。所以,加载 SPI 的接口的类加载器(`BootstrapClassLoader`)也会用来加载 SPI 的实现。按照双亲委派模型,`BootstrapClassLoader` 是无法找到 SPI 的实现类的,因为它无法委托给子类加载器去尝试加载。 这里需要注意:JDK 9+ 之后引入模块化,JDBC API 被拆分到 `java.sql` 模块中,不再是 `BootstrapClassLoader` 直接加载,而是由 `PlatformClassLoader` 加载。 @@ -386,11 +386,11 @@ public class ClassLoaderTest { 如何解决这个问题呢? 这个时候就需要用到 **线程上下文类加载器(`ThreadContextClassLoader`)** 了。 -拿 Spring 这个例子来说,当 Spring 需要加载业务类的时候,它不是用自己的类加载器,而是用当前线程的上下文类加载器。还记得我上面说的吗?每个 Web 应用都会创建一个单独的 `WebAppClassLoader`,并在启动 Web 应用的线程里设置线程线程上下文类加载器为 `WebAppClassLoader`。这样就可以让高层的类加载器(`SharedClassLoader`)借助子类加载器( `WebAppClassLoader`)来加载业务类,破坏了 Java 的类加载委托机制,让应用逆向使用类加载器。 +拿 Spring 这个例子来说,当 Spring 需要加载业务类的时候,它不是用自己的类加载器,而是用当前线程的上下文类加载器。还记得我上面说的吗?每个 Web 应用都会创建一个单独的 `WebAppClassLoader`,并在启动 Web 应用的线程里设置线程线程上下文类加载器为 `WebAppClassLoader`。这样就可以让高层的类加载器(`SharedClassLoader`)借助子类加载器(`WebAppClassLoader`)来加载业务类,破坏了 Java 的类加载委托机制,让应用逆向使用类加载器。 线程上下文类加载器的原理是将一个类加载器保存在线程私有数据里,跟线程绑定,然后在需要的时候取出来使用。这个类加载器通常是由应用程序或者容器(如 Tomcat)设置的。 -`Java.lang.Thread` 中的`getContextClassLoader()`和 `setContextClassLoader(ClassLoader cl)`分别用来获取和设置线程的上下文类加载器。如果没有通过`setContextClassLoader(ClassLoader cl)`进行设置的话,线程将继承其父线程的上下文类加载器。 +`Java.lang.Thread` 中的 `getContextClassLoader()` 和 `setContextClassLoader(ClassLoader cl)` 分别用来获取和设置线程的上下文类加载器。如果没有通过 `setContextClassLoader(ClassLoader cl)` 进行设置的话,线程将继承其父线程的上下文类加载器。 Spring 获取线程线程上下文类加载器的代码如下: @@ -409,4 +409,4 @@ cl = Thread.currentThread().getContextClassLoader(); - Class ClassLoader - Oracle 官方文档: - 老大难的 Java ClassLoader 再不理解就老了: - \ No newline at end of file + diff --git a/docs/java/jvm/jdk-monitoring-and-troubleshooting-tools.md b/docs/java/jvm/jdk-monitoring-and-troubleshooting-tools.md index 55a4a80f521..d1b1f004f6a 100644 --- a/docs/java/jvm/jdk-monitoring-and-troubleshooting-tools.md +++ b/docs/java/jvm/jdk-monitoring-and-troubleshooting-tools.md @@ -61,7 +61,7 @@ jstat(JVM Statistics Monitoring Tool) 使用于监视虚拟机各种运行 jstat -