Syrena

Java 文件与 I/O 流：File、字节流、字符流与文件操作

Tue, 06 Oct 2026 00:00:00 GMT

从开发的角度，文件分为两类

文本文件
二进制文件

文本文件是指，文件中的数据按照某种字符编码（UTF-8、GBK）存储，本质上是一系列字符。当然，字面意思就是，文件里保存的是人可以直接阅读的文字。

二进制文件是指，文件中的数据以二进制形式直接保存，不按照字符编码解析。

Java 标准库中提供了一系列的类操作文件

文件系统操作（创建文件、删除文件、重命名、创建目录）
文件内容操作（针对一个文件的内容进行读和写）

Java 中通过java.io.File类对一个文件（包括目录）进行抽象的描述。注意，有 File 对象，并不代表真实存在该文件。

1.File 概述

属性

修饰符及类型	属性	说明
`static String`	`pathSeparator`	依赖于系统的路径列表分隔符，以 `String`类型表示
`static char`	`pathSeparatorChar`	依赖于系统的路径列表分隔符，以 `char`类型表示

构造方法

签名	说明
`File(File parent, String child)`	根据父目录的 `File`对象和子路径，创建新的 `File`实例
`File(String pathname)`	根据路径创建新的 `File`实例，路径可以是绝对路径或相对路径
`File(String parent, String child)`	根据父目录路径字符串和子路径，创建新的 `File`实例

String 类型的参数是文件的路径，使用绝对/相对路径均可~

方法

返回值类型	方法签名	说明
`String`	`getParent()`	返回父路径；没有父路径时返回 `null`
`String`	`getName()`	返回文件或目录的名称
`String`	`getPath()`	返回 `File`对象描述的路径
`String`	`getAbsolutePath()`	返回绝对路径
`String`	`getCanonicalPath()`	返回规范化的绝对路径
`boolean`	`exists()`	判断对应的文件或目录是否真实存在
`boolean`	`isDirectory()`	判断对应的对象是否为目录
`boolean`	`isFile()`	判断对应的对象是否为普通文件
`boolean`	`createNewFile()`	创建空文件；成功创建返回 `true`，目标已存在返回 `false`
`boolean`	`delete()`	删除文件或空目录；成功返回 `true`
`void`	`deleteOnExit()`	登记在 JVM 正常退出时尝试删除对应的文件或目录
`String[]`	`list()`	返回目录中直接子文件和子目录的名称
`File[]`	`listFiles()`	返回目录中直接子文件和子目录对应的 `File`对象
`boolean`	`mkdir()`	创建目标目录，不创建缺失的父目录
`boolean`	`mkdirs()`	创建目标目录，必要时一并创建缺失的父目录
`boolean`	`renameTo(File dest)`	重命名或移动到目标路径；成功返回 `true`
`boolean`	`canRead()`	判断当前程序是否可以读取对应的文件或目录
`boolean`	`canWrite()`	判断当前程序是否可以写入对应的文件或目录

2. 文件内容的读写--数据流

Java 中提供了几十个这样的流，在此我只讲解其中 8 个就足够了~

针对上述几十个流，分成两个大类别：

字节流 读写文件，以字节为单位。是针对二进制文件使用的
1. InputStream 输入
2. OutputStream 输出
字符流 读写文件，以字符为单位。是针对文本文件使用的
1. Reader 输入
2. Writer 输出

关于判断输入输出的方法：

屁股坐在 CPU 上，迎面而来是输入，离你而去是输出。

InputStream 概述

方法

修饰符及返回值类型	方法签名	说明
int	`read()`	读取一个字节的数据，返回 `-1`代表已经完全读完了
int	`read(byte[] b)`	最多读取 `b.length`字节的数据到 `b`中，返回实际读取的数量，`-1`代表已经读完了
int	`read(byte[] b, int off, int len)`	最多读取 `len - off`字节的数据到 `b`中，放在从 `off`开始的位置，返回实际读取的数量，`-1`代表已经读完了
void	`close()`	关闭字节流

注意：

InputStream 只是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream 类，现在只关心从文件中读取，所以使用 FileInputStream（InputStream 的子类）

FileInputStream 概述

构造方法

签名	说明
`FileInputStream(File file)`	利用 `File`构造文件输入流
`FileInputStream(String name)`	利用文件路径构造文件输入流

InputStream inputStream = new FileInputStream("路径")当此处创建对象操作一旦成功，就相当于“打开文件”，同样还有关闭文件的方法，inputStream.close()

虽然在 Java 中只需要申请内存资源即可，释放交给 GC 自动完成。但是，文件资源不等同于内存资源，虽然 GC 能够自动管理内存，但是不能自动管理文件，需要我们手动释放。若不手动释放，就会引起“文件资源泄露”，也就是俗话说的“占着茅坑不拉屎”

因为进程 -> PCB -> 文件描述符表

每次程序打开一个文件，就会在文件描述符表（固定长度的顺序表）中申请一个表项（占个坑），然后如果光打开不关闭，就会使这里的文件描述符表的表项耗尽。后续再次打开就会失败~

至于为什么文件描述符表不能自动扩容，因为如果这么做的话，会更推进一步去加大内存操作中的不可控的因素~

注意：

另外，再补充一处，关于 InputStream 创建对象的时候一般使用 try-with-resource（Java1.5 引入的语法，我在 JDBC 也已经讲过）去包裹。以保证最终走出 try 代码块的时候能够自动关闭并释放。（可以不只实现一个对象~）

强调：能使用此方法创建的类必须实现 Closable 接口

使用例子如下：

public static void main(String[] args) throws IOException {
    try (InputStream inputStream 
         = new FileInputStream("./test.txt")) {
        while (true) {
            int data = inputStream.read();
            if(data == -1) {
                // 文件读完
                break;
            }
            System.out.printf("0x%x\n",data);
        }
    }
}

IntputStream 中的三个 read 方法

方法	含义	返回值
`read()`	一次读取 1 个字节	字节值 `0~255`，结束返回 `-1`
`read(byte[] b)`	一次读取多个字节	实际读取的字节数，结束返回 `-1`
`read(byte[] b, int off, int len)`	读取数据到数组指定位置	实际读取的字节数，结束返回 `-1`

对于无参数的 read 方法，如果没读完就会返回读到的字节值，读完了就返回-1

注意：剩下两个有参数的 read 返回的是读取到的字节数。仔细想想会比较特殊，它使用的是参数作为方法的返回值~ 在 Java 中比较少见，这种称之为“输出型参数”。一般来说，把方法想象成工厂，返回值就是产品；

public static void main(String[] args) throws IOException {
    try (InputStream inputStream 
         = new FileInputStream("./test.txt")) {
        while (true) {
            byte[] data = new byte[1024];
            int n = inputStream.read(data);
            if (n == -1) {
                // 文件读完
                break;
            }
            for (int i = 0; i < n; i++) {
                System.out.printf("0x%x\n",data[i]);
            }
        }
    }
}

Java 中，如果参数是引用类型，方法内部修改对象的时候，能影响到方法外部~ 即：

当方法参数是引用类型时，方法拿到的是“对象引用的副本”。虽然引用本身是复制的，但这个副本和方法外面的引用仍然指向同一个对象，所以通过它修改对象内部的数据，外面能看到变化。

对于第三个 read 方法：read(byte[] b, int off, int len)

其中 off 是指 offset 偏移量（数组下标），放置 len 数量个~

OutpuStream 概述

方法

修饰符及返回值类型	方法签名	说明
`void`	`write(int b)`	写入一个字节的数据
`void`	`write(byte[] b)`	将 `b`这个字节数组中的数据全部写入输出流中
`void`	`write(byte[] b, int off, int len)`	将字节数组 `b`中从 `off`位置开始的 `len`个字节写入输出流中
`void`	`close()`	关闭字节输出流，并释放与该流相关的系统资源
`void`	`flush()`	刷新输出流，将缓冲区中尚未真正写出的数据立即写入目标设备

说明一下：OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中，所以使用 FileOutputStream

此处的 writer 方法与前面的 read 方法类似，分为单个字节写入，多个字节写入以及多个字节拼接写入~

另外，对于OutputStream 来说，默认情况下会默认创建该文件。并且是以覆盖形式去写入。如果想要避免此情况，就需要使用追加写，即使用该构造方法FileOutputStream(File file, boolean append)

FileOutputStream 概述

构造方法：

构造方法	说明
`FileOutputStream(String name)`	根据文件路径创建字节输出流。文件不存在会创建；文件已存在会清空原内容
`FileOutputStream(String name, boolean append)`	根据文件路径创建字节输出流，并指定是否追加写入
`FileOutputStream(File file)`	根据 `File` 对象创建字节输出流。文件已存在时会清空原内容
`FileOutputStream(File file, boolean append)`	根据 `File` 对象创建字节输出流，并指定是否追加写入
`FileOutputStream(FileDescriptor fdObj)`	根据已有的文件描述符创建输出流，实际开发中较少直接使用

public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("./output.txt")){
            byte[] bytes = {97,98,99};
            outputStream.write(bytes);

        } catch (IOException e) {
            // 此处是需要处理两个异常. 由于此处并没有针对这两个异常提供不同的处理, 就直接合并了.
            throw new RuntimeException(e);
        }
    }

Reader 概述

构造方法：

修饰符	构造方法	说明
`protected`	`Reader()`	创建一个新的字符输入流对象，默认以当前 Reader 对象作为同步锁
`protected`	`Reader(Object lock)`	创建字符输入流，并指定用于同步操作的锁对象

因为他们是protected，而且Reader是抽象类,所以通常不直接使用这两个构造方法。

方法：

返回值类型	方法	说明
`int`	`read()`	一次读取一个字符，读取到末尾返回 `-1`
`int`	`read(char[] cbuf)`	一次读取多个字符到字符数组中，返回实际读取的字符数量；末尾返回 `-1`
`int`	`read(char[] cbuf, int off, int len)`	从字符数组的 `off`位置开始，最多存入 `len`个字符
`long`	`skip(long n)`	跳过 `n`个字符，返回实际跳过的字符数量
`boolean`	`ready()`	判断当前字符流是否已经可以读取
`boolean`	`markSupported()`	判断当前流是否支持 `mark()`操作
`void`	`mark(int readAheadLimit)`	标记当前读取位置
`void`	`reset()`	回到最近一次 `mark()`标记的位置
`void`	`close()`	关闭字符输入流并释放相关资源

以上的 read 方法与前面的还是类似。

无参数版本的 read 一次读一个字符。返回的相当于是一个 char，两个字节。

char[] 数组版本是读字符数组，尽可能把字符数组给填满，返回实际读到的字符个数。

第三个版本的 read 中的 CharBuffer，其实就相当于 char[] 进行了封装。

public static void main(String[] args) {
        try (Reader reader = new FileReader("./test.txt")) {
            while (true) {
                int c = reader.read();
                if(c == -1) {
                    break;
                }
                System.out.println((char) c);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

假设./test.txt 文件中，是“你好”两个字

但如果我不是强转为 char 类型，那么得到的结果就是20320 和 22909。那么之前还说过 utf8 中汉字占 3 个字节，为什么这里得到的是两组数字？

字节流读到的是文件中的原始数据，在硬盘上保存文件的时候，就是 6 个字节，utf8 编码。

字符流在读取的时候，就会根据文件的内容编码格式进行解析。read()一次，就会读到 3 个字节（按照 utf8 解析）。返回的时候，针对 3 个字节进行转码了，拿着 3 个字节查了一下 utf8 的码表“你”。read 就又把你这个汉字在 unicode 这个码表中再次查询一次，得到 unicode 的编码值。最终把 unicode 的编码值返回到 char 变量中（两个字节了）

以上就是自动进行转码了~

Writer 概述

构造方法

修饰符	构造方法	说明
`protected`	`Writer()`	创建字符输出流，默认使用当前对象作为同步锁
`protected`	`Writer(Object lock)`	创建字符输出流，并指定同步锁对象

因为Writer是抽象类，所以一般不会直接创建Writer对象。

方法

返回值类型	方法	说明
`void`	`write(int c)`	写入一个字符
`void`	`write(char[] cbuf)`	写入一个字符数组中的全部字符
`void`	`write(char[] cbuf, int off, int len)`	写入字符数组中从 `off`开始的 `len`个字符
`void`	`write(String str)`	写入一个字符串
`void`	`write(String str, int off, int len)`	写入字符串中从 `off`开始的 `len`个字符
`Writer`	`append(char c)`	追加一个字符
`Writer`	`append(CharSequence csq)`	追加一个字符序列
`void`	`flush()`	刷新字符输出流，将缓冲的数据写出
`void`	`close()`	关闭输出流并释放资源

上面看似是五个版本的 write 方法，其实也还是三个。

当前 IO 流对象，read 和 write 就属于直接读写文件了。要想提高效率：

写代码的时候，手动床见缓冲区（byte[]），手动减少 read write 次数
使用标准库提供的“缓冲区流”BufferStream 把 InputStream 之类的对象套上一层

示例一

扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要删除该文件

package file;

import java.io.File;
import java.util.Scanner;

public class mySearchAndDelete {
    public void searchAndDelete () {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要搜索的目录：");
        String rootDir = scanner.next();
        File rootfile = new File(rootDir);
        if (!rootfile.isDirectory()) {
            System.out.println("输入的不是目录！");
            return;
        }
        System.out.println("请输入要删除的关键字：");
        String keyWord = scanner.next();
        int count = scanDir(rootfile, keyWord, scanner);
        if (count == 0) {
            System.out.println("没有发现带有关键字的文件");
        } else {
            System.out.println("搜索完成，共发现 " + count + " 个匹配文件。");
        }
    }

    public int scanDir(File rootfile, String keyWord, Scanner scanner) {
        // 1. 列出当前目录中包含的内容
        File[] files = rootfile.listFiles();
        if (files == null) {
            return 0;
        }
        int count = 0;
        // 2. 遍历当前目录中的内容
        for (File file : files) {
            // 3. 判断当前文件是目录 or 文件
            if (!file.isFile()) {
                // 4. 如果是目录，继续遍历
                count += scanDir(file, keyWord, scanner);
            } else {
                // 5. 如果是文件，则查找关键字
                if (deleteFile(file, keyWord, scanner)) {
                    count++;
                }
            }
        }
        return count;
    }

    private boolean deleteFile(File file, String keyWord, Scanner scanner) {
        if (!file.getName().contains(keyWord)) {
            return false;
        }
        System.out.println(
                "发现文件: "
                        + file.getAbsolutePath()
                        + "，包含关键字！是否删除？(y/n)"
        );
        String input = scanner.next();

        if (input.equalsIgnoreCase("y")) {
            boolean success = file.delete();
            if (success)
                System.out.println("文件已删除！");
            else
                System.out.println("文件删除失败！");
        }
        return true;
    }
}

示例二

进行普通文件的复制

package file;

import java.io.*;
import java.util.Scanner;

public class myCopyFile {
    public void copyFile () {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入源文件路径：");
        String srcPath = scanner.next();
        System.out.println("请输入目标文件路径：");
        String destPath = scanner.next();
        File srcFile = new File(srcPath);

        // 1. 先判断源文件是否存在
        if (!srcFile.isFile()) {
            System.out.println("源文件不存在或不是文件");
            return;
        }
        File destFile = new File(destPath);
        // 如果目标路径是一个已经存在的文件夹
        if (destFile.isDirectory()) {
            destFile = new File(destFile, srcFile.getName());
        }
        // 2. 判断目标文件是路径 or 文件（destPath不一定存在）
        File parentFile = destFile.getParentFile();
        if (parentFile != null && !parentFile.isDirectory()) {
            System.out.println("目标文件所在目录不存在");
            return;
        }
        // 3. 此处进行读写操作
        try (InputStream inputStream = new FileInputStream(srcFile);
             OutputStream outputStream = new FileOutputStream(destFile)) {
            while (true) {
                byte[] buf = new byte[1024];
                int num = inputStream.read(buf);
                if (num == -1) {
                    break;
                }
                outputStream.write(buf, 0, num);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

示例三

扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）

注意：当前现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验

package file;

import java.io.*;
import java.util.Scanner;

public class myFileSearcher {
    public void searchFile () {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要搜索的目录：");
        String rootDir = scanner.next();
        File rootFile = new File(rootDir);
        if (!rootFile.isDirectory()) {
            System.out.println("输入的不是目录！");
            return;
        }
        System.out.println("请输入要搜索的关键字：");
        String keyWord = scanner.next();
        scanDir(rootFile, keyWord, scanner);
    }

    public static void scanDir (File rootFile, String keyWord, Scanner scanner) {
        // 1. 列出当前目录下所有内容
        File[] files = rootFile.listFiles();
        if (files == null) {
            return;
        }
        // 2. 遍历当前目录下的所有文件
        for (File file : files) {
            // 如果是文件
            if (file.isFile()) {
                dealFile(file, keyWord, scanner);
            } else {
                // 如果是目录
                scanDir(file, keyWord, scanner);
            }
        }
    }

    public static void dealFile(File file, String keyWord, Scanner scanner) {
        // 1. 判断文件名是否包含关键字
        if (file.getName().contains(keyWord)) {
            System.out.println("文件名包含关键字:" + file.getAbsolutePath());
        }
        // 2. 判断文件内容是否包含关键字。由于keyWord是字符串，就按照字符流读取
        StringBuilder stringBuilder = new StringBuilder();
        try (Reader reader = new FileReader(file)) {
            while (true) {
                char[] chars = new char[1024];
                int n = reader.read(chars);
                if (n == -1) {
                    break;
                }
                stringBuilder.append(chars, 0, n);
            }
        } catch (IOException e) {
            System.out.println("文件读取失败：" + file.getAbsolutePath());
            return;
        }
        // 3. 判定stringBuilder 是否包含关键字
        if (stringBuilder.indexOf(keyWord) >= 0) {
            System.out.println("文件内容包含关键字: " + file.getAbsolutePath());
        }
        return;
    }
}

Java Socket 编程：TCP、UDP 与回显服务器实践

Tue, 06 Oct 2026 00:00:00 GMT

1.网络编程

网络编程，指通过编写程序，利用计算机网络实现不用设备或进程之间的数据通信。

可以理解为，网络编程就是让两台或多台计算机上的程序能够通过网络交换数据~

就比如像是：

微信聊天：用户发送消息，服务器将消息转发给接收方。
浏览网页：浏览器向服务器发送 HTTP 请求，服务器返回网页内容。

1.1 基本模型

网络编程中最常见的就是客户端/服务端模型，也就是 Client/Server 简称 C/S

但首先需要先了解发送端和接收端：

发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机

接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机

收发端：发送端和接收端两端，也称为收发端

注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向的概念

接下来就到了服务端和客户端~

服务端：在常见的网络数据传输场景下，提供服务的一方进程，称为服务端，可以提供对外服务。

客户端：获取服务的一方进程，称为客户端。

模型就像下图中：

以浏览器访问网站为例：

客户端发送请求：浏览器向服务器发送 HTTP 请求。
服务器接收请求：服务器接收请求并执行相应的业务逻辑。
服务器返回响应：服务器将处理结果通过网络发送给客户端。
客户端接收响应：浏览器接收数据，并将网页内容显示给用户。

2.Socket

接下来才是正题~

浅浅了解计算机网络相关知识就可以知道，程序完成的事情就是把请求发过去，再把响应包收回来。

但关键是 Java 程序或者说代码自身不能自己从头控制网卡、组织所有协议头、处理整个网络通信过程。但操作系统已经提供了这些网络能力~

程序通过一组接口，就能够调用刚刚所说的部分功能。而 Socket 套接字就是操作系统提供的网络通信机制中的通信端点~

可以这样理解：创建和使用 Socket，就是让程序获得了一个用于收发网络数据的端点。

Socket api 这就是传输层给应用层提供的。

而 Java 又把这些能力封装成了类，所以在 Java 中就可以通过创建对象、调用方法来完成通信。

而传输层本身就有两个很重要的协议~

分别是 TCP 和 UDP。这两个协议规定了传输层的通信方式。而 Socket 让程序能够使用这些通行能力。

另外 TCP 和 UDP 差别也非常大，编写代码的时候风格也是不同的~

TCP 是有连接，可靠传输，面向字节流，全双工的
UDP 是无连接，不可靠传输，面向数据报，全双工的

下面分别介绍一下这两个特点，当然也是再温习一遍计算机网络啦

2.1 TCP 协议特点

首先是有连接，TCP 在正式传输数据之前，需要现在通信双方之间建立逻辑连接。通过三次握手来建立连接；然后是在建立好的连接基础上交换数据；再然后就是断开连接，通常是通过四次握手完成也可能通过 RST 等方式终止连接这里的连接不是物理线路，而是双方维护的通信状态，就比如序列号、缓冲区和窗口大小等~
可靠传输。TCP 能够保证，只要连接正常工作并且数据成功交付，接收方就能按照正确顺序获得完整、不重复的字节数据。TCP 主要就是通过这些机制来实现可靠传输：序列号、确认应答（ACK）、超时重传、校验和、接收端去重和重排序、流量控制、拥塞控制。就比如：发送方一次发送 A、B、C 三段数据，其中 B 在网络中丢失。 TCP 会检测到数据缺失，并通过重传等机制尝试恢复数据。另外需要注意的是：可靠传输不代表数据绝对不会丢失，也不代表一定传输成功。如果网络持续中断，TCP 最终可能超时或连接失败。它的可靠性主要体现在不会把缺失、乱序的数据当作完整、有序的数据流正常交付。
首先知道 TCP 是面向字节流的，TCP 将应用程序发送的数据看作一串连续的字节，而不是一条条独立的消息。假设我向对方先后发送两段内容，分别是hello、world。发送方执行了两次 write()，但接收方不一定恰好执行两次 read() 才能读完，意思就是他的一次读取不一定刚好对应发送方的一次发送。但最后接收方看到的还会是按顺序排列的字节helloworld。这也就是为什么 TCP 通信中可能出现应用层所说的粘包、半包问题。本质原因就是 TCP 不保留应用程序每次写入时的消息边界。
最后就是全双工通信。通信双方可以在同一时间发送和接收数据。例如在聊天程序中，客户端可以向服务器发送消息，同时服务器也可以向客户端发送消息，不必等待对方发送完毕。

2.2 UDP 协议

UDP 同样具有四个特点，无连接、不可靠传输、面向数据报、全双工通信。

无连接，UDP 在发送数据之前，不需要像 TCP 一样通过三次握手建立连接。发送方只需要知道接收方的 IP 地址和端口号，就可以尝试发送数据报。

DatagramSocket socket = new DatagramSocket();

byte[] data = "Hello".getBytes();

DatagramPacket packet = new DatagramPacket(
        data,
        data.length,
        InetAddress.getByName("127.0.0.1"),
        8080
);

socket.send(packet);

这里创建 UDP 套接字后，直接调用 send() 发送数据报，无须先建立 TCP 那样的连接。注意了，不需要建立连接，并不意味着接收方一定能收到数据。

不可靠传输。UDP 不提供 TCP 那样的可靠传输保证。在传输过程中可能会出现丢失、乱序、重复、损坏或被丢弃。UDP 本身不提供确认应答、超时重传、按序交付等机制 UDP 并不是一定会丢包，而是协议本身不保证数据一定到达。
面向数据报。UDP 将应用程序每次发送的数据视为一个独立的数据报，保留各个数据报之间的边界。就比如，发送方连续发送：第一个数据报 Hello、第二个数据报 World。接收方不会像 TCP 一样把两个数据报当成一个连续的字节流交付。

至于全双工就可 TCP 一样了。

2.3 UDP 数据包套接字编程

2.3.1 API 介绍

我们都知道，计算机中的“文件”通常都会是一个“广义的概念”。文件还能代指一些硬件设备（操作系统管理硬件设备，也是抽象成文件进行统一管理的）

那么网卡 —> socket 文件

在操作网卡的时候，流程就和操作普通文件差不多，也需要打开 -> 读写 -> 关闭

打开的时候也会在文件描述符表中分配一个表项

DatagramSocket

首先是 DatagramSocket类，它是 UDP Socket，用于发送和接收 UDP 数据报。

其构造方法如下：

构造方法	作用
`DatagramSocket()`	创建 UDP 套接字，由系统分配一个可用的本地端口（一般用于客户端）
`DatagramSocket(int port)`	创建 UDP 套接字，绑定指定的本地端口（一般用于服务端）

主要注意他的参数。

另外要补充，客户端通常不用手动指定的原因是，服务器通常需要一个实现约定的端口，客户端通常使用系统分配的端口。

我这样举个例子更好理解些：

假如我在学校一食堂 18 号窗口开了一家餐饮。那么我向同学们发传单告诉了他们我的餐饮地址，于是同学就知道我的餐饮位置在哪就会来到我的餐饮店前。这就像是客户端需要知道服务端的 IP 地址以及端口号一样。

但是同学来到我窗口点了餐回到座位上时，通常座位会是随机性的，因为你不能保证你去的时候不一定没有人坐吧~所以就像是客户端一样，你也不能保证你指定的端口号是不是被其他的进程给占用了

DatagramSocket的常用方法：

方法	作用
`void send(DatagramPacket p)`	发送数据报，不会阻塞等待，直接发送
`void receive(DatagramPacket p)`	接收数据报，默认会阻塞等待
`int getLocalPort()`	获取这个套接字使用的本地端口
`void close()`	关闭套接字，释放相关资源

此处所说的阻塞等待是，假设服务器执行到了socket.receive(packet);但还没有收到数据。于是执行这个方法的线程就会等待，后面的代码暂时就不会执行。

DatagramPacket

第二个类就是DatagramPacket了。DatagramPacket 用于封装 UDP 通信中发送或接收的数据报包。

它共有 6 个构造方法，可以分为接收数据和发送数据两类。

DatagramPacket用于接收的构造方法：

构造方法	说明
`DatagramPacket(byte[] buf, int length)`	创建接收数据报包，指定缓冲区和最大接收长度
`DatagramPacket(byte[] buf, int offset, int length)`	创建接收数据报包，指定缓冲区、起始偏移量和最大接收长度

使用范例：

byte[] buffer = new byte[4096];

DatagramPacket packet =
        new DatagramPacket(buffer, buffer.length);

此处就相当于准备好一个容器，“收到数据后，请把数据放进这个数组，本次最多接收这么多字节”

真正接收要调用：

socket.receive(packet);

接收完成后，packet 中不仅有数据，还有发送方的 IP 和端口。

receive 与之前的 read 方法一样，这也是一个把参数作为“输出结果”的一个输出型参数

DatagramPacket用于发送的构造方法：

构造方法	说明
`DatagramPacket(byte[] buf, int length, InetAddress address, int port)`	指定数据、长度、目标 IP 地址和端口
`DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)`	指定数据、起始偏移量、长度、目标 IP 地址和端口
`DatagramPacket(byte[] buf, int length, SocketAddress address)`	指定数据和长度，使用 `SocketAddress`<br/> 指定目标地址（包含 IP 地址和端口）
`DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)`	指定数据、起始偏移量和长度，使用 `SocketAddress`<br/> 指定目标地址（包含 IP 地址和端口）

涉及到的一些参数说明：

参数	类型	作用
`buf`	`byte[]`	存放发送或接收数据的字节数组
`offset`	`int`	数据在数组中的起始下标
`length`	`int`	发送数据的长度，或允许接收的最大长度，单位为字节
`address`	`InetAddress`	目标 IP 地址
`port`	`int`	目标端口号
`address`	`SocketAddress`	封装目标 IP 地址和端口号

DatagramPacket常用方法：

方法	作用
`byte[] getData()`	获取存放数据的数组
`int getOffset()`	获取有效数据的起始下标
`int getLength()`	获取待发送或实际收到的数据长度
`InetAddress getAddress()`	获取对方的 IP 地址
`int getPort()`	获取对方的端口号
`SocketAddress getSocketAddress()`	一次获取对方的地址信息

2.3.2 回显服务器示例

UDP Echo Server

将服务器分为两部分，

start()：负责接收请求、处理请求、返回响应
process()：负责具体业务

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpEchoServer {
    public DatagramSocket socket = null;

    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动...");

        while (true) {
            // 1. 读取请求并解析
            // DatagramPacket 表示一个UDP数据包，此处传入的字节数组，就保存UDP的载荷部分
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);
            // 把读取到的二进制数据，转成字符串，只是构造有效的部分
            String request = new String(requestPacket.getData(),
                    0,
                    requestPacket.getLength());

            // 2.根据请求，计算响应（服务器中关键的逻辑）
            // 但此处目前只打算写回显服务器，该环节相当于省略
            String response = process(request);

            // 3.把响应返回给客户端
            // 根据response构造DatagramPacket，发送给客户端
            // 注意：此处不能使用response.length()
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
                    response.getBytes().length,
                    requestPacket.getSocketAddress());
            // 此处还不能直接发送，UDP协议滋生没有保存对方的信息（不知道发给谁）
            // 需要指定目的IP 和 目的端口
            socket.send(responsePacket);

            // 4. 打印一个日志
            System.out.printf("[%s:%d] req: %s, resp: %s\n", responsePacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

UDP Echo Client

UDP 回显客户端，需要完成的如下：

从键盘读取文字；
把文字发送给服务器；
接收服务器返回的文字；
显示结果；

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    public UdpEchoClient (String serverIp, int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        socket = new DatagramSocket();
    }

    public void start () throws IOException {
        Scanner scanner = new Scanner(System.in);
        try {
            while (true) {
                // 1. 从控制台读取用户输入的内容
                System.out.println("请输入要发送的内容：");
                if (!scanner.hasNext()) {
                    break;
                }
                String request = scanner.next();
                // 2. 把请求发送给服务器，需要构造 DatagramPacket 对象
                // 构造过程中，不光要构造载荷，还要设置服务器的IP和端口号
                DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                        request.getBytes().length,
                        InetAddress.getByName(serverIp),
                        serverPort);
                // 3. 发送数据报
                socket.send(requestPacket);
                // 4. 接收服务器的响应
                DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(responsePacket);
                // 5. 从服务器读取的数据进行解析，并打印
                String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
                System.out.println(response);
            }
        } finally {
            socket.close();
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

就可以得到这样一个运行效果~

当然，如果有云服务器的话，可以自己打一个 jar 包放到云服务器上，并启动该程序：

java -jar jar包名

此时该程序就在服务器上运行起来了，只要能访问该服务器的都可以直接进行回显打印~

2.4 TCP 流套接字编程

2.4.1 API 介绍

ServerSocket

ServerSocket是 TCP 服务端用的核心类，作用是在服务器端监听某个端口，并等待客户端建立 TCP 连接。也就是说是专门给服务器用的

常用构造方法：

构造方法	作用
`ServerSocket()`	创建一个尚未绑定端口的 `ServerSocket`
`ServerSocket(int port)`	创建服务器 Socket，并绑定指定端口
`ServerSocket(int port, int backlog)`	绑定端口，并指定连接等待队列长度
`ServerSocket(int port, int backlog, InetAddress bindAddr)`	绑定指定端口、等待队列长度和本机 IP 地址

通常都会直接先指定好端口：

ServerSocket serverSocket = new ServerSocket(9090);

常用方法：

方法	作用
`accept()`	等待客户端连接，并返回一个 `Socket`
`bind(SocketAddress endpoint)`	绑定 IP 和端口
`close()`	关闭服务器 Socket
`isClosed()`	判断是否已经关闭
`isBound()`	判断是否已经绑定地址
`getLocalPort()`	获取当前监听端口
`getInetAddress()`	获取绑定的本机 IP
`getLocalSocketAddress()`	获取完整本地 Socket 地址
`setSoTimeout(int timeout)`	设置 `accept()` 最大阻塞时间
`getSoTimeout()`	获取当前超时时间

其中，注意accept()方法是一个阻塞方法，它会开始监听指定端口，有客户端连接后，返回一个服务端 Socket 对象，并基于该 Socket 建立与客户端的连接，否则阻塞等待~

就比如：

System.out.println("等待客户端连接...");
Socket clientSocket = serverSocket.accept();
System.out.println("客户端已连接");

当执行到accept()的时候，如果暂时没有客户端连接，当前线程就会停在这里~

注意，TCP 这里就没有 send/receive 这样的操作...

Socket

这个类是客户端和服务端都能用。Socket是客户端或服务端中接收到服务端建立连接（accept）的请求后，返回的服务端 Socket。不管是客户端还是服务端，都是双方建立连接后，用来保存对端信息以及与对方收发数据的~

常用构造方法：

方法	说明
`Socket()`	创建一个尚未连接服务器的 Socket 对象，之后需要调用`connect()`建立连接
`Socket(String host, int port)`	根据服务器主机地址和端口号创建 Socket，并立即尝试建立 TCP 连接
`Socket(InetAddress address, int port)`	根据服务器的 `InetAddress`和端口号创建 Socket，并立即尝试建立 TCP 连接
`Socket(String host, int port, InetAddress localAddr, int localPort)`	指定服务器地址、服务器端口、本地 IP 和本地端口建立连接
`Socket(InetAddress address, int port, InetAddress localAddr, int localPort)`	使用 `InetAddress` 指定服务器地址，同时指定本地 IP 和本地端口建立连接

常用方法：

方法	作用
`getInputStream()`	获取输入流，接收数据
`getOutputStream()`	获取输出流，发送数据
`getInetAddress()`	获取对方 IP
`getPort()`	获取对方端口
`getLocalPort()`	获取本地端口
`isConnected()`	判断是否成功连接过
`isClosed()`	判断 Socket 是否关闭
`close()`	关闭 Socket

到这里我再讲上面一起解释了：

在 TCP 中，常会这样去接收客户端发来的连接，你可以理解为这样去接电话~

private ServerSocket serverSocket = null;
Socket clientSocket = serverSocket.accept();

其实就是ServerSocket负责等客户端来连接，Socket负责连接成功之后真正和某个客户端通信

我给个比喻：

private ServerSocket serverSocket = null：理解为小哥在马路牙子上揽客 [ 外场 ]~

Socket clientSocket = serverSocket.accept()：理解为小姐姐给客人提供点单服务 [ 内场 ]~

2.4.2 回显服务器示例

TCP Echo Server

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpEchoServer {
    private ServerSocket serverSocket = null;

    // 此处和UDP服务器类似，也是在构造对象的时候，绑定端口号
    public TcpEchoServer (int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start () throws IOException {
        System.out.println("服務器启动");
        // 此处为提供多个客户端服务，需要使用多线程来解决
        // 否则只能服务于一个客户端
        // 此处用线程池来解决，通常不会使用fixThreadPool
        ExecutorService executorService = Executors.newCachedThreadPool();
        while (true) {
            // 对TCP来说，需要先处理客户端发来的连接
            // 通过读写clientSocket，和客户端进行通信
            // 若无客户端发起连接，此时accept就会阻塞
            // 此处主线程负责进行accpet，每次accept到一个客户端，就创建一个线程
            Socket clientSocket = serverSocket.accept();

            executorService.submit(() -> {
                processConnection(clientSocket);
            });
        }
    }

    // 该方法处理一个客户端的连接，但被线程池调用
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s,%d]客户端上线!\n",
                          clientSocket.getInetAddress(),
                          clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 针对 InputStream 套了一层
            Scanner scanner = new Scanner(inputStream);
            // 针对 OutputStream 套了一层
            PrintWriter writer = new PrintWriter(outputStream);
            // 分成三个步骤
            while (true) {
                // 1. 读取请求并解析，可以直接read，也可以借助Scanner来辅助完成
                if (!scanner.hasNext()) {
                    // 连接断开
                    System.out.printf("[%s,%d] 客户端下线!\n",clientSocket.getInetAddress(),
                                      clientSocket.getPort());
                    break;
                }
                String request = scanner.next();
                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 返回响应到客户端
                writer.println(response);
                writer.flush();
                // 打印日志
                System.out.printf("[%s:%d] req: %s, resp: %s\n",
                                clientSocket.getInetAddress(),
                                clientSocket.getPort(),
                                request,
                                response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(1234);
        server.start();
    }
}

TCP Echo Client

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        // 直接把字符串的IP地址设置进来
        socket = new Socket(serverIp, serverPort);
    }

    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter writer = new PrintWriter(outputStream);

            // 从控制台读取请求，发送给服务器
            while (true) {
                // 1. 从控制台读取用户输入
                String request = scanner.next();
                // 2. 发送给服务器
                writer.println(request);
                // 加上刷新缓冲区操作，才是真正发送数据
                writer.flush();
                // 3. 读取服务器返回的响应
                String response = scannerNet.next();
                // 4. 打印到控制台
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1", 1234);
        client.start();
    }
}

具体解释~

Socket 问题

两部分代码整体的运行逻辑主要就是：

以上是客户端和服务端接收和发送的核心部分，主要就是需要处理清楚请求包和响应包之间的处理关系即可~

另外，客户端里的 socket 和服务端接收客户端请求的 socket 不一样~

这俩 socket 对象不是同一个对象（分别是在不同进程中，甚至在不同主机上）

从更严谨的话来说就是：

这两个 Socket 是两个不同的 Java 对象，分别位于客户端和服务端程序中，但它们代表同一条 TCP 连接的两个端点。

结构就像是上面图中一样~

当然，用电话比喻也是没问题的。就像是 A 和 B 在进行一次通信，但 A 和 B 绝对不是同一个对象！！！

运行问题

如果是 UDP 和 TCP 一起运行同一个端口，实际上并不会受影响，主要是因为协议不同才不会冲突~

然后，客户端注意，需要进行配置修改才能多客户端运行：

这样就能成功运行多个实例了~

IO 流问题

try (InputStream inputStream = socket.getInputStream();
    OutputStream outputStream = socket.getOutputStream()) {
        Scanner scannerNet = new Scanner(inputStream);
        PrintWriter writer = new PrintWriter(outputStream);
    ...
}

此处不是“又拿了一次 IO 流”，而是在原始字节流外面套了一层更方便使用的高级工具。

首先我们知道，InputStream是字节输入流，也就是从网络接收到的数据本质上就是：01001000...类似这种~也就是一个个字节。

如果是直接使用InputStream，通常还需要自己写：

byte[] buffer = new byte[1024];
int n = inputStream.read(buffer);
String str = new String(buffer, 0, n);

所以才在这里套一层Scanner，它会将字节流处理为字符串，因此也就不需要自己处理 byte[]。

OutputStream也是一样的道理。如果直接用它的话，就还需要：

String request = "hello";
outputStream.write(request.getBytes());

但是我们现在发送的是文本，所以套一个PrintWriter之后就可以很自然的用 println 写入缓冲区，最后再 flush 即可。

总结上面就是，Socket 提供底层网络 IO 通道，InputStream/OutputStream 负责字节传输，而 Scanner/PrintWriter 是为了更方便地以文本形式使用这些字节流。

flush()必须出现

代码中的部分：

writer.println(request);
writer.flush();

需要特别理解一下，PrintWriter为了提高 IO 效率，会涉及缓冲。

当执行writer.println(request)这部分操作的时候，可以先理解为“把准备发送的数据交给PrintWriter”。而flush则是表示：“把还没有真正向下输出的数据立即刷到 OutputStream”

所以此处的两行代码基本就是属于固定搭配~

println()和 hasNext 的玄机

注意客户端和服务端里的两部分代码：

// 客户端
writer.println(request);
writer.flush();

// 服务端
if (!scanner.hasNext()) {
    ......
}
String request = scanner.next();

这之间形成了一套基于空白字符分隔消息的简单应用层协议~

首先要知道不能直接把 println(request) 改成 print(request)。如果只是改成 print(request) 再 flush()，很可能服务器会一直阻塞在 hasNext()，因为它不知道这一条请求到底什么时候结束。

因为当我们使用println的时候，println会在后面追加换行符，类似相当于追加一个\n；更准确地说，println() 添加的是当前平台的行结束符。

Linux:
hello\n

Windows:
hello\r\n

而服务端的玄机又在：

服务端的Scanner是Scanner scanner = new Scanner(inputStream)。而Scanner默认采用的分隔符是空白字符（空格、\t、\n、\r 等）

我让 GPT 给出了服务器大概解析的样子~

也就是说 scanner 的 hasNext 和 next 方法都是以分隔符作为判断隔断标准，以解析一段token/数据项

3.IO 多路复用（了解一下~）

如果客户端进一步增加，此时多线程/线程池，就会产生大量的线程~

IO 多路复用，就是让操作系统统一等待多个连接的 IO 事件，告诉程序哪些连接已经就绪，线程再去处理这些链接。

在我们前面写的 TCP 回显服务器一开始是没有使用线程池来完成的，于是就导致了第二个第三个线程...一直在等待第一个线程完成直至断开连接，这样也才到第二个线程（当然也还是要竞争~）

于是乎就想出了使用线程池来让多个客户端一同完成服务~但是！这样就变成了每一个连接安排一个线程，各自等待自己的客户端。但如果连接很多，且大部分时间都没有消息，就会有很多线程在等待~

那么 IO 多路复用就是为了让一个线程照看多个连接，谁有数据，就先处理谁。

拿一个餐厅比例：

原来的方式就像是：

每桌安排一个服务员，顾客还没决定吃什么，服务员一直站在这桌等

多路复用的方式就像是：

多个餐桌共用一个服务员，餐厅的呼叫系统告诉他哪桌需要服务，他再过去处理

如果 B 桌和 C 桌都按了铃，这个服务员可以先处理 B，再处理 C。

网络通信基础：IP、端口、协议分层与数据封装

Sun, 04 Oct 2026 00:00:00 GMT

计算机连接起来以后，数据到底应该送到哪里，又应该怎样理解收到的数据？

围绕这里，就需要我们先了解四个概念：

IP 地址
端口号
协议
五元组

它们之间有联系，我们把它们放到同一个场景里理解。

1. 网络通信基础

我们平常会说，我的电脑正在和服务器通信，但再往里面看，真正需要交换数据的是：两边正在运行的程序，也就是进程。

就比如：

场景	发起通信的程序	接收通信的程序
浏览网页	浏览器	网站服务器程序
使用 JDBC 查询数据库	Java 程序	MySQL 服务程序
聊天	聊天客户端	聊天服务器程序

之前学习 JDBC 的时候就写过相关代码：

DriverManager.getConnection(
    "jdbc:mysql://127.0.0.1:3306/java113",
    user,
    password
);

此处正是设计网络通信了，Java 程序通过 JDBC 驱动，与 MySQL 服务程序建立连接、交换数据。所以会说，网络通信更具体的说，是进程之间基于网络传输数据。

至于接收数据的程序在哪台设备上以及找到设备以后把数据交给哪个程序这就需要 IP 和端口号了。

1.1 IP 地址

IP 地址可以理解为，用于定位主机的网络地址

就像是寄快递填写的，某个城市、某条街道、某栋楼

同样，发送网络数据时，也需要有目标地址，类似192.168.1.20

更严谨地说，IP 地址配置在网络接口上，一台设备可以有多个 IP 地址，并不是每台电脑永远只有一个地址。

此处我们讨论的是 IPv4：

IPv4 地址占 32 位，也就是 4 个字节，是一个 32 位的二进制数，通常分成四个 8 位部分。

使用的是点分十进制表示法

部分	占用位数	十进制范围
第一部分	8 位	0～255
第二部分	8 位	0～255
第三部分	8 位	0～255
第四部分	8 位	0～255

而常用的 127.0.0.1，则是一个回环地址，通常用于访问本地的网络服务~

而 localhost，则是主机名，但常被解析为127.0.0.1，当然也有可能解析为 IPv6 的 ::1

项目	`localhost`	`127.0.0.1`
类型	主机名	IPv4 地址
含义	本地主机	IPv4 回环地址
是否需要解析	需要	不需要
可能解析为	`127.0.0.1` 或 `::1`	永远是 IPv4
网络协议	可能 IPv4 / IPv6	IPv4

对于当前很多 AI 小白利用 AI 做项目的时候，就常有将访问本地资源的localhost分享给他人而搞出段子~

你可以这样记住区别：

localhost 是主机名，127.0.0.1 是 IPv4 回环地址。localhost 通常会解析到 127.0.0.1，但也可能解析到 IPv6 的 ::1，所以两者不能认为绝对完全相同。

1.2 端口号

端口号就是负责，数据发送到目标主机时，将数据送到哪一个进程的。

用快递类比就是：

IP 地址类似收货地址。
端口号类似这个地址下的收件入口。

通常，一台设备可以有：

服务	假设监听的端口
MySQL 服务	`3306`
Java 服务 A	`8080`
Java 服务 B	`9090`

那么192.168.1.20:3306和192.168.1.20:8080，虽然目标设备相同，但目标服务入口不同。

而端口号的范围也就是 TCP、UDP 等传输协议使用 16 位端口号，所以数值范围是 0~65535。因为 216=65536

而端口号和进程编号 PID 不是一回事~

PID 只是用于操作系统用来标识进程的，而一个进程可以拥有多个端口号~

实际接收数据时，操作系统会根据地址、传输协议、端口等信息，找到对应的套接字，再交给应用程序处理。后面学习 Java Socket 时，会具体使用它。

1.3 协议

协议的作用就相当于双方提前约定“数据怎样组织、怎样解释，以及通信过程中怎样行动”

就比如会这样约定：

约定	目的
文字使用 UTF-8 编码	接收方知道怎样解码
消息中携带长度信息	接收方知道正文有多少字节
某种消息表示请求，另一种表示响应	接收方知道该怎样处理

这里是在举自定义协议规则的例子，具体协议会有自己的设计。

所以，协议不仅规定数据格式，也会规定通信行为。

TCP、UDP、HTTP、MySQL 协议等，都在不同层次解决通信中的问题。

你写 JDBC 时，不需要自己把 SQL 拼成 MySQL 协议的数据包，是因为：

JDBC 驱动已经帮你实现了与 MySQL 服务通信的协议处理。

1.4 五元组

对于常见的 TCP、UDP 通信，这五项是：

字段	含义
源 IP 地址	数据从哪个网络地址发出
源端口号	发送方使用的端口
目的 IP 地址	数据发往哪个网络地址
目的端口号	接收方使用的端口
传输层协议	使用 TCP、UDP 等哪种协议

此处的“源”和“目的”，是相对于当前的数据传输方向来说的~

我这里继续拿 Java 访问 MySQL 举例：

假设

Java 程序所在设备的 IP 是 192.168.1.10

MySQL 所在设备的 IP 是 192.168.1.20

Java 这次连接使用本地端口 50000

MySQL 服务监听 3306

使用 TCP 通信

Java 向 MySQL 发送数据时：

五元组字段	值
源 IP	`192.168.1.10`
源端口	`50000`
目的 IP	`192.168.1.20`
目的端口	`3306`
协议	`TCP`

MySQL 回复时，源和目的会交换：

五元组字段	值
源 IP	`192.168.1.20`
源端口	`3306`
目的 IP	`192.168.1.10`
目的端口	`50000`
协议	`TCP`

所以显然，客户端并不永远是“源”，服务器也不永远是“目的”。谁正在发送，谁就是这个方向上的源。

假设很多客户端都在连接同一个 MySQL 服务。

它们的目的地址和目的端口可能都是192.168.1.20:3306

服务器还需要区分：

这份数据来自哪一条连接？回复应该发给谁？

这就需要结合客户端的地址和端口。

因此，同一个服务端口可以接待很多连接，不是“一条连接就独占整个服务端口”。

在 Windows 中，可以通过：

netstat -ano

三个选项分别表示：

选项	作用
`-a`	显示活动连接及监听端口等信息
`-n`	使用数字显示地址和端口
`-o`	显示相关连接的进程编号 PID

如果需要过滤（一般是通过端口号或进程 PID 过滤），可以使用 netstat -ano | findstr 过滤字符串

2. 协议分层

当前的问题是，刚刚上面的所有工作该如何分工。

解决方法是，把网络通信的工作划分为不同层次，各层负责自己的任务，并通过约定好的接口协作。

2.1 同层之间遵守协议，相邻层之间使用服务

先来看上图中的例子：

把打电话分成两层：

语言层负责双方用什么语言交流，怎样理解对方说的话

通信设备层负责怎样通过设备传递声音

这里其实有两套规则：

语言层规则

双方需要理解汉语，才能明白：

“你明天几点到？”

通信设备层规则

电话系统需要按照相应规则，把声音传递给对方。

它负责让对方听到声音。

其实也就是，第一层封装，第二层解耦

上层协议不需要了解下层协议的细节~打电话的人会说话就行，不需要理解电话机原理
分层后，灵活的替换其中的某一层，对于整体的工作过程影响很小

关于下方的两个改变，主要改变的是：上层怎样组织和理解表达内容

底下的电话系统仍然可传递声音。

所以分层的价值就是，在接口和服务约定保持兼容的情况下，一层的变化可以尽量减少对其他层的影响。

当然，实际网络通信比这个例子要复杂，一层的变化可以尽量减少对其他层的影响。

其实分层是比较类似“面向接口编程”

就类似调用方使用接口，提供方通过接口提供服务。

网络分层也有类似的思想：

上层使用下层提供的服务
下层通过接口提供能力，隐藏自己的实现细节

同层之间遵守协议，相邻层之间使用服务

此处要分清两个方向：

同一设备内部，上层通过接口，使用下层的服务

通信双方之间，双方对应层需要遵守相应的协议

2.2 OSI 七层模型

OSI（Open System Interconnection）开放系统互联

但 OSI 七层网络模型复杂也不实用，所以 OSI 七层模型都没有落地实现

实际组建网络时，只是以 OSI 七层模型设计中的部分分层，也就是以下 TCP/IP 五层（或四层）模型来实现

2.3 TCP/IP 五层（或四层）模型

五层或四层只是视角不同罢了~

TCP/IP 是一组协议的代名词，其中包含 TCP、UDP、IP 以及许多应用层协议

首先是应用层。它关注的是应用程序之间，应该交换什么消息，又该如何理解这些信息。就比如 HTTP(网页等资源的请求与响应)、SMTP(电子邮件传输)、FTP(文件传输)等。在编写 Java 网络程序，主要就是在这一层组织业务消息，并通过 Socket 等接口使用下层的传输服务。当然，这一层你也可以理解为买家在拿到包裹后如何使用~
传输层关注的是通信两端的应用怎样交换数据（如 TCP 传输控制协议）。之前了解到的端口号就在此处发挥作用。字面意思就是，两个任意设备之间的通信，不考虑中间过程，只考虑起点和终点。就像是卖家在寄件时，只负责填发货地址和到货地址即可。
网络层，处理地址与跨网络转发，也就是负责地址管理和路由选择。两台主机之间可能隔着很多网络和路由器（就像是《无敌破坏王》中那样到网络中心一样），这一层就关心数据下一步该往哪里转发，对应的就是前面的 IP 地址。路由器会根据目的 IP 地址和路由表等信息，选择下一跳。并不要求发送方提前固定好整条完整路径。
数据链路层，则是负责设备之间的数据帧的传送和识别。这一层通常会处理数据帧的组织、链路上的寻址（如以太网中的 MAC 地址）、介质访问、差错检测等。主要就是关注当前链路上怎样把数据送到下一站。
物理层，真正传递信号。数据帧最终还需要通过实际介质传出去。而物理层就负责光/电信号的传递方式。这一层设计信号编号、传输介质、接口等问题。所以应用层所表达的业务消息，最终需要借助这些物理能力完成传递。

就相当于，我在淘宝上买了床刷子

我则关心床刷子买到之后，我要如何使用 ->应用层

卖家只要关心收件人信息 ->传输层

物流公司则关心包裹以怎样路径传输的 ->网络层

快递小哥/货车司机考虑的是相邻节点 ->数据链路层

国家在铺桥修路 ->物理层

写代码主要就是工作在应用层了~

而像主机、路由器、交换机就分别对应下方：

主机 -> 工作过程涉及到从物理层->应用层（通过应用程序满足网络通信的需求）

路由器-> 工作过程涉及到从物理层->网络层（组建局域网，进行网络）

交换机-> 工作过程涉及到从物理层->数据链路层（对路由器的接口的扩展，不需要考虑组网的问题）

此处说的是传统意义上的交换机和路由器，也称为二层交换机（工作在 TCP/IP 五层模型的下两层）、三层路由器（工作在 TCP/IP 五层模型的下三层）

上面的工作区间也是一个经典的面试题

2.4 一则信息的全过程

2.4.1 数据发送

假设我通过 QQ，发送 Hello 给好友：

应用程序会先获取到用户输入，构造一个应用层的数据包。这个应用层数据包就会遵循应用层的协议（这部分往往是开发者自己定义的）。假设此处的协议格式是：

发送者的 qq 号，接收者的 qq，消息的时间，消息正文。（类似下图这种）

就以此为例：1234567,7654321,2026-10-04，12:00:00，Hello（当然实际是会加密的）

注：上述所说的数据包往往是“结构化数据”。发送数据的时候，把结构化数据 -> 字符串/二进制 bit 流（序列化）；接收数据的时候，字符串/bit 流 -> 结构化数据（反序列化）

应用程序调用传输层提供的接口（API 也就是 socket api），把数据交给传输层。传输层拿到数据之后，构造出“传输层数据包”。传输层的协议主要就是两个：TCP、UDP。得到数据包形式：TCP 数据包 = TCP 报头（header） + TCP 载荷（payload）。TCP 载荷就是应用层数据包。

传输层构造好数据之后，继续调用网络层的 api，把传输层的数据包交给网络层。网络层继续进行处理。网络层最主要的协议就是 IP 协议。IP 协议会继续对上述数据包进行加工 -> 拼上 IP 报头~。得到的 IP 数据包形式就是： IP 数据包 = IP 报头 + IP 载荷（整个传输层的数据包）。其中 IP 报头包含的信息也有很多的，就比如源 IP 或目的 IP。

注：IP 报头还会记录传输层使用的是哪个协议。同样的，传输层报头中也会记录应用层使用的是哪个协议（准确的说是数据交给哪个应用程序）......

IP 协议继续调用数据链路层的 api ，把 IP 数据包交给数据链路层。数据链路层中的核心协议就是“以太网”这个协议。以太网也会在网络层数据包的基础上进一步加工~

到目前为止，数据还在当前主机上转悠，还没出门~

以太网继续把这样的数据交给硬件设备（网卡）。网卡会按上述二进制数据最终以光信号/电信号/电磁波信号传播出去~此时数据才算出门了~

封装顺序就是 应用数据 -> TCP 报文段 -> IP 数据包 -> 以太网帧 -> 信号

从上到下，数据都要进一步加工

解释一下：网络数据包/帧/报/段

段（segment） TCP 用段

报（Datagram） UDP用报

包（packet） IP 用包

帧（frame）数据链路层以太网数据帧

但其实日常工作中，确实也不会明确区分这些概念~

2.4.2 数据接收

刚才是数据发送所进行的全过程，接下来是数据接收回来一步一步解封装

数据到达接收方的网卡。网卡就会把光信号还原成二进制，随后把二进制数据交给上层数据链路层。

补充一下：不同的网络连接方式，数据链路层使用的协议和帧格式也可能不同

网线/光线来的数据，数据链路层 -> 以太网

WiFi 来的数据，数据链路层 -> IEEE 802.11 协议

数据链路层按照以太网协议进行解析。把报头和报尾取出来，剩下的载荷往上传递给网络层。以太网的帧头中就有专门的属性，描述了网络层使用哪个协议

网络层拿到这个数据之后，按照 IP 协议的格式解析：再把载荷数据交给传输层。IP 报头中也有专门的属性，描述了传输层使用哪个协议

传输层拿到数据之后，也是类似，按照 TCP 协议来解析。取出载荷，交给应用层。传输层的报头中，通过目的端口号，告知我们数据交给哪个应用程序

QQ 应用程序解析应用层数据，拿到关键信息，展示到界面上，给出提示~不同的应用程序，自然使用不同的应用层协议来解析~

传输的中间过程中，也是涉及到封装分用的。

交换机只需要封装分用到数据链路层即可

交换机是工作在数据链路层（二层转发）

主机的数据 -> 交换机。交换机收到之后，物理层解析，然后数据链路层解析（没有网络层）~ 重新构造出新的以太网数据帧发送给下一个设备。

数据链路层中，得到以太网数据帧的帧头，信息就足以支持交换机进行下一步工作

路由器是工作在网络层（三层转发）

主机的数据 -> 路由器。物理层，数据链路层，网络层解析（没有传输层），重新构造出新的网络数据包。构造出以太网数据帧，构造出二进制数据，再进行转发

Java 并发进阶（三）：线程安全容器与并发集合

Wed, 30 Sep 2026 00:00:00 GMT

1.线程安全的集合类

1.1 多线程下使用 `ArrayList`

前面我们对 count++这样的共享变量使用 synchronized 来保护，如果面对的是这样：

List<String> names = new ArrayList<>();

显然如果是在多线程，就不能直接调用 add()了。毕竟本身ArrayList也不负责同步。在多个线程同时访问下，并且至少有一个线程修改集合结构时，还需要另外的同步措施。否则就会出现结果不正确，遍历的时候也可能遇到并发修改问题。

下面是介绍三种在多线程下使用 ArrayList 方法

自己使用同步机制（synchronized 或者 ReentrantLock）

所有访问都遵守同一规则

List<String> names = new ArrayList<>();
Object lock = new Object();

synchronized (lock) {
    names.add("张三");
}

synchronized (lock) {
    for (String name : names) {
        System.out.println(name);
    }
}

之所以读的时候也要用同一把锁，是因为如果一个线程正在遍历，另一个线程却同时修改，遍历过程就可能受到干扰。

所以此处的关键就是“同一个集合、同一把锁”。如果添加时锁lockA，遍历时锁 lockB，两个线程仍然可能同时操作集合；这两把锁不会替彼此协调。

自己加锁能用，但项目里每个访问位置都要守规矩，漏掉一处，前面的保护就可能失效~

`Collections.synchronizedList()`包装

给原集合套一层同步包装

List<String> names =
        Collections.synchronizedList(new ArrayList<>());

names.add("张三");
names.add("李四");

可以理解为，原来的ArrayList外面加了一层“门卫”。调用包装后的name.add()等方法时，由包装对象去负责同步。

创建时就包装的原因，是因为后续代码应该统一返回的names访问集合。如果有人绕过包装对象，直接去操作原始ArrayList，这层同步就管不到他了。

注意：遍历仍需要自己在包装对象上加锁

synchronized (names) {
    for (String name : names) {
        System.out.println(name);
    }
}

但问题是，都说是线程安全的包装了，为什么遍历还要加锁？在学到这里的时候我也很困惑

主要是因为，遍历不是一次调用，耳熟“取得迭代器、检查有没有下一个，读取下一个......”的一连串动作。包装类能同步单次方法调用，却不能自动保证整个遍历期间没有其他线程插入修改。所以在官方文档中明确要求了并发遍历时，在返回的集合对象上手动同步~

这部分我就不再详细解释了，可以复制这部分问 AI 给出详细答案~

`CopyOnWriteArrayList`写入时复制

这个方法叫写时复制

List<String> names = new CopyOnWriteArrayList<>();

names.add("张三");
names.add("李四");

举个例子：

假设大家都在阅读一份名单，此时有人要修改名单：

synchronized的思路更像，修改和阅读要协调使用同一份名单。
CopyOnWriteArrayList的思路则是，写入时制作一份新的底层数组，在新数组上完成修改，再让后续读取使用新版本；已经开始的遍历继续看它原来的版本。

这样的目的是为了让读者遍历时不必因写入而打断当前遍历。代价则是每次写入都要复制底层数组，集合大、写入频繁时成本会高，官方文档也把它定位在遍历远多于修改的场景。

// 用代码观察“旧遍历看到的旧版本”：
CopyOnWriteArrayList<String> names = new CopyOnWriteArrayList<>();
names.add("张三");

Iterator<String> iterator = names.iterator();
names.add("李四");
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}
System.out.println(names);

这段代码里，iterator是添加“李四”之前创建的，所以它遍历的是当时的快照，只打印“张三”；最后直接打印当前names，则能看到“张三”和“李四”。

注意“新写的数据不能第一时间读取到”，是已经创建的旧的迭代器不会看到后续修改；并不是说以后重新读取集合，也一直看不到新数据。

再补充一个例子：

假设当前底层数组是，[1, 2, 3, 4]

此时一个线程正在读取这个数组，而另一个线程准备修改数据，例如把 1 修改成 100。

CopyOnWriteArrayList 并不会直接在原来的数组上修改，而是先复制出一份新的数组，再在新数组上完成修改

也就是，复制和修改新数组的这段时间里，旧数组并不会发生变化。因此此时其他正在读取的线程仍然可以继续读取旧版本的数据，并不会因为写线程正在复制、修改而被阻塞。

等新的数组复制、修改完成之后，CopyOnWriteArrayList才会把自己内部保存的数组引用切换到新数组。

实际实现中，CopyOnWriteArrayList保存底层数组的引用具有相应的内存可见性保证，因此新数组准备完成以后再发布出去。这样读线程看到的要么是完整的旧版本，要么是完整的新版本，而不是一个“修改了一半”的中间状态。

不过，这里要区分一下两种“读取”：

普通读取在新数组发布以后，后续就可以读取到新数据
但是已经创建好的迭代器比较特殊，他会一直持有创建那一刻的数组快照~

很明显，上面的方案也有缺点：

数组特别大时，非常低效
如果多个线程同时修改，也容易出问题

只能适用于特定场景，比如服务器进行重新加载配置的时候......

我导出了一份对比：

方式	核心做法	注意
自己加锁	所有相关访问使用同一把锁	不能漏掉访问位置
`synchronizedList`	包装常用集合方法	并发遍历仍需手动同步
`CopyOnWriteArrayList`	修改时复制底层数组	适合读多写少；旧迭代器只看旧快照

综上，集合的“线程安全”，看add()会不会冲突，还要看遍历、复合操作，以及读写同时发生时应当看到哪个版本。

1.2 多线程下使用队列

（该小节利用 AI 进行整理）

现在把共享资源换成队列

举个例子：

假设一家奶茶店，前台负责接单，后厨负责制作。前台接到订单以后，会先把订单放到等待区，后厨再从等待区取出订单进行处理。

这里的等待区，就可以理解为一个队列：

生产者：负责往队列里放入任务，比如前台提交订单。
消费者：负责从队列里取出任务，比如后厨取走订单。

但问题是，如果没有订单，后厨怎么办？如果等待区已经满了，前台还能继续放吗？

这就需要用到阻塞队列，Java 中对应的接口是：

BlockingQueue<E>

不仅负责线程安全地存取元素，还提供了条件不满足时等待的操作：

queue.put(task);    // 放入元素，没有空位时等待
Task task = queue.take(); // 取出元素，没有元素时等待

注意，阻塞的是调用方法的那个线程。比如消费者在等订单，生产者仍然可以提交订单；有了订单以后，消费者才有机会继续执行。

不过，阻塞队列也不是所有方法都会等待，这里可以先做一个区分：

操作	方法	暂时无法完成时
放入元素	`put(e)`	等待空位
取出元素	`take()`	等待元素
放入元素	`offer(e)`	没有空位就返回 `false`
取出元素	`poll()`	没有元素就返回 `null`

所以具体是等待还是直接返回，要看调用的方法，而不能只看它是不是“阻塞队列”~

下面介绍三种队列。

`ArrayBlockingQueue`

这个名字可以拆开理解：

Array：底层使用数组。

BlockingQueue：支持阻塞操作的队列。

BlockingQueue<String> orders =
        new ArrayBlockingQueue<>(2);

这里的 2 表示，队列里最多存放两个元素。

它属于有界队列，创建时必须指定容量，而且创建以后容量就固定了，不会像 ArrayList 一样自动扩容。元素按照先进先出的顺序取出。

举个例子：

假设奶茶店的等待区只能放两张订单：

orders.put("订单1");
orders.put("订单2");

boolean success = orders.offer("订单3");
System.out.println(success); // false

前两次 put() 可以成功，因为队列还有空位。

但第三张订单放不进去，所以这里的 offer() 返回 false。之所以使用 offer()，是为了观察“队列满了”的结果，同时让当前线程还能继续往下执行。

如果改成：

orders.put("订单3");

当前线程就会等待，直到其他线程取走一个元素，腾出空位。

再补充一个例子：

接着前面的队列，先取走一张订单，再放入第三张：

String firstOrder = orders.take();
System.out.println(firstOrder); // 订单1

orders.put("订单3");

System.out.println(orders.take()); // 订单2
System.out.println(orders.take()); // 订单3

之所以先取出“订单1”，是因为它最早进入队列。取出以后，队列空出一个位置，“订单3”才能放进去。

不过，这里要区分一下：

队列容量限制的是队列中等待的元素数量，不是线程数量，也不是所有未完成任务的数量。

比如后厨取走“订单1”以后，虽然还没制作完成，但这张订单已经离开队列了，因此队列可以接收新的订单。

另外，上面的 put()、take() 需要处理或者声明 InterruptedException。练习时可以把代码放在声明了该异常的 main() 中：

public static void main(String[] args)
        throws InterruptedException {
    // 示例代码
}

因为等待期间可能被中断，所以这两个方法要求我们考虑这种情况。

`LinkedBlockingQueue`

和前面的数组队列相比，LinkedBlockingQueue 底层使用的是链表节点，同样按照先进先出的顺序取出元素。

它也可以指定容量：

BlockingQueue<String> orders =
        new LinkedBlockingQueue<>(100);

这里表示，队列最多存放一百张订单。达到容量以后，再调用 put()，生产者就需要等待。

不过，它还可以这样创建：

BlockingQueue<String> orders =
        new LinkedBlockingQueue<>();

没有传入容量，那是不是就能无限存放元素了？

显然不是。不指定容量时，默认容量是 Integer.MAX_VALUE，也就是 2147483647。

所以不能简单理解为“链表可以不断增加节点，队列就永远不会满”。

举个例子：

假设前台每秒接一百张订单，但后厨每秒只能完成十张。如果一直按照这个速度运行，等待区中的订单就会越积越多。

没有设置合适的容量上限时，程序可能持续接收任务，直到积压的数据占用大量内存。

因此，创建时指定容量的意义，不只是决定能放多少元素，也是为了让生产者在积压达到上限时先等待，给消费者处理任务的时间。

它的基本使用方式和前面一样：

BlockingQueue<String> orders =
        new LinkedBlockingQueue<>(2);

orders.put("订单1");
orders.put("订单2");

System.out.println(orders.take()); // 订单1
System.out.println(orders.take()); // 订单2

可以发现，换成链表实现以后，生产者和消费者仍然通过 put()、take() 配合，不需要重新写一套等待与通知逻辑~

`PriorityBlockingQueue`

按优先级取出的阻塞队列

前面两种队列都是先进先出，但有些场景并不适合只按进入顺序处理。

举个例子：

医院接诊时，普通患者虽然来得早，但后来送来的急救患者，可能需要优先处理。

这时就需要：

PriorityBlockingQueue

它会根据元素的自然顺序或者我们提供的比较器，决定下一次取出哪个元素。

先用整数观察：

BlockingQueue<Integer> queue =
        new PriorityBlockingQueue<>();

queue.put(30);
queue.put(10);
queue.put(20);

System.out.println(queue.take()); // 10
System.out.println(queue.take()); // 20
System.out.println(queue.take()); // 30

明明 30 先放进去，为什么却先取出 10？

因为对于 Integer，默认的自然顺序是从小到大。因此这里先取出最小的元素，而不是最早进入队列的元素。

所以，“优先级高”并不一定表示数字大，具体含义要由排序规则决定。

如果希望数字越大越先取出，可以提供一个比较器：

BlockingQueue<Integer> queue =
        new PriorityBlockingQueue<>(
                10,
                new Comparator<Integer>() {
                    @Override
                    public int compare(Integer a, Integer b) {
                        return Integer.compare(b, a);
                    }
                }
        );

这里把比较顺序反过来，因此放入 30、10、20 后，取出顺序就是 30、20、10。

不过，构造方法中的 10 要特别注意：

它表示初始容量，不是最多只能存放十个元素。

PriorityBlockingQueue 是逻辑上的无界队列，可以扩容。放入元素时，不会因为达到某个固定容量上限而等待，但仍然受到实际内存的限制；队列为空时，调用 take() 则会等待。

再补充一个容易混淆的地方：

假设消费者已经取走一个普通任务，正在执行。此时又放入了一个紧急任务，队列并不会把正在执行的任务强行中断。

优先级影响的是下一次从队列中取出哪个任务，并不代表可以抢占已经开始执行的任务。

另外，观察优先顺序时，应该看连续调用 take() 或 poll() 的结果。直接使用 for-each 遍历，不保证按照优先级顺序输出；相同优先级的元素，也不保证按照进入顺序取出。

我整理了一份对比：

队列	底层结构	容量特点	取出顺序
`ArrayBlockingQueue`	数组	必须指定容量，创建后固定	先进先出
`LinkedBlockingQueue`	链表	可以指定容量，默认是 `Integer.MAX_VALUE`	先进先出
`PriorityBlockingQueue`	堆	逻辑上无界，构造参数是初始容量	按自然顺序或比较器决定

1.3 多线程下使用哈希表

首先需要知道 HashMap 本身不是线程安全的

而在多线程环境下使用哈希表可以使用：

Hashtable
ConcurrentHashMap

我们已经讨论过多线程下使用数组、队列，那么现在就轮到哈希表了。

首先，我给一个使用环境，比如我们想统计每篇博客的访问次数：

map.put("Java多线程", 100);
map.put("MySQL事务", 200);

如果是只有一个线程操作，问题不大。但如果是在服务器里，多个用户同时访问，就有可能多个线程同时操作这张哈希表。

这部分我打算主要介绍这两个类：Hashtable和ConcurrentHashMap

HashMap 不负责线程同步

先来回忆一下哈希表，往 HashMap 里放一个键值对，不只是简单地给变量赋值，就像这样map.put("张三", 90)

内部还需要有这几步：

根据 key 的哈希值，确定放在哪个桶
查看桶里有没有已有的元素
判断是新增键值对，还是替换已有值
必要时调整结构、更新数量，甚至扩容

如果是两个线程同时修改这些内部数据，而且还没有同步措施，就可能相互干扰~

所以必须先强调：HashMap 本身不是线程安全的。

多个线程共享它，并且存在并发修改时，需要额外的同步措施，Java 文档也明确了这一点。

最直接的办法是，像前面提到的ArrayList一样

Map<String, Integer> scores = new HashMap<>();
Object locker = new Object();

synchronized (locker) {
    scores.put("张三", 90);
}

synchronized (locker) {
    Integer score = scores.get("张三");
}

注意，需要协调的访问，都遵循同一把锁的规则。由于每次操作都需要自己写同步代码，所以 Java 就提供了接下来要说到的现成的同步实现。

`Hashtable`把关键方法加锁

使用的方式还是比较熟悉的

Map<String, Integer> scores = new Hashtable<>();
scores.put("张三", 90);
scores.put("李四", 85);
System.out.println(scores.get("张三"));

其基本思路可以理解为，给get()、put()、remove()等关键方法加上synchronized.

这些实例方法加锁，锁的是当前 Hashtable 对象。

所以多线程调用同一个对象的这些方法，竞争的是同一把锁。Hashtable 是一个提供同步的 Map 实现。

当你点入标准库中的 Hashtable 你会发现，它的大部分方法就是在前面加上了synchronized，没错就是硬上锁。所以它的结构就如同下面这样：

一个Hashtable只有一把锁，两个线程访问Hashtable中的任意数据都会出现锁竞争。

另外，一旦触发扩容，该线程就会完成整个扩容过程，这个过程涉及到大量的元素拷贝，效率会非常低。

所以就引出了ConcurrentHashMap

`ConcurrentHashMap`缩小需要互斥的范围

使用方法还是类似：

ConcurrentHashMap<String, Integer> scores =
        new ConcurrentHashMap<>();

scores.put("张三", 90);
scores.put("李四", 85);
System.out.println(scores.get("张三"));

它在设计时就考虑了多线程并发访问。

由于上面的Hashtable采用的是整体置锁，因此ConcurrentHashMap采用另外的方式进行置锁以保证减少锁竞争问题，达到效率的提高。

我们知道，在哈希表中，底层那个数组中，每一个位置都可以视为桶，也就是说一个哈希表有许多桶组成（如果忘记这点可以看看 JavaSE 篇中的内容）

ConcurrentHashMap要解决的就是，在我们操作哈希表时，减少其中的锁竞争。

我们知道，针对不一样的 key 可能会落入不同的哈希桶中，当然也有可能落入同一个桶中。

假设现在：

A 修改桶 0 中的数据。
B 修改桶 1 中的数据。

既然它们修改的主要结构互不相同，就可以尽量允许它们并发执行。

C 修改桶 2 中的王五。
D 修改桶 2 中的赵六。

虽然 key 不同，但它们操作的是同一个桶，就可能需要互斥。

于是乎，在 Java5~Java7 阶段ConcurrentHashMap使用了分段锁的思想，缩小了锁保护的范围，降低了不同操作争抢同一把锁的概率。

它主要协调的是不同的桶之间的关系，你不能记成 key 不同，就一定不会产生锁竞争；更准确的是，落在不同的桶里的修改，通常更有机会并发执行。

再说明一下分段锁：

也就是说在 Java5~Java7 阶段，一开始是多个桶放一把锁。用官方的描述是“多个桶被划分到一个 Segment 中，一个 Segment 对应一把锁。”

这还是比较好理解的，就比如锁 1 被分配在桶 1,2,3,4,5,6 ，然后锁 2 被分配在桶 7,8,9,10,11......以此类推

OpenJDK 7 的源码注释直接写明，哈希表被划分为多个 Segment，每个 Segment 自己又是一个哈希表。（具体参考论述可以追踪到OpenJDK7）

但上述问题是，锁粒度还是有些大，就比如桶 1 与桶 2 之间还会有可能存在锁竞争。

于是在 Java8ConcurrentHashMap 做了一次非常大的重构，直接取消了 Segment 作为主要并发结构。而变成Node<K,V>[] table，结构更像普通的HashMap。也就是将锁粒度缩小到桶级别，并将桶的头节点作为synchronized的锁对象。

在 Java8 中是能不用锁尽量不用锁。

源码中还专门提及过“向空桶插入第一个节点时直接通过 CAS 完成。”

对了，读操作get()没有加锁，配合volatile保证了可见性。

另外再强调一个地方，就是关于扩容部分的优化：

对于 ConcurrentHashMap，可以这样理解，把迁移工作拆成若干段，允许多个线程领取不同的部分，协作完成迁移。

扩容过程中，新旧数组会暂时同时存在。

但并不是每次查询都把两张表完整查一遍。

关键在于，某个旧桶迁移完成以后，会留下一个转发节点，告诉后续操作去新表找。

关于迁移要注意这几个点

并不是每个访问线程都会参与搬迁。 例如，get() 可以根据转发节点去新表查找，不负责帮助迁移。
并不是每个线程只搬固定几个元素就结束。 迁移按桶区间分配，参与线程可能完成多批工作。
扩容期间，插入也不是一律只操作新表。 尚未迁移的桶仍可能在旧表处理；遇到已迁移的桶，才转向新表。

全部迁移完成以后，当前表切换为新表。旧数组在不再被引用后，由垃圾回收处理。

（重点）ConcurrentHashMap对HashMap的核心优化点：

把锁整个表 -> 锁桶，以及读操作不加锁
充分利用 CAS 特性，针对 size 属性通过 CAS 更新，避免出现重量级锁
优化扩容方式以及化整为零（把锁整个表 → 锁桶就是锁粒度的化整为零）

Java 并发进阶（二）：CAS、原子类与 JUC 工具

Tue, 29 Sep 2026 00:00:00 GMT

1.CAS

CAS 前面其实在说synchronized就已经就接触到这个词了。

但那会只是简单的解释了一下：

线程可以通过 CAS 去尝试修改锁状态，如果成功就说明拿到锁；失败就说明有人竞争，再继续自旋；

这里我再具体说明一下：CAS 全称 Compare and swap，字面意思“比较并交换”。

CAS 操作可以拆成三个值，有如下：

V：内存中的原始值

A：线程认为它是旧值，也叫预期值

B：线程想写入的新值

而 CAS 要做的事情就是，只有 V 任然等于 A，才把 V 改成 B；否则不修改，并告诉线程这次失败了。

这段写的代码不是原子的，真实的 CAS 是一个原子的硬件指令完成的，这个伪代码只是辅助理解 CAS 的工作流程

boolean CAS(address, expectValue, swapValue) {
    if (&address == expectValue) {
        &address = swapValue;
        return true;
    }
    return false;
}

比如共享变量最初是 10。线程想执行 CAS(原始值 10, 预期值 10, 新值 11)：

如果执行 CAS 时变量仍是 10，修改成功，变量变成 11。
如果另一个线程已经把预期值改成 11，预期值对不上，修改失败，变量保持原值。

还可以这么理解，你正在修改在线文档，你开始编辑时看到的是第 10 版，提交时系统先确认他是否仍为第 10 版；如果别人已经提交了第 11 版，就不能直接用你的旧内容覆盖它。

实际代码中的 if 不具备原子性，上面的已经说过只是伪代码辅助理解 CAS，实际的 if 会可能存在之前说的内存可见性问题，这里我就不再展开解释了~

CAS 其实和前面的乐观策略是有一定联系：

CAS 会先按照刚才读到的值长尝试修改，如果期间没人改它，那么就会成功；如果有人先改了，它再重新取，重新计算。

也就是失败的 CAS 不会接着完成，而是会在失败后再重试；

1.1 CAS 实现原子类

前面的典型操作，count++线程不安全，就需要加锁来解决问题。但是又认为，加锁效率比较低，于是就可以通过 CAS 来实现 count++，这样能确保性能，又同时保证线程安全~

标准库中提供了java.util.concurrent.atomic包，里面的类都是基于这种方式来实现的。典型的就是AtomicInteger类，其中的getAndIncrement相当于 i++操作；

实际只想给计数器加 1 时，直接使用原子类即可：

AtomicInteger count = new AtomicInteger(0);
// 相当于 i++
int oldValue = count.getAndIncrement();

伪代码实现：

// 原理伪代码，不是可直接运行的 AtomicInteger 源码
class AtomicInteger {
    private int value;

    public int getAndIncrement() {
        int oldValue = value;

        while (CAS(value, oldValue, oldValue + 1) != true) {
            oldValue = value;
        }

        return oldValue;
    }
}

假设 value 一开始是 0，我们按顺序看：

oldValue = value：先记下当前值 0。因为稍后要根据它计算新值，还要把这个旧值返回给调用者。
CAS(value, oldValue, oldValue + 1)：尝试确认共享值是否仍为 oldValue。如果仍是 0，就原子地改成 1，本次操作成功。
如果 CAS 失败，就执行 oldValue = value，重新读取共享值。因为其他线程可能已经把它改了，原来的 oldValue + 1 也就不再是这次应该写入的结果。
循环直到 CAS 成功，最后 return oldValue。返回的是这次成功加一之前的值，不是加一后的值。
比如 A、B 都读到 0，A 先通过 CAS 把值改成 1。B 再拿“预期是 0”去尝试，就会失败。B 重新读到 1，下一轮尝试把 1 改成 2。如果成功，B 返回 1；最终共享值是 2。

注意：代码里的 CAS(value, …) 是为了说明原理。普通 Java 方法接收一个 int 参数，不能仅靠这个参数原子地修改外部字段；这段也不能当作 JDK AtomicInteger 的实际源码来运行。写程序时直接使用标准库的 AtomicInteger.getAndIncrement() 即可。

1.2 用 CAS 实现自旋锁

前面学习过的自旋锁是指，线程暂时拿不到锁，就先不进入等待状态，而是在原地反复尝试。

但问题是：两个线程都看见“锁没人持有”，又怎能保证只有一个线程拿到

假设用 owner 记录锁的持有者：

owner == null：目前没人持有
owner == 当前线程：当前线程拿到了锁

线程 A 和 B 同时来时，都想把owner从null改成自己。这里不然能用普通的“先判断，再赋值”，因为两人可能都判断为null。于是用 CAS：

owner.compareAndSet(null, 当前线程)

意思是，只有owner此刻仍然是null，才原子地把它改成当前线程。

假设 A 先成功，owner 就变成 A；B 再尝试时，发现它已经不是 null，因此失败。B 可以继续循环，等待 A 释放后再试。这就是 CAS 实现自旋锁的核心。Java 的 AtomicReference.compareAndSet() 正好提供对对象引用的这种操作。

下面是一段伪代码：

public class SpinLock {
    private Thread owner = null;

    public void lock(){
        // 通过 CAS 看当前锁是否被某个线程持有。
        // 如果这个锁已经被别的线程持有，那么就自旋等待。
        // 如果这个锁没有被别的线程持有，那么就把 owner 设置为当前尝试加锁的线程。
        while(!CAS(this.owner, null, Thread.currentThread())){

        }
    }

    public void unlock (){
        this.owner = null;
    }
}

加锁操作中，就需要判定，锁是否被人占用；如果未被人占用，就把当前线程的引用设置到 owner 中；如果已经被人占用，就自旋等待。

由于循环体是空着的，整个循环速度非常快（忙等），但是一旦其他线程释放了锁，此时此刻线程就能第一时间拿到这里的锁。

1.3 CAS 的 ABA 问题

刚刚一直在判断，“当前值和我先前读到的值，是否相等”

但是“相等”并不能证明“中间从未被别人修改过”

这就像是你去买手机买电脑可能买到“翻新机、二手机”一样，经过翻新之后，机器外观看起来就和新机完全一样，实际上里面早就是不一样了~

CAS 中的 ABA 问题其实大部分情况下，即使出现了 ABA，最终的程序其实一般问题也不大。只有一些极端场景，ABA 问题才会产生一些严重 BUG

就比如取银行取钱：

假设账户里原本有 100 元，线程 1 和线程 2 都读取到了这个值，并且都准备把余额从 100 修改成 50。正常情况下，线程 1 先执行成功，把余额改成 50；等线程 2 再执行时，发现当前值已经不是自己之前读取的 100 了，所以 CAS 失败，这是我们期望的结果。

但是如果在线程 2 执行之前，又有其他操作把账户余额从 50 重新改回了 100，那么线程 2 再进行 CAS 时，会发现：

之前读取的值：100

当前的值：100

从数值上看没有发生变化，于是 CAS 会认为这个数据没有被修改过，并继续执行扣款。

但实际上余额已经经历了：

100 → 50 → 100

ABA 问题解决

ABA 问题产生的原因，是 CAS 只会比较“当前值”和“之前读取到的值”是否相同，却无法判断这个值在中间有没有被修改过。

所以要解决 ABA 问题的常见思路，就是在原来的数据之外，再额外增加一个版本号。每次读取数据时，不仅要读取当前值，还要记录他对应的版本号；真正执行 CAS 时，也要同时比较数据和版本号。

比如账户余额一开始是 100 元，版本号是 1。线程 1 和线程 2 都读取到了“余额 100，版本号 1”。

随后线程 1 先执行扣款，把余额从 100 修改成 50，同时版本号从 1 增加到 2。之后又有人向这个账户转入 50 元，余额重新变回 100，但版本号会继续增加到 3。

这时候线程 2 再执行 CAS。虽然它之前读取到的余额是 100，而现在的余额也正好是 100，看起来数据没有发生变化，但线程 2 保存的版本号还是 1，而当前版本号已经变成了 3

因此版本号比较失败，这次 CAS 也就不会成功。

这样的话，即使数据经历了“100 → 50 → 100”，最终又回到了原来的值，我们仍然可以通过版本号发现，这个数据中间其实已经被修改过了。

所以，解决 ABA 问题的核心可以简单理解为：

普通 CAS 只比较值，而解决 ABA 问题后，需要同时比较“值 + 版本号”。

Java 中提供了AtomicStampedReference<E>来实现这种思路，其中保存的数据可以理解为实际值，而stamp就相当于这个值对应的版本号。每次成功修改数据时，同时更新版本号，这样就可以判断数据在这期间是否发生过变化~

对应出现的相关面试题可能就会这样出：

讲解一下你自己理解的 CAS 机制

全称 Compare and Swap，即“比较并交换”。相当于通过一个原子的操作，同时完成“读取内存，比较是否相等，修改内存”这三个步骤，本质上需要 CPU 指令的支撑

ABA 问题如何解决

给要修改的数据引入版本号。在 CAS 比较数据当前值和旧值的同时，也要比较版本号是否符合预期。如果发现当前版本号和之前读到的版本号一致，就真正执行修改操作，并让版本号自增；如果发现当前版本号比之前读到的版本号大，就认为操作失败

2.JUC 的常见类

JUC 是指java.util.concurrent及其相关包。其实前面用过的AtomiciInteger就属于 JUC；我就从里面两个主要的类讲一讲~

2.1 Callable 接口

在前面创建线程的时候，经常是将 Runnable 实例出一个 task 交给线程去执行。

Runnable task = new Runnable() {
    @Override
    public void run() {
        // 执行任务
    }
};

Thread t = new Thread(task);
t.start();

如果任务只是打印一句话，Runnable就很合适。但问题是，如果子线程负责计算 1 到 1000 的和，主线程只能通过创建成员变量最后赋值才能拿到。

public class Demo {
    public static int total = 0;
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            int sum = 0;
            for (int i = 0; i <= 1000; i++) {
                sum += i;
            }
            total = sum;
        };
        Thread t = new Thread(task);
        t.start();
        t.join();
        System.out.println("total = " + total);
    }
}

但如果子线程有很多的话，还得自己管理结果存放、等待条件和线程通知，代码会很繁琐。

所以 JUC 就提供了 Callable<V> 这样一个更贴合这类任务的接口；

Callable 是一个 interface。Callable<V>描述“执行完后会产生一个 V类型结果”的任务，相当于把线程封装了一个“返回值”。方便给程序猿借助多线程的方式计算结果。

用Callable去完成上面一个计数代码是实现如下：

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result = 0;
                for (int i = 0; i <= 1000; i++) {
                    result += i;
                }
                return result;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        System.out.println(futureTask.get());
    }
}

Callable 接口和 Runnable 接口是并列关系；Callable<V> 是要重写一个 V call()方法，而Runnable是要重写一个void run()方法。

使用Callable要注意，上面的代码有三个重要角色，

Callable<Integer>描述要做的计算，以及返回什么结果、

FutureTask<Integer>包装任务，记录它是否完成，并保存结果、

Thread真正安排新线程执行任务。

Thread 本身不提供获取结果的方法，所以就需要凭 FutureTask 对象来拿到结果。至于为什么 Thread 不能直接接收 Callable 对象，则是因为需要解耦合。

Thread 就是线程，要和任务这个概念能剥离开。线程不需要关心任务是啥样的任务（是否有返回值）。

再补充一下上述关于futureTask.get()部分：

拿买麻辣烫举例。

Callable：交给后厨的制作任务。

工作线程：做餐的厨师。

FutureTask：你拿到的取餐票。

get()：拿着票取餐。

你拿到取餐票时，麻辣烫可能还没做好。因此调用 get() 时：

任务已经完成：直接取到结果。

任务还没完成：当前调用 get() 的线程等待，直到有结果。

这里等待的是调用 get() 的主线程；负责计算的子线程仍在工作。get() 也只是等待并取结果，不会替你启动任务。所以如果忘了 thread.start()，却直接调用 get()，主线程就可能一直等下去。

还有一种情况：子线程在 call() 中计算失败、抛出异常。主线程调用 get() 时不会得到正常结果，而会收到 ExecutionException；如果主线程在等待期间被中断，则会收到 InterruptedException。

同时，上面也补充了一个之前没学习到的线程创建方法，通过传入Callable对象。这里再总结一下：

继承 Thread（定义单独的类/匿名内部类）
实现 Runnable（定义单独的类/匿名内部类）
lambda
实现 Callable（定义单独的类/匿名内部类）
线程池，ThreadFactory

2.2 ReentrantLock

ReentrantLock 即可重入互斥锁，是更经典风格的锁，与 synchronized 是并列关系。都是用来实现互斥效果，保证线程安全。

ReentrantLock 提供了三个方法：

lock()：加锁，如果获取不到锁就死等。
unlock()：解锁。
unlock(超时时间)：加锁，如果获取不到锁，等待一定的时间之后就放弃加锁。

它的基本加锁和解锁使用方式就像这样

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

lock.lock()：尝试取得锁。如果被其他线程持有，就等待取得它。只有 lock() 成功返回，才应进入负责释放这把锁的代码。
try：执行需要保护的 count++。
finally：无论代码正常结束还是抛出异常，都调用 unlock()。

trylock()这个方法的话，就是抢不到就先不等。

他不会阻塞，加锁成功返回 true，加锁失败返回 false。调用者判定返回值，决定接下来需要做什么~

它还可以设置超时时间，等待时间达到超时时间再返回 true/false

import java.util.concurrent.TimeUnit;

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        count++;
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("等了最多一秒，仍没拿到锁");
}

你可以想下面这样理解：

使用一间会议室

lock()：会议室有人，就等到空出来。
tryLock()：看一眼，有人就马上离开。
限时 tryLock()：等一会儿，过了约定时间就改变安排。

但现在 synchronized 优化做的越来越好，优先还是使用 synchronized

这里的重点是 synchronized 和 ReentrantLock 之间区别：

synchronized 是关键字（内部是 JVM 通过 C++实现的），ReentrantLock 则是标准库的类（完全由 Java 编写的）
synchronized 通过代码块控制加锁解锁，ReentrantLock 需要 lock/unlock 方法，需要注意 unlock 不被调用的问题
ReentrantLock 除了提供 lock，unlock 之外还提供了一个方法 tryLock()
ReentrantLock 提供了公平锁的实现（默认是非公平的）
ReentrantLock 搭配的等待通知机制，是 Condition 类，相比 wait notify 来说功能更强大一些

2.3 信号量 Semaphore

前面了解到synchronized和ReentrantLock通常是在描述：同一时刻只允许一个线程进入。

而信号量就是为了同一时刻，管理多份资源的工具。

信号量，用来表示“可用资源的个数”，本质上就是一个计数器，你可以这样理解；

Semaphore parking = new Semaphore(4);

这里的 4 表示的是一开始有 4 个表示可用许可，也可以理解为停车位：

发生的事	可用许可
停车场刚开放	4
第一辆车进入	3
第二辆车进入	2
又有两辆车进入	0
第五辆车尝试进入	等待
一辆车驶出	释放 1 个许可，等待的车有机会进入

我称其为“许可”，是因为Semaphore只管理可用数量，并不真的创建停车位对象。Java 文档也是按“取得一个许可，归还一个许可”来描述它的。

可以参考一下Oracle官方文档

2.3.1 `acquire()`申请资源

Semaphore提供的其中一个方法，acquire()就是会先申请许可，再使用资源。在车进入停车场前，会先调用

parking.acquire();

其含义就是，我要申请一个许可，拿到了，才能往下执行。

如果还有许可，可用数量减一，线程继续执行。如果许可已经用完，线程就等待，直到有其他线程归还许可；等待期间也可能因中断而抛出 InterruptedException。

所以说也可以称其为 P 操作。

信号量的一个特殊情况：初始值为 1 的信号量，取值要么是 1 要么是 0（二元信号量）。这就等价于“锁”

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        // 指定可用资源的个数是 "4"
        Semaphore semaphore = new Semaphore(3);
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
    }
}

2.3.2 `release()`释放资源

在车离开停车场的时候就调用：

parking.release();

可用许可增加一个，正在等待的线程便有机会取得它。这一步也就是所谓的V 操作：归还一个许可，可用数量加一。

注意：Semaphore 不会像 ReentrantLock 那样检查“是不是持有锁的那个线程”，对它来说，调用一次 release()，就只是把当前许可数量加 1。多调用一次 release()，许可数量就可能增加。就比如，原本只打算容纳 4 辆车，但没有申请资源的前提下使用了release()就会变为容纳 5 辆车。

所以代码里必须保证，成功 acquire() 之后才 release()，并且用完一定归还。

示例代码：

public class Demo {
    public static void main(String[] args) {
        Semaphore parking = new Semaphore(4);

        Runnable car = new Runnable() {
            @Override
            public void run() {
                boolean acquired = false;

                try {
                    // 1. 先申请车位
                    parking.acquire();
                    acquired = true;

                    // 2. 拿到车位后，才能进入停车场
                    System.out.println(Thread.currentThread().getName() 
                            + " 进入停车场");

                    Thread.sleep(1000); // 模拟停车 1 秒
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();

                } finally {
                    // 3. 只有确实拿到车位，才归还车位
                    if (acquired) {
                        parking.release();
                        System.out.println(Thread.currentThread().getName() 
                                + " 离开停车场");
                    }
                }
            }
        };
        for (int i = 1; i <= 20; i++) {
            new Thread(car, "车辆" + i).start();
        }
    }
}

2.4 CountDownLatch

在上一节的Semaphore有一个计数器，用来表示，现在还允许多少个线程进入；

CountDownLatch也有计数器，但问题完全不同，它是还有多少件事没完成？等它们全部完成，我才能继续。

就拿跑步举例，还有多少件事没完成？等它们全部完成，我才能继续。

CountDownLatch latch = new CountDownLatch(10);

这里的 10 表示的是还需要收到 10 次完成通知。

每次有一名选手结束比赛就调用latch.countDown()，计数器减 1，然后负责统计的线程调用latch.await()。

如果计数器还不是 0，那么这个线程就的等待；计数器到 0 之后，它才会继续执行。countDown()的调用者不用等其他选手，通知完就可以结束自己的工作。

过程能记为：

事件	剩余计数
比赛开始，等待 10 名选手	10
第一名完成任务	9
又有 8 名完成任务	1
最后一名完成任务	0
等待中的统计线程	可以继续

此处的计数器表示剩余任务数，不是“还有多少个名额可供使用”。这就是它和Semaphore最根本的区别。

虽然说这 10 个线程也可以分别 join()，但CountDownLatch更直接的地表达需求，“我不关心逐个等待哪条线程；我要等待 10 项任务都发出完成通知”

和信号量哪里可以相反的理解，Semaphore 问的是“现在还能进几个”；CountDownLatch 问的是“还差几个没完成”。

public class Demo{
    public static void main(String[] args) throws InterruptedException {
        // 现在把整个任务拆成 10 个部分. 每个部分视为是一个 "子任务".
        // 可以把这 10 个子任务丢到线程池中, 让线程池执行.
        // 当然也可以安排 10 个独立的线程执行.

        CountDownLatch latch = new CountDownLatch(10);
        ExecutorService executor = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 10; i++) {  // 此处创建任务数要与latch个数相同
            int id = i;
            executor.submit(() -> {
                System.out.println("子任务开始执行: " + id);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("子任务结束执行: " + id);
                latch.countDown();
            });
        }
        // 这个方法阻塞等待所有的任务结束
        // 此处的 a => all
        latch.await();
        System.out.println("所有任务执行完毕");
        executor.shutdown();
}

对于这一部分可能会出的面试题：

线程同步的方式有哪些？

synchronized、ReentrantLock、Semaphore、原子类等都可以用于线程同步。

为什么有了synchronized还需要 JUC 下的 Lock？

以 JUC 的 ReentrantLock 为例：

synchronized 使用时不需要手动释放锁；ReentrantLock 使用时需要手动释放锁，使用起来更加灵活。

synchronized 在申请锁失败时，会一直等待；ReentrantLock 可以通过 tryLock() 的方式尝试获取锁，也可以等待一段时间后放弃。

synchronized 不提供公平锁机制；ReentrantLock 默认是非公平锁，也可以通过构造方法传入 true 开启公平锁模式。

synchronized 可以通过 Object 的 wait() / notify() 实现等待与唤醒；ReentrantLock 可以搭配 Condition 实现等待与唤醒，并且能够更加精确地控制不同等待队列中的线程。

AtomicInteger 的实现原理是什么？

基于 CAS 机制，伪代码如下：

class AtomicInteger {
    private int value;

    public int getAndIncrement() {
        int oldValue = value;

        while (!CAS(value, oldValue, oldValue + 1)) {
            oldValue = value;
        }

        return oldValue;
    }
}

信号量是什么？一般应用在哪些场景？

信号量，用来表示“可用资源的个数”。本质上就是一个计数器

使用信号量可以实现“共享锁”。比如某个资源允许 3 个线程同时使用，那么就可以使用 P 操作作为加锁，V 操作作为解锁，前三个线程的 P 操作都能顺利返回，后续线程再进行 P 操作就会阻塞等待，直到前面的线程执行了 V 操作。

解释一下 ThreadPoolExecutor 构造方法的参数的含义

参考另一篇“多线程：应用案例”

Java 并发进阶（一）：锁策略与 synchronized 原理

Mon, 28 Sep 2026 00:00:00 GMT

这一部分的内容主要针对面试，所以内容相对有些干巴~

1.常见锁策略

1.1 乐观锁和悲观锁

不知道你第一次见是不是误以为：一个锁比较开心，另一个锁比较消极；

不过其实描述的主要是：对于“接下来会不会发生线程冲突”

悲观锁：

每次访问共享数据都先假设别人可能会修改，因此线上锁；其他线程如果也需要访问，就只能等待锁释放。

悲观锁的想法比较保守，加锁的时候，预测接下来的锁竞争的情况会非常激烈，就需要针对这样的激烈情况额外做一些工作。

还是继续拿公司举例子，假设财务办公室有一份账本。张三觉得“这个账本这么重要，李四王五说不定随时都会来改，我还是先把门锁上。”

乐观锁：

先假设并发冲突发生的概率不高，在真正提交更新时再检查是否发生冲突。

乐观锁的想法就相反，加锁的时候，预测接下来的锁竞争的情况不激烈，就不需要做额外的工作。

乐观锁和悲观锁的对比就像下面一样说的一样

比如：现在张三和李四想找老师问问题。

张三比较悲观：“老师平时这么忙，我直接过去估计也是白跑。”所以张三就先发消息“老师，你下午两点有空吗？”

老师确认“有空”后，张三才过去~

像上面这样就是悲观锁

李四就比较乐观“老师应该没这么忙吧，我直接过去”。于是李四直接跑办公室，如果老师正好有空，那最好直接把问题解决~

这样就根本没有提前预约产生额外流程。

如果老师正忙，“哦，那算了，我下次再来。”

虽然这次失败了，但他能够识别到“现在发生冲突了”然后重新尝试~

这就是乐观锁的类比

两种策略没有绝对优劣，关键看当前场景。

比如冲突非常频繁，你还一直乐观“失败再试失败又试”，就像知老师每天都忙得要死，你还天天直接跑办公室碰碰运气。最后反而白跑很多次，一直浪费资源~这就比较适合悲观锁了~

反过来，假如有 1000 次操作，可能只有 1 次冲突。如果每一次都申请锁->等待->解锁，这就有点像：老师一年都闲的要死，你每次都为“1+1”等于几之前，还提前三天预约~这种冲突概率很低的场景，就更适合乐观锁策略。

那么乐观锁到底怎么知道“别人改没改”？

这个问题就先埋下来~

而悲观锁其实很好理解：真的把锁拿到手

那乐观锁既然不提前把别人挡住，那它凭什么知道别人有没有改过数据？

一个典型的方案就是版本号~

就比如：当前数据是余额 = 100，version = 1

线程 A 读到：100 / version 1

准备修改为：50

真正提交的时候再看 version 是否等于 1

如果还是version = 1就说明我读取之后没人改过；如果发现version != 1就说明我不在的时候有人动过这份数据~那么本次修改就失败

这其实就是为我后面要说的CAS 埋个伏笔

既然提到锁，就不得不提一下synchronized，synchronized 开始时会倾向使用更乐观、开销较低的策略；如果发现锁竞争逐渐频繁，则会逐步转向更悲观、开销更高的处理方式。

1.2 重量级锁和轻量级锁

从前面我们学习到了，锁的核心目的是保证原子性 / 互斥；

可以先暂时不用深入研究 JVM 和操作系统底层是如何实现锁的，就记住Java 的锁当然不是凭空出现的，它最终还是要依赖 CPU 提供的原子指令以及操作系统提供的线程调度能力。

那么重量级锁和轻量级锁是什么意思？

重量级锁

这里提到的重量级，不是说把锁本身“更大”，而是发生锁竞争时，为了实现线程之间的互斥，需要付出的系统开销比较大。

就比如，当一个线程获取不到锁时，可能需要让该线程进入阻塞状态。等到锁被释放以后，又需要将这个线程唤醒，让它重新参与 CPU 调度。

这其中可能涉及到：

用户态与内核态之间的切换
线程阻塞与唤醒
线程上下文切换
操作系统线程调度

这些操作相对于普通的用户态代码来说成本比较高，所以被称为重量级锁。

轻量级锁

轻量级锁的思路则是：如果锁竞争并不严重，就尽量不要马上让线程进入阻塞状态，而是在用户态先尝试解决竞争。

就比如：JVM 可以利用 CPU 提供的 CAS 原子指令，或者让线程进行短暂的自旋，尝试获取锁。

整个过程中线程可能并没有真正进入阻塞状态，因此也就避免了比较昂贵的线程阻塞、唤醒和上下文切换。这也就是所说的“轻量级”。

上面提及的用户态 / 内核态指的就是：

用户态：程序自己在用户空间里完成，不需要操作系统直接介入线程的阻塞和唤醒。

内核态：当锁竞争严重、线程需要被阻塞或唤醒时，需要操作系统内核参与线程调度，可能产生用户态与内核态切换以及线程上下文切换。

你可以这么理解用户态和内核态：

假设你去银行，在大厅外面，自己能完成的事情（填表、看号码、整理材料）这些事情自己就能做，这就可以类比为用户态。

但是有些事情你没有权限自己完成，必须交给拥有更高权限的工作人员，所以只能去柜台，让银行工作人员处理，这就可以类似内核态。

对于上面所说的“重量级锁”和“轻量级锁”，主要区别并不是谁更安全，而是谁的实现成本更高。所以还是那句话：没有哪一种策略永远最好，关键看当前的竞争情况。

1.3 自旋锁和挂起等待锁

我们知道，线程在竞争锁时可能会遇到一种情况：线程 A 已经持有锁，线程 B 尝试获取锁但失败了。对于线程 B 通常会有两种不同的处理思路：

继续占用 CPU，不断尝试获取锁 -> 自旋等待
暂时放弃 CPU，进入阻塞等待状态 -> 挂起等待

这也就是我这一节要说的自旋锁和挂起等待锁~

自旋锁：

刚刚说到的第一种思路就是自旋锁（继续占用 CPU，不断尝试获取锁）

按照传统的处理方式，如果线程获取锁失败，可以直接进入阻塞状态，将 CPU 让给其他线程。这样做虽然不会一直浪费 CPU，但是线程阻塞、唤醒以及上下文切换本身也是有成本的。

于是就产生了一个问题：

假设线程 A 虽然正在持有锁，但是它马上就要释放了，如果这时候线程 B 马上进入阻塞，那么阻塞和唤醒线程的成本，可能反而比等待锁释放的时间还长~

所以换一种思路就是先不要马上阻塞线程，让线程继续运行一小段时间，不断尝试获取锁，这就是自旋的含义。

自旋你可以抽象理解为：

while (获取锁失败) {
    // 继续尝试获取锁
}

注意哈，这只是帮助理解的伪代码。

我让 AI 解释了下，实际 JVM 或并发组件中的实现会更加复杂，并不会简单地让线程无条件无限循环。

再补充一下，自旋锁其实是属于一种偏轻量级的等待策略。自旋线程仍然处于运行状态，因此仍然会占用 CPU~

挂起等待锁：

挂起等待锁其实就是另一种思路了：既然暂时获取不到，那我就先不抢了，把 CPU 让出来。

从过程上来看其实就是“我拿不到锁，我先休息，把 CPU 让出来，等锁释放后再唤醒我”

此处所说的“挂起”并不是说 Java 线程永远停止，而是线程暂时进入等待 / 阻塞状态，不再持续占用 CPU 执行。

这里说到的自旋锁和挂起等待锁你可以这样理解一下：

想象一下，去追求一个女神。当男生像女神表白后，女神说：你是个好人，但是我有男朋友了~~

挂起等待锁：陷入沉沦不能自拔......过了很久很久之后，突然女神发消息过来，“要不咱俩试试？”（注意，这个很长时间间隔里，女神可能已经换了好几个男票了）

自旋锁：死皮赖脸坚韧不拔，仍然每天坚持地和女神说早安晚安。一旦女神和上一任分手，那么就能立刻抓住机会上位。

我让 GPT 总结了上面的内容给出了对比表格：

对比	自旋等待	挂起等待
获取锁失败后	不断尝试获取锁	线程进入等待 / 阻塞
是否继续占用 CPU	是	通常不持续占用 CPU
是否需要线程阻塞	通常不需要	需要
是否涉及调度	较少	通常需要
等待时间很短	更合适	阻塞成本可能不划算
等待时间很长	会浪费 CPU	更合适

所以上述两种方式没有绝对的好坏，而是适用的场景不同~

其实还是回到了锁竞争的激烈程度：

悲观锁 -> 重量级锁 -> 挂起等待锁

乐观锁 -> 轻量级锁 -> 自旋锁

1.4 公平锁和非公平锁

这一部分其实更好理解些，主要说的是：

如果很多线程都在等同一把锁，那么这把锁到底要不要讲“先来后到”？

假设现在有三个线程，分别是 A，B，C

A 先尝试获取锁，获取成功。然后 B 再尝试获取锁，获取失败，阻塞等待。然后 C 也尝试获取锁，C 也获取失败，也阻塞等待。

那么，当线程 A 释放锁的时候，会有两种情况：

公平锁：遵循“先来后到”，B 比 C 先来，所以当 A 释放锁的时候，B 会先于 C 获取到锁。

非公平锁：不遵循“先来后到”，B 和 C 都有可能获取到锁。

其实你可以认为，非公平锁也能定义为公平，因为锁默认情况下，就相当于“概率均等”，操作系统针对线程的调度是随机的~

操作系统线程调度本身可以看成带有随机性；如果没有额外机制限制，锁通常不会天然保证公平。如果要实现公平，就需要额外的数据结构记录线程到来的先后顺序。

下面这个例子希望更能加深对公平锁和非公平锁的印象~

再补充一句，synchronized 其实是非公平锁，在之前学习 synchronized 的时候就说到，当一个线程释放锁以后，其他等待的线程会重新竞争，并不一定严格按照先来后到。

1.5 可重入锁和不可重入锁

在之前的初阶已经稍微接触过，只是当时是为了说明synchronized不会让线程“自己把自己锁死”。

可重入的意思就是：

同一个线程已经拿到第一把锁以后，还可以再次获取同一把锁。

或者逼入一个递归函数里有加锁操作，递归过程中这个锁会阻塞自己吗？如果不会，那么这个锁就是可重入锁（因为这个原因可重入锁也被称为递归锁）。

就比如下面这样：

public class Demo {
    public synchronized void method1() {
        System.out.println("method1");
        method2();
    }
    public synchronized void method2() {
        System.out.println("method2");
    }
}

Demo demo = new Demo();
demo.method1();

比如我 new 了一个 Demo，调用了 method1，method1 内部又调用了method2，它们同样都是 synchronized；

如果是可重入锁，method2 允许再次进入。

但如果是不可重入锁，method2 就会被拒之门外，然后method1 又无法释放锁。此时就会发生死锁情况。

这样的锁就称为不可重入锁。

synchronized 是可重入锁

1.6 普通互斥锁和读写锁

在多线程环境下，对共享数据的访问通常可以分为两类：读取数据和修改数据

如果只是两个线程同时读取数据，两个线程都不会修改数据，因此一般不会破坏数据的一致性。

但如果一个线程读取数据，一个线程修改数据，这样就可能产生问题；同样，如果是两个线程都在修改数据也必须得保持互斥。

你可以这样认为：

普通互斥锁

普通互斥锁的问题主要是，即使多个线程之间只是读取操作，它们仍然不能同时执行。

就像是之前学习 synchronized 一样：

public synchronized int getData() {
    return data;
}

public synchronized void setData(int data) {
    this.data = data;
}

这样虽然能保证线程安全，但是假设三个线程都执行getData()只是读取数据。但又由于synchronized是互斥的。也就是说即使多个线程之间只是读取操作，他们仍然不能同时执行。

线程安全是保证了，但是并发能力下降了。

所以这时候就产生了一个新的思路：既然读操作不会修改数据，那就允许多个线程同时读取；

读写锁

这就是读写锁由来。

读写锁并不是只有“一把锁”，而是把锁拆为了读锁（Read Lock）和写锁（Write Lock）分别对待读取操作和修改操作。

Java 标准库提供了 ReentrantReadWriteLock，它的内部提供了两种锁，分别是读锁类 ReentrantReadWriteLock.ReadLock 和写锁类 ReentrantReadWriteLock.WriteLock。

以上两个类都提供了 lock / unlock 方法分别进行加锁和释放锁。

读锁最大的特点就是：读锁之间可以共享，所以读锁也被称为共享锁

而写锁的话就必须保证互斥，所以读锁也能理解为独占锁，因为同一时间只能有一个线程持有写锁。

这样就实现了上面那种图片的效果了：

读锁 + 读锁：不互斥

写锁 + 写锁：互斥

读锁 + 写锁：互斥

也就是说，只要有线程持有写锁，其他线程既不能获取读锁，也不能获取写锁

反过来，只要还有线程持有读锁，写线程就不能获取写锁

使用实例如下：

ReentrantReadWriteLock readWriteLock =
        new ReentrantReadWriteLock();
ReentrantReadWriteLock readWriteLock =
        new ReentrantReadWriteLock();

Lock readLock = readWriteLock.readLock();
Lock writeLock = readWriteLock.writeLock();
// 读操作加锁
public int getData() {
    readLock.lock();

    try {
        return data;
    } finally {
        readLock.unlock();
    }
}
// 写操作加锁
public int getData() {
    readLock.lock();

    try {
        return data;
    } finally {
        readLock.unlock();
    }
}

再补充一句，synchronized不是读写锁~

对于以上锁的内容，一般面试考察的就是概念性的

然后对于读写锁来说还有一个要注意的地方：

在ReentrantReadWriteLock中，持有写锁的线程，可以继续获取读锁。

例如：

这种操作叫做：锁降级

也就是从写锁变成了读锁，权限从独占变成了共享读取~

2.`synchronized` 原理

synchronized 前面已经学过了，但结合上面说到的锁策略问题，你可以将 synchronized 先理解成：

开始倾向乐策略竞争频繁后转向更悲观的处理
开始使用轻量级实现竞争严重后可能转成重量级锁
轻量级阶段可能使用自旋
非公平锁
可重入锁
不是读写锁

JVM 将synchronized锁分为无锁、偏向锁、轻量级锁、重量级锁状态。

2.1 加锁过程

synchronized不是一上来就用最重的方案，你可以这么理解：

竞争不严重的时候，能简单处理就简单处理。

当竞争越来越严重，简单办法搞不定，再逐渐换成更重的办法。

先不急着背这几个词，可以把线程放进一个具体场景。

class Counter {
    private final Object lock = new Object();
    private int count = 0;

    public void add() {
        synchronized (lock) {
            count++;
        }
    }
}

假设线程 A、B 都调用同一个 Counter 对象的 add()。它们竞争的就是该对象中的同一个lock。

无锁：目前还没有人使用这把锁

lock刚创建出来的时候还没有线程进入这段同步代码~

这时候线程 A 来执行 add，他想做的事情就只是：

“我要进入synchronized(lock)，修改count”

JVM 需要保证 A 修改期间，如果 B 也来了，B 不能同时修改~

但现在只有 A，一个竞争者都没有。但如果每次都按“许多线程争锁”的方式处理，成本就白花了。

偏向锁：一直都是 A 在使用

我还是拿之前的例子来吧：

假设我是个妹子，我要谈男朋友，我又希望把男朋友换的快一些，那么就有下面两个步骤：

和当前男朋友分手

我需要 zuo 一 zuo，打一打拳，逐渐消耗他的耐心~~

我再谈分手，一定得是哭的梨花带雨，让它认为都是他的名字~

和下一个小哥哥培养感情

当我最开始谈这个男朋友的时候，我和他做各种情侣之间做的事情，但是从不和他确认关系（搞暧昧）这就让他能够更好的满足我对于男朋友的需求~

然后当有一天我对他厌烦了，这个时候就不必麻烦了，直接和他说，咱们不要再见面了~

但这样搞暧昧的手段也有一定副作用，万一有别的妹子也在接近我的小哥哥，我的小哥哥也可以瞬间把我给踹了，然后用同样的话“咱们只是普通朋友”应对我

所以我只要发现了有妹子试图接近我家哥哥，只要一有这样的苗头，我就立即和我家哥哥确认关系，并且朋友圈官宣~让其他妹子就可以 gun 远了~

ok，像上述这样的过程，就是偏向锁的过程~

进行synchronized刚一上来，不是真加锁，而是只是简单做一个标记（搞暧昧）

这个标记，非常轻量，相比于加锁解释来说，效率高很多~

如果没有其他线程来竞争这个锁，最终当前线程执行到解锁代码，也就只是简单清除上述标记即可（不涉及真加锁、真解锁），就像是搞暧昧，不真确立关系，后续分手就很快

如果有其他线程来竞争，就抢先一步，在另一个线程拿到锁之前，抢先拿到锁。也就是真加锁了，偏向锁 ->轻量级锁。其他线程只能阻塞等待~

本质上也是懒汉模式思想的体现

偏向锁之所以省事，前提是基本没有别的线程来争；前提变了，策略也得变。

轻量级锁：有竞争，但也许很快就结束

假设 A 正在执行：

synchronized (lock) {
    count++;
}

此时 B 恰好也来了。B 发现自己暂时拿不到 lock。

如果同步代码只有一个 count++，A 很可能马上就执行完了。此时此刻让 B 挂起，等操作系统以后再唤醒它，可能比“稍等一下”还费事。

尝试取得锁：用 CAS 检查并尝试更新与锁有关的状态。（先把 CAS 理解成一个“确认状态仍符合预期，才尝试修改”的动作）
短暂自旋：如果这次没取得锁，B 可以短暂重试，看看 A 是否已经释放。

这就和上面提到的自旋锁策略接上了，“我先不去休息，在小试一小会，也许你马上就用完了”

但如果 A 持续时间很长，B 一直原地重试。这时候 B 就会持续消耗 CPU，所以自旋不会毫无节制地一直进行。短暂等待仍拿不到锁，就需要考虑成本更合适的处理方式。

重量级锁：持续竞争，就让线程等待

假设 A 进入同步代码后久久不退出，B 试了多次还是拿不到锁；或者有更多线程都来争这把锁。

此时要是再试一下就不划算了~所以就需要才需更重的处理方式，也就是重量级锁：有 JVM 的监视器机制管理竞争，拿不到锁的线程可能进入等待，等锁释放后再被唤醒、重新争取。

对于上述的内容我是这样认为

无锁 --> 偏向锁：代码进入synchronized的代码块

偏向锁 --> 轻量级锁：拿到偏向锁的线程运行过程中，遇到了其他线程尝试竞争这个锁

轻量级锁 --> 重量级锁：JVM 发现，当前竞争锁的情况非常激烈

当前 JVM 中，只提供了“锁升级”不能“锁降级”。注意此处我说的锁降级与前面提到的 ReentrantReadWriteLock 的锁降级不是同一种。

ReentrantReadWriteLock 的“锁降级”，是并发锁 API 的读写权限转换；synchronized 所谓“锁升级”，是 JVM/HotSpot 对 Monitor 的底层实现形态变化。

2.2 其他的优化操作

锁消除

锁消除就是编译器和 JVM 判断某些锁实际上不会发生线程竞争，于是把没有必要的加锁、解锁操作直接去掉~

就比如，都知道 StringBuffer 很多方法本身就带同步。

StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");

但如果，sb 只是一个方法里的局部变量，而且整个过程只有当前线程能访问。那么就根本没有线程在跟你抢，那这时候还“加锁、append、解锁”就纯粹是白忙活~

所以 JVM 如果能分析出这个对象不会被其他线程访问，那么就可以把这些没有意义的同步操作消掉~

再注意一下，JVM 只有在能够判断这个锁不会发生真实竞争时，才能进行这种优化

锁粗化

再看另一种情况：

for (int i = 0; i < 1000; i++) {
    synchronized (lock) {
        count++;
    }
}

假设 JVM 按代码表面上的范围处理，每轮循环都要 取得锁 -> count++ -> 释放锁

如果是循环一千次，那么就重复一千次

但问题是如果这些操作紧挨着进行，反复去取得、释放同一把锁，本身也会有成本。

所以锁粗化就是在合适的情况下，JVM 可能把多次相邻的加锁范围合并，减少反复申请和释放锁的次数。

举个例子：假设你要向领导交代三个任务

方式一：打电话交代任务 1，挂断；再打电话交代任务 2，挂断；再打一次交代任务 3.
方式二：打一次电话，把三个任务交代完，再挂断。

你给领导打电话（对领导加锁），这个时候领导需要全心全意应付你，没法做别的事情，所以必然会对整体效率产生影响~

所以方法二就省掉了重复的成本，锁粗化成一把锁省的也是反复“取得、释放”的成本。所以上面的加锁可以优化成这样：

synchronized (lock) {
    for (int i = 0; i < 1000; i++) {
        count++;
    }
}

所以 synchronized 真正厉害的地方，不只是“能加锁”，而是 JVM 在背后替我们做了很多优化。

那么对于如果有类似下面的面试题回答就不算困难了~

什么是偏向锁？

偏向锁不是真的加锁，而只是在锁的对象头中记录一个标记（记录该锁所属的线程）。如果没有其他线程参与竞争锁，那么就不会真正执行加锁操作，从而降低程序开销。一旦真的涉及到其他的线程竞争，再取消偏向锁状态，进入轻量级锁状态。

synchronized 实现原理是什么？

Java 并发实践：单例模式、阻塞队列、线程池与定时器

Sat, 19 Sep 2026 00:00:00 GMT

1. 单例模式

对于《初阶》这篇文章我们已经介绍了synchronized和volatile，初阶知识点很多是在单独解决某个线程安全。为了切实理解如何应用，我引入了单例模式这个典型例子来深度讲解一下：

单例模式首先是设计模式里的其中一个，那么什么是单例模式，什么又是设计模式？

我先回答设计模式：

设计模式：设计模式不是某一个 Java 语法，而是针对某类常见问题总结出来的一套代码设计思路。而单例模式就是其中非常经典的一种。

你可以这么理解，设计模式可以类比象棋中的“棋谱”，针对红方的一些走法，黑方应招的时候有一些固定的套路，那么按照套路来走局势就不会吃亏。

那么软件开发中当然也会有很多常见的“问题场景”，针对这些问题场景，大佬就总结出了一些固定的套路，按照这个套路来实现代码也不会吃亏。

设计模式和框架也不是一个概念，框架属于“硬性要求”，设计模式属于“软性要求”；

单例模式：

希望某一个类，在程序中只存在一份的实例。

单例模式，是强制要求一个类不能创建多个对象，

你可以先记成：一个类 -> 只希望存在一个对象 -> 其他地方需要使用时 -> 都按这一份对象

单例模式具体实现方法有很多，常见的就有“饿汉”和“懒汉”两种。

1.1 饿汉模式

先看最简单的一种：

class Singleton {
    private static Singleton instance = new Singleton();	// 记住这个地方，在类加载阶段触发的
    private Singleton() {
        //...
    }
    public static Singleton getInstance() {
        return instance;
    }
}

好了，我先来解释一下饿汉模式：类加载的时候，就直接把实例创建出来；

你可以理解为太饿了，等不及别人来要，我先把饭做好放在这里。结合上面的代码就是在Singleton类加载的时候直接 new 出一个instance实例，之后谁需要直接通过getInstance获取；

再解释一下上面的代码，有三个点需要看懂：

对于该句private static Singleton instance = new Singleton()，之所以用static，就是让instance这个实例直接属于类本身，而不是属于某个具体对象；
private Singleton()这里的构造方法使用private的原因就是为了禁止外部随便创建 Singleton 对象。
想要获取 instance就只有通过静态方法getInstance。这是统一向外提供的对象。

当然，对于如果需要有多个参数去构建 instance 时，就可以再对多参数的构造方法进行私有化就可以了。

1.2 懒汉模式

我们已经知道了“饿汉”就是：我先给你做好。

懒汉也很好理解：你真要用的时候，我再做。

对了，再补充一下“懒”，“懒”在计算机中其实是褒义词，经常能够节省计算机资源开销，我举个例子：

假如有一个很大的文件（千万字的小说），你用编译器打开一般会有两种情况~

把所有的内容，都从文件加载到内存中，在显示
只把一部分内容加载并显示

第一种情况会明显卡顿，而且就算加载再多你也看不过来；第二种情况就是后续如果用户翻页，随着翻页随时加载后续的数据。

懒汉模式对应的就是第二种情况。而且我用的 Okular PDF 阅读器很明显用的就是懒汉模式，因为当你快速滑动到后面的图片时，很明显会需要加载一下下。

来看一段单线程下的懒汉模式例子：

class SingletonLazy {
    private static SingletonLazy instance = null;
    private SingletonLazy() {

    }
    public static SingletonLazy getInstance() {
        if(instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

这段懒汉模式与饿汉模式最大的区别就是在创建实例的时候。懒汉模式下，创建实例的时机是在第一次使用的时候，而不是在程序启动的时候。

当然，上述这些内容都是引子，接下来才是正题。

上面两份代码（饿汉、懒汉）是否存在线程安全问题，如果不是，该怎么办？（这也是经典的面试题）

首先对于饿汉模式，很明显只存在读操作，没有进行任何数据写入。多个线程最多是进行Singleton.getInstance()去获取instance而已。所以显然不存在线程安全问题。它的特点就是：不管以后到底用不用，类加载的时候对象就已经创建了。

但是对于懒汉模式，if 条件判断的时候，多线程下假设：

一个线程在进入 if 判断但还没进入创建实例的时候，另一个线程也在 if 判断，此时另一个线程也会同样进入线程去创建，这样第一个线程创建的实例就会被另一个线程后创建的实例给覆盖掉。

这样第一个线程的instance就被覆盖了，而且随着第二个现成的覆盖操作，第一个线程 new 出来的对象也就会被 GC（grabage collection 垃圾回收）改释放掉了。像这样的情况就属于是 BUG，所以懒汉模式这样的写法，getInstance 就是线程不安全的。

在生产环境下，new 一个对象所要加载的内存可能是很大了（会有上百 G），所以像这样的操作还是很危险的，可能程序启动就会花费很长时间。

因此引入synchronized，将“希望”、“条件”和“修改”打包成原子的操作。但我还是要提醒的是：不是每个不安全的地方写了synchronized就会变得安全的，具体问题具体分析。

修改后得到的是：

class SingletonLazy {
    private static SingletonLazy instance = null;
    private static Object locker = new Object();
    private SingletonLazy() {

    }
    public static SingletonLazy getInstance() {
        synchronized(locker) {
            if(instance == null) {
                instance = new SingletonLazy();
            }
            return instance;
        }
    }
}

引入加锁之后，后执行的线程就会在加锁的位置阻塞，阻塞到前一个线程解锁。当后一个线程进入条件的时候，前一个线程已经修改完毕。instance不再为null，就不会进行后续的new操作。

但是这样又会产生一个新的问题：

每次调用 getInstance 都要加锁……多线程情况下，这里的加锁就会相互阻塞，进一步影响程序的执行效率。

加锁、解锁存在额外开销，而懒汉模式真正危险的其实只是第一次实例创建阶段，所以后续没必要每一次获取实例都继续竞争锁。

所以继续优化~

通过再一次增加 if 判断条件，进而决定是否要加锁：

class SingletonLazy {
    private static SingletonLazy instance = null;
    private static Object locker = new Object();
    private SingletonLazy() {

    }
    public static SingletonLazy getInstance() {
        if(instance == null) {
            synchronized(locker) {
                if(instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

但这个地方，说实话我第一次学习的时候也觉得奇怪，因为在单线程两个一样条件的 if 是无意义的。单线程中，执行流就只有一个，上一个 if 的判定结果和下一个 if 是一样的~

但是在多线程中，两次判定之间，可能存在其他线程，然后其中有线程把 if 中的instance变量给修改了。就导致这里的两次 if 结论可能不同~

所以这里的两次 if 条件相同，只是纯属巧合了...

但是呢，增加了 if 判断是否加锁还是可能存在一些问题，比如是否会存在“内存可见性”问题？

答案是可能存在的，编译器优化非常复杂，为了稳妥起见可以给instance直接加上一个volatile，从根本上杜绝了内存可见性问题。

此处内存可见性就可能存在这种情况：第一个线程读取instance的时候，第二个线程进行修改。第一个线程就没有能及时读取到第二个线程进行的修改。

但这里更关键的问题其实是指令重排序。指令重排序也是编译器优化的一种体现，编译器会在逻辑不变的前提下，调整你代码执行的先后顺序，以达到提升性能的效果。

涉及指令重排序的代码为创建实例的时候：

instance = new SingletonLazy();

这一步从概念上可以拆成三步：

分配对象内存
执行构造函数，对对象初始化
把对象地址赋值给 instance

正常来说这三个步骤是按照 1、2、3 这样的顺序来执行的。但是在指令重排序下，可能成为 1、3、2 这样的顺序，单线程环境下，1、2、3 还是 1、3、2 其实无所谓~

但多线程中是 1、3、2 这样的顺序执行，多线程环境下可能会出现 BUG！！！

这样的问题不仅仅是指令重排序引起的，也和双重 if 有关，那么到底该如何解决？

其实透露一下，volatile这个关键字的功能有两个方面：

确保每次读取操作都是读内存
关于该变量的读取和修改操作，不会触发重排序

所以最终优化版本如下：

class SingletonLazy {
    private static volatile SingletonLazy instance = null;	// 第三处
    private static Object locker = new Object();
    private SingletonLazy() {

    }
    public static SingletonLazy getInstance() {
        if(instance == null) {	// 第二处
            synchronized(locker) {	// 第一处
                if(instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

最后切记关于懒汉模式的三个关键点，然后关于面试中真的遇到了该如何应对：

先写一个不带线程安全的单例模式
思索片刻，线程不安全，把锁加上
再次思索片刻，加上 if
再次思索片刻，加上 volatile

如果是一次写出最终版本，在面试官眼里他会觉得这个问题你正好准备过，此时说明这个题目就考察不出来啥，这题不算，谈下一话题~

2. 阻塞队列

我们在 JavaSE 中学过普通队列，应该都知道先进先出。而所谓的阻塞队列BlockingQueue就是一种比较特殊的队列。但它首先还是队列，所以仍然遵守先进先出。可它又多了一个非常重要的一个特点：

当队列满的时候，继续入队列就会阻塞，直到有其他线程从队列中取走元素；
当队列空的时候，继续出队列也会阻塞，直到有其他线程往队列中插入元素；

阻塞队列的一个典型应用场景就是“生产者消费模型”

2.1 生产者消费者模型

···

生产者消费者模型其实就是：通过一个容器来解决生产者和消费者的强耦合问题。

生产者和消费者彼此之间不直接通讯，而是通过阻塞队列来进行通讯，所以伸长这生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取。

生产者消费者模型这名字也很好理解，就比如过年包饺子：

负责擀饺子皮的这个人就是生产者

负责包饺子的人就是消费者

这样，擀饺子皮的不关心包饺子的人是谁，包饺子的人也不用关心擀饺子皮的人是谁，大家就各自做各自的就行。

这也就是简单的上下游关系。阻塞队列的目的就是避免生产者和消费者之间绑得很死，能够解耦合；

阻塞队列还相当于生产者和消费者之间的缓冲，平衡生产者和消费者的处理能力，也就是削峰填谷。

一般来说 A 这种上游的服务器，尤其是入口的服务器，干的活更简单，单个请求消耗的资源数少；像 B 这种下游的服务器，通常承担更重的任务量，复杂的计算/存储工作，单个请求消耗的资源数更多。

引入下面 2 这样的阻塞队列后，就能够有效缓解一下 B 服务器；它会让来自 A 的请求先进入阻塞队列，随后消费者服务器慢慢取，暗号服务器能承受的速度处理；

比如：突然来了 10000 个请求，先存起来，然后每秒处理 100 个；也就是高峰先缓冲，慢慢消化。这也就是所说的“削峰”。

2.2 标准库中的阻塞队列

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>();

        for (int i = 0; i < 100; i++) {
            queue.put("aaa");
        }
        System.out.println("队列已经满了. ");

        queue.put("aaa");
        System.out.println("再次尝试 put 元素");
    }
}

Java 已经给我们准备好了BlockingQueue，这是一个接口，真正实现的类是LinkedBlockingQueue。

其中put方法用于阻塞式的入队列，take用于阻塞式的出队列。
BlockingQueue也有offer、poll、peek等方法，但是这些方法不带有阻塞特性。

会发现，这里有数组、链表以及优先级队列实现的阻塞队列。说到这就想到，面试中常考的 Java 中 ArrayList 和 LinkedList 有什么区别，其实最主要的是他们的时间复杂度

顺序表：尾插尾删，O(1)；头插头删、中间位置插入 O(N)
链表：任意位置插入删除 O(1)

这里我让 ai 给了个阻塞队列的表格：

对比	`ArrayBlockingQueue`	`LinkedBlockingQueue`
底层结构	数组	链表
是否有界	必须指定容量	可指定；不指定时容量接近无限
内存分配	初始化一次数组，后续基本不分配节点	每加入一个元素都要创建 Node
GC 压力	较小	较大
put/take 并发	共用一把锁	`putLock`<br/> 和 `takeLock`<br/> 两把锁
高并发吞吐	一般	某些生产/消费并发场景更好
内存可控性	很好	要特别注意容量
延迟稳定性	通常更好	容易受对象分配和 GC 影响

先来一个例子：

生产者消费者模型使用阻塞队列

public class Demo7 {
    
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        Thread producer = new Thread(() -> {
            int num = 0;
            while (true) {
                try {
                    queue.put(num);
                    System.out.println("生产元素" + num);
                    num++;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"producer");

        Thread consumer = new Thread(() -> {
            try {
                Integer num = queue.take();
                System.out.println("消费元素" + num);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        producer.start();
        consumer.start();
    }
}

关于此处要是不设参数的话，默认会是一个非常大的值...

用计算机计算就能知道是 21 亿多，

另外阻塞队列中，没有提供一个“阻塞的获取队首元素的操作”。

对于上述代码中，如果让其中一个 sleep 等待一下，让生产者速度比消费者速度快一下会如何？

其实只是生产者会很快填满阻塞队列，然后消费者会一个一个从中取出，就按他自己的节奏来。其实按照上述代码就算存满了，其实也占不了多大内存，我们已经知道该队列最大最多 21 亿个元素，每个元素就是一个 int 的 4 字节空间。总共就是 80 亿字节，转换为也就是 8G；

具体转换如下：

Thousand 千 => K

Million 百万 => M

Billin 十亿 => G

2.3 阻塞队列模拟实现

class MyBlockingQueue {
    // 此处不使用泛型
    private String[] data = null;
    // 队首
    private int head  = 0;
    // 队尾
    private int tail = 0;
    // 元素个数
    private int size = 0;
    public MyBlockingQueue(int capacity) {
        data = new String[capacity];
    }

    public void put(String elem) throws InterruptedException {
        // 当队列满，需要阻塞
        synchronized (this) {
            while (size >= data.length) {
                this.wait();
            }
            data[tail] = elem;
            tail++;
            // 再判断是否需要循环
            if(tail >= data.length) {
                tail = 0;
            }
            size++;
            // 针对队列空的话，需要唤醒阻塞
            this.notify();
        }
    }

    public String take() throws InterruptedException {
        // 当队列空，需要阻塞
        synchronized (this) {
            while (size == 0) {
                this.wait();
            }
            String ret = data[head];
            head++;
            if (head >= data.length) {
                head = 0;
            }
            size--;
            // 针对队列满的话，需要唤醒阻塞
            this.notify();
            return ret;
        }
    }
}

上述使用的阻塞队列是循环的队列：

由于队列满或者队列空的时候需要阻塞队列，然后又由于队列不空或者不满的时候需要被唤醒，所以put和take方法中分别都需要到wait和notify。

注意，上述代码中，使用synchronizd的目的是，解决多个线程同时修改队列导致的数据竞争，避免两个线程可能同时操作同一个位置导致队列混乱，保证 head、tail、size、data 的操作是线程安全的。另外，此处为避免混乱还需结合着wait和notify一起使用。

if (size >= data.length) {
    this.wait();
}

另外关于为什么使用的是while而不是if。问题在于被notify唤醒，并不代表你现在一定可以继续执行。假设：队列容量为 1，且当前队列已占满。现在有两个生产者 P1、P2 都想放元素。于是当前 P1、P2 都进入 wait等待。然后消费者取走占满的元素，唤醒了两个等待线程，假设是 P1 先拿到锁，现在队列就又满了。如果是if那么 P2 从wait后面继续执行，不会再次判断条件。于是就直接进行data[tail] = elem。但如果是while的话，P2 会再重新检查一遍是否真的被唤醒~

对于使用wait这个地方，其实标准库中就已经建议使用while来替换if~

java17中关于wait的相关解释

对了，上述所说的 wait，其实也不只是能被 notify 唤醒，还可以被Interrupt这样的方法给中断。如果用 if 作为 wait 的判断条件，此时也还是存在被提前唤醒的风险！

3 线程池

之前学习 String 已经初步了解了常量池相关知识，常量池主要就是为了复用常量数据，减少重复存储。它与线程池的共同点就是池化的思想：

把创建成本较高或可以重复利用的资源提前保存起来，后续重复使用。

那么线程池的意义就是，我还是举个例子吧：

一家餐厅每天都会不断有客人来。如果每来一桌客人，就临时招聘一个服务员，服务完再把他辞退，成本会非常高。
更合理的做法是提前准备固定数量的服务员，客人来了就分配给空闲服务员处理；忙不过来时，客人先排队等待。

所以线程池的最大好处就是提前创建并复用线程，避免频繁创建和销毁线程带来的开销。

对于频繁创建和销毁线程，目前已经有三种解决情况了：

线程池，不反复创建，直接使用；
协程：不再让每个任务都对应一个重量级线程；
虚拟线程，Java21+之后开始的；

但目前使用最普遍还是线程池，剩下两个可以后面再了解~

关于为什么叫“池”，主要还是因为池化的这种思想。都是池子里会提前准备一些资源，需要的时候拿出用即可，用完不是销毁，而是放回池子里继续再使用。

3.1 标准库中的线程池

其实，线程池不需要我们每次自己实现。Java 的标准库已经提供好给我们了。

先讲 Java 供我们可以自定义的线程池：

首先先来区分一下这些名称

Executor → 接口

ExecutorService → 线程池常用接口

Executors → 工具类，帮我们创建线程池

ThreadPoolExecutor → 线程池核心实现类

`ThreadPoolExecutor` 自定义线程池

核心方法是 submit(Runnable)，不过这个方法你在ThreadPoolExecutor没看到很正常，因为ThreadPoolExecutor是继承了submit这个方法。

继承关系是：Executor <- ExecutorService <- AbstractExecutorService <- ThreadPoolExecutor

而 submit方法主要是在ExecutorService中定义的，在 AbstractExecutorService 中给出了实现，所以 ThreadPoolExecutor 直接继承了它。

然后通过 Runnable 描述一段要执行的任务，再通过submit任务放到线程池中，线程池就会执行这些任务；

但构造ThreadPoolExecutor线程池有些麻烦，需要了解一些相关参数：

有四个构造参数，一般面试会问这些参数都是什么意思（经典面试题）

面试官最想听的就是你对于第七个参数的理解~

这里我们直接了解最困难的最后一个

ThreadPoolExecutor(
        int corePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue,
        ThreadFactory threadFactory,
        RejectedExecutionHandler handler
)

int corePoolSize：核心线程数，表示至少有多少个线程。线程池一旦创建，这些线程也要随之创建，知道整个线程池销毁，这些线程才会销毁。
int maximumPoolSize：最大线程数，表示核心线程数+非核心线程数（不繁忙就销毁，繁忙就再创建），我们知道，线程不是越多越好的。
long keepAliveTime：非核心线程允许空闲的最大时间。临时增加出来的线程，不可能永远留在那里。
TimeUnit unit：时间单位，单看keepAliveTime = 10你不知道单位是秒？分钟？小时？这里是枚举类型
BlockingQueue<Runnable> workQueue：任务队列，也就是我们前面学到的阻塞队列（线程池里的任务队列）。当然了此处的队列可以自己选择合适的根基（数组/链表、指定 capacity、指定是否要带有优先级/比较规则）。线程池本质上也是生产者消费者模型，调用submit就是在生产任务，线程池里的线程就是在消费任务。
threadFactory：线程工厂，用来定义线程池创建工作线程的方式。线程池需要新线程时，会调用 ThreadFactory.newThread(Runnable) 创建线程。通过线程工厂可以统一设置线程名称、优先级、是否为守护线程以及异常处理方式等。它只负责“怎么创建线程”，不负责决定“什么时候创建线程”。

对于为什么使用线程工厂，我给到下面的解释：

假设我有一个 Point，他最终都要保存平面直角坐标，单床剪一个点时，可以有两种输入方式：

方法 1，使用直角坐标(x,y)；方法 2，使用极坐标(r,a)

但问题就在构造方法这里，我们会自然的写出两个构造方法：

class Point {
    public Point(double x, double y) {
        // 按照直角坐标创建
    }
    public Point(double r, double a) {
        // 按照极坐标创建
    }
}

但是 Java 不允许，原因就是 Java 的方法重载看的是方法名、参数个数、参数类型、参数顺序。所以对于 Java 来说这俩就完全一样。所以就用工厂方法来解决。就改为不直接让用户调用构造方法，而是提供不同名字的方法。就比如下面：

class PointFactory {
    public static Point makePointByXY(double x, double y) {
        Point p = new Point();
        p.x = x;
        p.y = y;
        return p;
    }

    public static Point makePointByRA(double r, double a) {
        Point p = new Point();
        p.x = r * Math.cos(a);
        p.y = r * Math.sin(a);
        return p;
    }
}

注意类型是 Point并且还是静态方法。工厂方法的核心就是通过静态方法把构造对象 new 的过程、各种属性初始化的过程封装起来，并且提供多组静态方法，实现不同情况的构造。此时调用就可以这样：

Point p1 = PointFactory.makePointByXY(3, 4);
Point p2 = PointFactory.makePointByRA(5, Math.PI / 2);

当然也可以直接在Point里面写静态工厂方法：

class Point {

    private double x;
    private double y;

    private Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public static Point fromXY(double x, double y) {
        return new Point(x, y);
    }
    public static Point fromRA(double r, double a) {
        return new Point(
                r * Math.cos(a),
                r * Math.sin(a)
        );
    }
}

// 使用
Point p1 = Point.fromXY(3, 4);
Point p2 = Point.fromRA(5, Math.PI / 2);

以上两种方法分别是：

构造方法：负责真正构造对象

静态工厂方法：负责提供不同的创建方式

以上就是对工厂类的解释。

RejectedExecutionHandler：拒绝策略，显然他的意思就是字面意思。submit会把任务添加到任务队列中，任务队列是阻塞队列，队列满了再添加，就会阻塞~对于线程池来说，发现入队列操作时，队列满了，不会真的触发“入队列操作”，不会真阻塞，而是执行拒绝策略相关代码。

为什么不使用生产者消费者模型是因为如果调用submit就阻塞，就会是这个线程就没法干别的事情，对于用户那里就会迟迟拿不到请求的响应，用户等了很久，直观上看到的现象就是“卡了”。所以，与其是“卡了”不如直接告诉我“失败”。

拒绝策略就是下面四个，我会再一步解释一下：

拒绝策略	含义
`AbortPolicy`	直接抛异常
`CallerRunsPolicy`	让提交任务的线程自己执行
`DiscardOldestPolicy`	丢掉队列中最老的任务
`DiscardPolicy`	直接丢掉新任务

拿快递站举个例子，现在所有员工都忙，任务本也写满了，临时工也招到上限。

此时来了一个快件...

AbortPolicy：“接受不了了！”，直接报错；

CallerRunsPolicy：“谁把这个任务送过来的，谁自己干。”

DiscardOldestPolicy：“把任务本里最老的一项扔掉，给新任务腾位置。”

DiscardPolicy：“新来的直接不要。”

意思就是上面这么个意思

`Executors`封装好的常用线程池

如果按照上面的自定义线程池那样，每次使用线程池就得自己填写那么多参数还是太麻烦了。而且很多时候我们的需求其实也很普通：我就是想要一个固定 10 个线程的线程池。

所以 Java 就提供了一个封装好的 Executors 这样一个工具类。它就相当于帮我们把常见的ThreadPoolExecutor参数提前组合好了，并且提供了几种常见线程池创建方式。

下面都是Executors的方法：

我只大概了解其中几个：

newFixedThreadPool：创建一个固定 n 个线程的线程池。

ExecutorService pool =
        Executors.newFixedThreadPool(10);
pool.submit(() -> {
    System.out.println("hello");
});

newCachedThreadPool：创建线程数量可以动态变化的线程池。业务多的时候会增加线程；业务少的时候空闲线程逐渐回收。
newScheduledThreadPool：可以完成延迟执行、定期执行；正好等到后面要说的定时器再展开。

综上也能看出来，其实 Executors 本质上就是 ThreadPoolExecutor 类的封装。

3.2 线程池的关闭

线程池使用完后，需要主动进行关闭。ThreadPoolExecutor中常用的两个就是：shutdown()和awaitTermination()。

其中shutdown()用于发起线程池关闭通知，而awaitTermination()用于等待线程池真正关闭完成。

`shutdown()`方法

executor.shutdown()，调用shutdown之后，线程池会进入关闭状态，会有以下的过程：

不再接受新任务；
已经提交并正在执行的任务会继续执行；
已经进入任务队列的任务也会继续执行；
当所有已提交任务执行完成后，线程池中的工作线程才会逐渐退出。

注意，shutdown不会阻塞调用它的线程~毕竟，谁会断了自己的路呀~

`awaitTermination()`方法

如果程序需要确认线程池中的任务已经执行结束，可以配合：

executor.awaitTermination(10, TimeUnit.SECONDS);

作用就是：让当前线程等待线程池结束，最多等待指定的时间。

通常需要先调用executor.shutdown()，再调用executor.awaitTermination(10, TimeUnit.SECONDS)

例如：

executor.shutdown();

try {
    boolean finished = executor.awaitTermination(10,TimeUnit.SECONDS);

    if (finished) {
        System.out.println("线程池已经完全关闭");
    } else {
        System.out.println("等待超时，线程池仍未关闭");
    }

} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

此处，awaitTermination(10,TimeUnit.SECONDS)表示当前线程最多等待线程池 10 秒。然后这个方法还会返回一个boolean值：true 表示在线程等待期间，线程池已经完全终止；false 表示等待时间已经到了，但线程仍然没有结束。

3.3 线程池模拟实现

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

// 实现一个固定线程个数的线程池
public class MyThreadPool {
    private BlockingQueue<Runnable> queue = null;
    public MyThreadPool(int n) {
        // 初始化线程池，创建固定个数的线程
        // 此处使用ArrayBlockingQueue作为任务队列，容量为1000
        queue = new ArrayBlockingQueue<>(1000);

        // 创建线程
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                try {
                    while (true) {
                        Runnable task = queue.take();
                        task.run();
                    }
                } catch(InterruptedException e){
                    throw new RuntimeException(e);
                }
            });
            // 启动线程
            t.start();
        }
    }

    // 提交任务
    public void submit(Runnable task) throws InterruptedException {
        queue.put(task);
    }

    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(10);
        for (int i = 0; i < 100; i++) {
            int id = i;
            pool.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " id = " + id);
            });
        }
    }
}

理解线程池最直接的方法之一，就是自己实现一个简化版本，并且能不看模板自己实现一个，这样你才能明白到这段代码中很多细节以及整个运转流程，真的...

真正的 ThreadPoolExecutor 内部还包含核心线程数、最大线程数、拒绝策略、线程回收、线程池状态管理等大量机制，但如果只看最核心的思想，其实可以概括为两部分：

提前创建一批可以重复使用的工作线程
使用一个任务队列保存暂时还没有被执行的任务

上面那部分代码虽然很简单，但已经包含了线程池最基本的运行过程。我来解释一下部分含义：

使用阻塞队列保存任务

我在线程池内部首先定义了一个BlockingQueue<Runnable>，创建了一个容量为 1000 的阻塞队列，队列中保存的不是线程，而是Runnable，也就是一个个等待执行的任务。当调用pool.submit(task)时，任务并不会立即由submit方法执行，而只是通过queue.put(task)被放入任务队列中。

整个过程就是

“提交任务 -> submit(task) -> queue.put(task) -> 等待工作线程处理”

使用阻塞队列还有一个重要的原因：它可以很好的协调“提交任务的线程”和“执行任务的线程”。

当队列暂时没有任务时，工作线程执行：queue.take()，会进入阻塞状态，而不是不断循环检查队列。这样的话线程在没有任务的时候就不会一直占用的 CPU。

提前创建固定数量的工作线程

在线程池的构造方法中，已经提前创建好了 n 个线程MyThreadPool pool = new MyThreadPool(10)，这就意味着线程池创建时会直接启动 10 个工作线程。这些线程当然不是执行一次任务以后就结束，而是在 while 里不断循环去 take 任务：

while (true) {
    Runnable task = queue.take();
    task.run();
}

take() 负责取得任务，run() 负责执行任务

在工作线程中最核心的代码实际上只有两行：

Runnable task = queue.take(); 
task.run();

queue.take()负责从任务队列中获取一个Runnable任务，当其他线程通过queue.put(task)提交新任务以后，线程池中的一个的等待中的工作线程就可以取得这个任务。

task.run()才是真正执行任务的地方，当然这里还有注意去分析下t.start()和task.run()。

例如：

Thread t = new Thread(...);
t.start();

表示启动一个工作线程。之后这个工作线程从队列中取得Runnable task，再调用task.run()表示由当前这个已经启动的工作线程去执行任务。

👌以上就是我对模拟实现的讲解~

4. 定时器

上面我们已经学习了线程池，他所解决的主要是任务来了以后交给谁执行，而现在要学习了定时器要解决的是这个任务是么时候执行。

你可以把定时器类比一下为“闹钟”，先把任务和时间约好，等时间到了以后再去执行对应的代码。就像是计算机网络里学到的网络通信超过一定时间没有响应就重连，或者让某个缓存数据几秒以后过期。

4.1 标准库中的`Timer`

标准库提供了一个 Timer 类，Timer 类的核心方法就是Schedule；

Schedule包含两个参数，第一个参数指定即将要执行的任务代码，第二个参数指定多长时间之后执行（单位为毫秒）

Timer timer = new Timer();

timer.schedule(new TimerTask() {
    @Override
    public void run() {
        System.out.println("hello");
    }
}, 3000);

以上是匿名内部类写法，与讲线程的创建方法的时候类似。

主要就是以下三个要点：

创建了子类（父类 TimerTask），匿名
重写了 run
new 了子类的实例

正常描述任务，是 Runnable，但在定时器这里稍微特殊一些，把 Runnable 封装了一下为 TimeTask。那么 Timer 和 TimerTask 分别又是什么呢？

你可以这样理解，就是Timer负责什么时候执行，也就是调度者；TimerTask负责执行什么，也就是任务；

和线程池类似，线程池负责调度并执行 Runnable 任务，而 Timer 负责定时调度 TimerTask 任务；实现 Runnable 时需要实现 run() 方法，继承 TimerTask 时同样需要重写 run() 方法，因为真正的任务逻辑都写在 run() 中。

Thread thread = new Thread() {
    @Override
    public void run() {
        System.out.println("hello");
    }
};

thread.start();

以上就是两者的大概对比；还有就是和线程池一样，Timer 中也包含前台线程，阻止进程结束。

4.2 定时器的模拟实现

首先我们需要了解定时器的构成：

一个带优先级队列（不需要使用 PriorityBlockingQueue，容易死锁）
队列中的每个元素是一个 Task 对象
Task 中带有一个时间属性，队首元素就是即将要执行的任务
同时有一个 worker 线程一直扫描队首元素，看对队首元素是否需要执行

而我们要实现定时器则需要按照下面这四部分：

创建一个类MyTimeTask，表示一个任务
定时器中，能够管理多个任务的集合类
实现 schedule 方法，把任务添加到队列中即可
额外创建一个线程，负责执行队列中的任务

和线程池不同，线程池是只要队列不为空，就立即取任务并执行。此处还要看队首元素的时刻是否到了，时刻到才能执行，时刻不到不能执行。

这里的话，我喜欢先讲解再展示代码哈：

我先创建两个类，分别是定时器类MyTimer,以及存放任务的 MyTimerTask。这里我没有实现Runnable，而是直接在MyTimerTask持有一个Runnable。所以MyTimerTask里就存在了两个参数，Runnable task和long time；接着就是必备着带着两个参数的构造方法。记住，既然自己实现了任务类就得自己实现一个比较器。
接着就是在MyTimer定时器里创建一个优先级队列PriorityQueue<MyTimerTask> queue，存放就是自己写的任务类MyTimerTask。再然后就是创建schedule方法，在这个方法里实例化一个新任务并放入队列中。
随后就是在MyTimer中通过构造方法创建线程，循环从队列中提取任务进行执行

这三部分我都是按照上面说的，只是将第二步与第三步放在了一起。然后是注意线程安全问题，注意加锁 synchronized 以及wait/notify；

package timer;

import java.util.PriorityQueue;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Syrena.
 * Date: 2026-09-20
 * Time: 13:24
 */
public class MyTimer {
    // 队列里的每一个元素都是MyTimerTask类型
    private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private Object locker = new Object();
    // 创建schedule方法
    public void schedule(Runnable task, long delay) {
        synchronized (locker) {
            // 记录时间戳
            // 实例化时建议放在锁里，否则没拿到锁的时候就先实例化时间存在一定延迟
            MyTimerTask timerTask = new MyTimerTask(task, System.currentTimeMillis() + delay);
            queue.offer(timerTask);
            locker.notify();
        }
    }

    // 构造方法中，额外创建一个线程，负责执行队列中的任务
    public MyTimer() {
        Thread t = new Thread(() -> {
            try {
                while (true) {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            locker.wait();
                        }
                        // 取出队首元素
                        MyTimerTask task = queue.peek();    // 先判断时间是否到再移除
                        if(System.currentTimeMillis() < task.getTime()) {
                            // 当前任务时间如果比系统时刻还大，说明还未到执行时刻
                            locker.wait(task.getTime()
                                    - System.currentTimeMillis());
                        } else {
                            task.run();
                            queue.poll();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
    }
}

package timer;

/**
 * Created with IntelliJ IDEA.
 * Description: 用来描述一个任务
 * User: Syrena.
 * Date: 2026-09-20
 * Time: 13:15
 */

    /*
    两个方法：
    1. 实现一个Runnable，但需要基于抽象类定义MyTimerTask
    2. 持有一个Runnable
     */
// 由于比较的类是自己写了类型，所以比较规则需要自己写（Comparable/Comparator）
public class MyTimerTask implements Comparable<MyTimerTask>{

    private Runnable task;
    private long time;  // 记录要执行的时刻，用时间戳

    // 构造函数里传入可运行的task
    public MyTimerTask (Runnable task,long time) {
        this.task = task;
        this.time = time;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int) (this.time - o.time);  // < 0，则this < 0；需求是让时间小的元素在队首，实现小根堆
    }
    public long getTime() {
        return this.time;
    }
    public void run() {
        task.run();
    }

    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Hello 1000");
            }
        },1000);
        myTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Hello 2000");
            }
        },2000);
        myTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Hello 3000");
            }
        },3000);
    }
}

以上就是定时器的模拟实现，需要注意的是：

public MyTimer() {
    Thread t = new Thread(() -> {
        try {
            while (true) {
                synchronized (locker) {
                    while (queue.isEmpty()) {
                        locker.wait();
                    }
                    // 取出队首元素
                    MyTimerTask task = queue.peek();    // 先判断时间是否到再移除
                    if(System.currentTimeMillis() < task.getTime()) {
                        // 当前任务时间如果比系统时刻还大，说明还未到执行时刻
                        locker.wait(task.getTime()
                                - System.currentTimeMillis());
                    } else {
                        task.run();
                        queue.poll();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    t.start();
}

此处的构造方法本身可以写synchronized，但此处不能将synchronized直接包裹整个构造方法，因为此处的synchronized 保护的是线程的 run 里面的 lambda；

while (queue.isEmpty()) {
    locker.wait();
}

此处使用 wait 时要使用 while，避免异常唤醒以及其他可能唤醒能够循环再次检查一遍；如果使用if检查的话，会导致忙等，一直循环检查会消耗大量 CPU 资源。

if(System.currentTimeMillis() < task.getTime()) {
    // 当前任务时间如果比系统时刻还大，说明还未到执行时刻
    locker.wait(task.getTime()
            - System.currentTimeMillis());
} else {
    task.run();
    queue.poll();
}

此处使用 wait 时无需再 while 检查，因为外面有一层 while，就算这里被异常唤醒后能够再循环到这一步重新 wait。

标准库提供的 Timer 和自己写的 MyTimer 差不多，都是使用一个线程，负责扫描队首元素并执行。但其实可以结合线程池，创建多个线程，负责执行这里的队列中的任务（一个线程负责扫描，扫描到需要执行的任务，添加到另一个线程池的任务队列中，有多个线程负责执行）

如果任务少/任务的时间分散都无所谓，如果任务特别多，时间非常集中，一个线程就可能执行不过来~

定时器其实是一个非常重要的组件，在分布式系统中，把定时器专门提取出来，封装成一个单独的服务器~

Java 多线程基础：Thread、线程安全与同步机制

Thu, 10 Sep 2026 00:00:00 GMT

1.初识线程 `Thread`

1.1 什么是多线程

上一篇我们已经提到，一个程序运行起来就是一个进程。而一个进程里，又存在多个线程。

简单来说：

进程提供运行环境和资源，而线程是真正在这个环境中执行代码的执行流；

我们之前是这么比喻的：

进程 = 一套房子

线程 = 房子里干活的人

同一个房子里，可以住好几个人，就比如：

张三在厨房做饭
李四在客厅扫地
王五在阳台晾衣服

他们虽然在干不同的事情，但他们都在共享着一套房子里的资源。当然，在程序里也差不多。

在一个 Java 进程中可以存在多个线程，每个线程都有自己的执行流程，但是同一个进程里的线程又可以共享这个进程里的资源和数据。这就是所说的多线程。

1.2 为什么需要线程

还是拿上一篇“吃鸡”的例子

现在桌子上有 100 只鸡：

如果只有我一个人吃：

我必须得一只、两只、三只......

但如果我叫来一位老铁：

如果条件合适，两个人就可以分别处理一部分工作

对应到程序里就是一个任务可以被拆成很多个相对独立的任务，交给多个线程执行。

但，千万不要理解成：线程越多，程序就一定越快。这个结论当然是不成立的。

依旧是吃鸡这个例子，一张桌子本来坐四个人正好，你非得找 100 个人围着这张桌子：

“兄弟们！我们今天靠人数优势干爆这 100 只鸡！”

最后可能会出现这种情况：

鸡没吃几只，100 个人先因为 “你挡我了。”、“筷子给我。”、 “让我过去。”等各种原因先打起来。

线程也是一样。线程创建、切换和调度本省都有开销，而且 CPU 核心数量也是有限的。所以合理的多线程可以提高效率，而不是无限增加线程数量。

这里我给出了一段代码，可以尝试运行一下，比较线程串行和并行的时间效率：

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Sirens007
 * Date: 2026-09-02
 * Time: 10:27
 */
public class TheadAdvantage {
    private static final long count = 10_0000_0000;

    private static void concurrency() throws InterruptedException {
        long begin = System.nanoTime();

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a--;
                }
            }
        });
        // 主线程内计算b的值
        int b = 0;
        for (long j = 0; j < count; j++) {
            b--;
        }
        // 等待thread进程结束
        thread.join();

        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 /1000 /1000;
        System.out.printf("并发：%f 毫秒 %n",ms);
    }

    private static void serial() {
        // 都在主线程计算a , b值
        long begin = System.nanoTime();
        int a = 0;
        for (long i = 0; i < count; i++) {
            a--;
        }
        int b = 0;
        for (long j = 0; j < count; j++) {
            b--;
        }
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 /1000 /1000;
        System.out.printf("串行：%f 毫秒 %n",ms);
    }

    public static void main(String[] args) {
        try {
            concurrency();
            serial();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }
}

2.Java 中创建线程

我了解到的是有三个方法：

2.1 继承 `Thread`

首先需要自己写一个类，主要是为了重写 Thread 中的 run()方法：

class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("我开始干活了");
    }
}

其中的 run()方法描述的是这个线程启动后，到底要做什么，然后就会创建线程对象 thread。

但是此时还没有真正开始执行，你可以类比这个例子：

我把李四叫到了公司

李四就说：“老板，我来了。”

我：“嗯”

然后谁也不说话，李四当然不会知道自己需要去做什么了。

所以这个时候还需要我们去启动线程：thread.start();

这就相当于：我跟李四说：“李四，开始干活！ ”

这个时候就算是真正的启动了一个线程。注意：run() 和 start()千万不要弄混淆；直接写 thread.run()的话只是相当于直接调用方法，而启动执行流才是使用：thread.start()

2.2 实现 `Runnable` 接口

除了直接继承Thread，Java 还可以把“线程”和“任务”拆开。

同样我们还是需要重写 run()方法，因为实现 Runnable 接口就得重写它的所有方法：

不过 Runnable 只有一个 run 方法~

class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("开始搬砖");
    }
}

然后还要记得启用线程：

MyRunnable task = new MyRunnable();
Thread thread = new Thread(task);
thread.start();

不知道会不会有人觉得这样写法比继承 Thread 多绕了一层...

不过我推荐这样理解：

Thread 是员工，Runnable 是工作任务；

假如当前有个任务是搬 100 块砖，因此我需要去定义这个任务

MyRunnable task = new MyRunnable()，然后再把任务交给员工，Thread thread = new Thread(task)，最后老板说开始干，也就是thread.start()这样就会好理解多了；

2.3 其他变形

2.3.1 使用匿名内部类创建 `Thread`

如果你打算这个线程就使用一次的话，单独写 MyThread 就似乎有点麻烦了。

所以我们可以直接使用匿名内部类：

Thread thread = new Thread() {

    @Override
    public void run() {
        System.out.println("我开始干活了");
    }
};

thread.start();

本质上还是要重写 run 方法，只是这次这个类我没有单独取名字，直接现场创建。

2.3.2 使用匿名内部类创建 `Runnable`

既然上面 Thread 可以使用匿名内部类，Runnable 当然也是可以啦

Thread thread = new Thread(new Runnable() {

    @Override
    public void run() {
        System.out.println("我开始干活了");
    }
});

thread.start();

本质上还是：任务 + 执行任务的线程

2.3.3 使用 `Lambda` 创建线程

首先我们需要知道什么是 Lambda，Lambda 你可以理解为：对“只有一个抽象方法的接口”的简化写法。

Lambda 是从 Java8 开始引入的，主要就是为了“把一段代码装起来”，举个例子：

public static void hello() {
    System.out.println("Hello");
}

这个方法就描述了一件事情，但我现在想把这段“要执行的代码”交给另外一个东西，让它以后帮我们执行，我们一般就只能通过 接口 -> 实现类 -> 重写方法 -> 创建对象 这样的步骤完成；

// 创建接口
interface Task {
    void run();
}

// 创建类实现接口
class MyTask implements Task {

    @Override
    public void run() {
        System.out.println("Hello");
    }
}

// 最后创建对象
Task task = new MyTask();

引入 lambda 就是为了让这种代码变的简洁,于是这部分就变成了：

Task task = () -> {
    System.out.println("Hello");
};

能够省去了“创建类实现接口”这个部分；

3.`Thread` 常用属性和方法

至于线程我们已经知道如何创建出来了，那么我们就还得了解它现在在干嘛、怎么让它停下来、等待它结束，或者通知它停止？

3.1 `Thread` 常见属性

在我们创建线程的时候，thread 不只是一个普通的对象，它描述的就是后面那个线程执行流。

先来一段代码：

public class ThreadDemo {

    public static void main(String[] args) {

        Thread thread = new Thread(() -> {
            System.out.println("线程开始工作");
        });

        System.out.println("线程 ID：" + thread.getId());
        System.out.println("线程名称：" + thread.getName());
        System.out.println("线程状态：" + thread.getState());
        System.out.println("线程优先级：" + thread.getPriority());
        System.out.println("是否后台线程：" + thread.isDaemon());
        System.out.println("是否存活：" + thread.isAlive());
        System.out.println("是否被中断：" + thread.isInterrupted());
    }
}

这里面用到的方法就是 Thread 提供的线程 ID、名称、状态、优先级、是否存活以及终端标志等信息。

getId()：获取线程的编号，就类似员工的工号；
getName()：获取线程名字，我们当然可以自定义名字，方法如下；
getState()：用于获取线程当前的状态，后面会再介绍进程的四个状态；
getPriority()：用于查看线程优先级，但这里的线程优先级高也不代表一定会先执行；
isDaemon()：用于查看是不是后台线程，也可以叫守护线程，你可以理解为做后勤的；然后一般前台线程、后台线程都是有多个的；如果有多个前台线程，必须得等所有前台线程都结束了，进程才能结束；
isAlive()：用来判断该线程是否还活着；
isInterrupted()：给线程发一个中断通知，但不是强制杀死线程；

// 自定义名字
Thread thread = new Thread(() -> {
    System.out.println("开始搬砖");
}, "李四");

3.2 `Thread` 常见构造方法

方法	说明
`Thread()`	创建线程对象
`Thread(Runnable target)`	使用 `Runnable`<br/> 对象创建线程对象
`Thread(String name)`	创建线程对象，并命名
`Thread(Runnable target, String name)`	使用 `Runnable`<br/> 对象创建线程对象，并命名
【了解】`Thread(ThreadGroup group, Runnable target)`	线程可以被用来分组管理，分好的组即为线程组，这个目前我们了解即可

具体的使用例子如下：

Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

如果我们想实时了解线程的状态，我们还可以通过 jdk 里的 jconsole 这个可执行文件查看，路径就在 jdk 下面的 bin 目录里，如下：

3.3 启动一个线程-`start()`

我们之前说过run() 描述线程要做的事情，而真正让线程独立运行的是 start()；只有调用 start()，底层才会真正创建新的线程。

所以我们要了解 start()我们就得了解这个方法：

会发现真正底层启动线程的工作是由 start0 这个方法完成的。从 native 可以看出这是一个本地方法或者说是Java 标准库/JVM 提供的方法，由 C++ 语言编写的方法。本质上是调用系统的 API，不过这对于我们学习 Java 目前应该不是那么必要。

3.4 中断一个线程

假设我们面对一个情境：

前面已经把员工成功招进公司，也知道怎么查看他的名字、状态这些信息了，但现实中老板安排下去的任务也不一定非得执行到底。

比如现在李四正在疯狂转账：

李四：老板放心，钱马上就转过去了。

结果老板突然接到电话：

“别转了！对面是骗子！”

那现在就有一个问题：

李四这个线程都已经开始执行了，我该怎么通知他赶紧停下来？

当然，Java 不是粗暴将它 thread.kill()掉，而是采用通知的方式告诉他你该停了。此时线程就会收到通知，但是否停止、什么时候停止就由线程的代码自己决定。

我学习到的常见就是以下两种方法：

通过共享的标记来进行沟通；
调用 interrupt()方法通知；

示例一：共享变量作为标志位（标志位要加上 volatile）

class MyRunnable implements Runnable {

    public volatile boolean isQuit = false;

    @Override
    public void run() {
        while (!isQuit) {
            System.out.println(
                    Thread.currentThread().getName()
                    + "：别管我，我忙着转账呢！"
            );
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(
                Thread.currentThread().getName()
                + "：啊！险些误了大事"
        );
    }
}
public static void main(String[] args)
        throws InterruptedException {
    MyRunnable target = new MyRunnable();
    Thread thread = new Thread(target, "李四");
    System.out.println("让李四开始转账");

    thread.start();
    Thread.sleep(10 * 1000);
    System.out.println("老板来电话了，对方是骗子！");
    target.isQuit = true;
}

此处的 volatile 关键字我们后面再继续专门讲解，这里先不用钻太深~

现在可以先简记为：volatile isQuit就是为了让一个线程修改以后，另外一个线程能够及时看到。

上面的代码流程如下：

共享变量此处再补充一个点：

如该例子：（我也不知道为什么截 IDEA 里就是这么糊）

Java 要求 Lambda 捕获的局部变量必须是：

final 或者 effectively final（实际没有被修改）

这里是触发“变量捕获”这样的语法，Lambda 是回调函数，执行时机是很久之后（操作系统真正创建出线程知乎偶，才会执行的）

所以很有可能，后续线程创建好了，当前 main 这里的方法都执行完了对应的 isFinished 就销毁了。所以为了解决上述的问题：

Java 将被捕获的变量给拷贝一份，拷贝给 Lambda 里面。外面的变量是否销毁，就不影响 Lambda 里面的执行了。

但是拷贝，就意味着这样的变量不适合进行修改。因为修改一方，另一方不会随之变化的（本质上是两个变量），所以 Java 语言的大佬就不允许在这里进行修改~

上面图片中可以利用成员变量（也就是定义在类里面、方法外面的变量，它属于对象或类）

public class Demo5 {
    private static boolean isFinished = false;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isFinished) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //somefunc...
                }
            }
            System.out.println("t 结束");
        });

        t.start();
        Thread.sleep(3000);
        System.out.println("main 线程尝试终止 t 线程");
        isFinished = true;
    }
}

但这里有一个隐患，就是线程之间可能看不到最新值，也就是存在可见性问题，涉及到 volatile，我们先保留该问题；但主要还是应为 CPU 缓存机制

示例二：使用interrupt通知线程

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println(
                    Thread.currentThread().getName()
                    + "：别管我，我忙着转账呢！"
            );
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(
                        Thread.currentThread().getName()
                        + "：收到老板的中断通知！"
                );

                // sleep 被 interrupt 后，中断标志会被清除
                // 因此这里直接 break 结束循环
                break;
            }
        }
        System.out.println(
                Thread.currentThread().getName()
                + "：啊！险些误了大事"
        );
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "李四");
        System.out.println("让李四开始转账");
        thread.start();
        
        // 老板 10 秒后发现被骗
        Thread.sleep(10 * 1000);
        System.out.println("老板来电话了，对方是骗子！");

        // 通知李四线程停止
        thread.interrupt();
    }
}

Interrupt你可以先理解为老板让你先停一下，而不是让你人间蒸发。当然啦，老板的话听不听也可以取决于你~

interrupt() 的核心是通知线程发生了中断，而不是直接强制终止线程。

既然说到了 interrupt()那其实就还有一种方法，就是Thread.interrupted()也能判断

while (!Thread.interrupted()) {

}

它也可以用来检查当前线程的中断状态。注意是当前线程，因为Thread.interrupted()是静态方法。不过我们还要了解一个方法，就是 thread.isInterrupted()，它们存在一定区别。

方法	是否静态	检查谁	会不会清除中断标志
`Thread.interrupted()`	是	当前线程	会清除
`thread.isInterrupted()`	否	指定的 `thread`<br/> 对象	不会清除

如果在线程自己的代码中判断中断状态，经常会写成 Thread.currentThread().isInterrupted()。其中 Thread.currentThread() 获取的是当前正在执行这段代码的线程，然后再通过 isInterrupted() 查看它的中断状态。它们有个区别需要记一下：

thread.isInterrupted()读取中断标志后不会清除这个标志；

Thread.interrupted()读取中断标志后会清除这个标志；

就拿下面代码举个例子：

public class Demo4 {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println(Thread.currentThread().getName() + "+" + Thread.interrupted());
        System.out.println(Thread.currentThread().getName() + "+" + Thread.interrupted());
    }
}
// 得到结果
// main+true
// main+false

Thread.interrupted() 在获取当前线程中断状态的同时，还会将中断状态清除。因此第一次调用得到 true 后，如果中途没有再次调用 interrupt()，第二次调用就会得到 false。

public class Demo4 {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println(Thread.currentThread().getName() + "+" + Thread.currentThread().isInterrupted());
        System.out.println(Thread.currentThread().getName() + "+" + Thread.currentThread().isInterrupted());
    }
}
// 得到结果
// main+true
// main+true

而这里的 interrupted 是读取线程的状态而不是去修改（刚好也出现了后面要说的 volatile）

如果线程正好在 sleep()：

方法	说明
`public void interrupt()`	`thread.interrupt()`：向指定线程发出中断请求
`public static boolean interrupted()`	`Thread.interrupted()`：检查当前线程的中断状态，并清除中断状态
`public boolean isInterrupted()`	`thread.isInterrupted()`：检查指定线程对象的中断状态，不会清除

到这的话就有点意思了，假设李四正在干活：

while (!Thread.currentThread().isInterrupted()) {
    System.out.println("工作");
    Thread.sleep(1000);
}

此时老板打来个电话，thread.interrupt()

刚好李四又在睡觉sleep()，Thread.sleep() 本身声明了可能抛出 InterruptedException。如果线程正在 sleep() 的过程中，其他线程对它调用了 interrupt(),李四这线程就会被唤醒并抛出InterruptedException；此时被 catch 到了，那么接下来需要干什么就取决于 catch 里的内容了，可以跳出也可以继续执行；

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("Hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    /*throw new RuntimeException(e);*/
                    /*Thread.currentThread().interrupt();*/
                }
            }
            System.out.println("t 结束");
        });
        t.start();

        Thread.sleep(3000);
        System.out.println("main 线程尝试终止 t 线程");
        t.interrupt();
    }
}

因为收到 InterruptedException 并不代表 Java 自动决定这个线程必须结束。

对于这部分解释，正常来说，调用 Interrupt 方法就会修改 isInterrupted 方法内部的标志位（设置为 true），由于上述代码中，是把 sleep 给唤醒了，这种提前唤醒的情况下，sleep 就会在唤醒之后，把 isInterrupted 标志位给设置回 false。

所以在这样的情况下，如果继续执行到循环的条件判定，就会发在能够继续执行~

3.5 等待一个线程 - `join()`

我们前面知道了如何让线程暂停，但现实中还有另一种情况：

就是我的工作必须等你的工作做完以后才能继续

假设李四负责：

整理今天公司的转账记录；

而我负责：

根据李四整理出来的数据统计今天到底赚了多少钱；

那我肯定不能李四刚开始整理，我这边就直接开始统计。为了解决这种情况，Java 中就引入了join()，来看个例子：

public class Demo {
    public static void main(String[] args)
            throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("李四开始整理数据");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("李四整理完成");
        }, "李四");

        t1.start();
        t1.join();
        System.out.println("main：开始统计数据");
    }
}

注意哈这地方容易弄反，在主线程中调用 join 得用到 t1 对象；也就是说调用join()的那个线程才是真正等待的。

main 等待 t 线程 <-----> t.join()

说实话，这里主要是按正常语言逻辑不太符合主谓宾习惯，但我们可以反过来理解

t 线程合并入 main（合并前提，必然是 main 存在）

两个执行流合并为一个，一个执行流结束，另一个继续执行；

方法	说明
`public void join()`	等待线程结束
`public void join(long millis)`	等待线程结束，最多等 `millis` 毫秒
`public void join(long millis, int nanos)`	同理，但可以更高精度

join 提供了带参数的版本，就是指定“超时时间”即等待的最大时间~

就像是你约了女神上午 8 点出来，最后女神 12 点才到；你继续在这里傻等就是“感动自己”~

3.6 获取、休眠当前线程

方法	说明
`public static Thread currentThread();`	返回当前线程对象的引用

很明显这是个静态方法，也就是说哪个线程调用这个方法，返回哪个线程的引用，类似 this；

方法	说明
`public static void sleep(long millis) throws InterruptedException`	休眠当前线程 millis 毫秒
`public static void sleep(long millis, int nanos) throws InterruptedException`	可以更高精度的休眠

Thread.sleep()是让调用它的当前线程休眠；

从上面多个例子你会发现，实例中往往都有

throws InterruptedException

// 或者以下

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
}

原因还是之前说的，线程睡眠期间，可能被其他线程通过 interrupt 方法打断提前醒来，它和 sleep、join、wait 这三个方法也一样密切；

注意:

sleep(0)不是不休眠，而是意味着让当前的线程立即放弃 CPU 资源，等待操作系统重新调度~

4.线程状态

Java 中一共有 6 种状态：

状态	含义	比喻
NEW	新建状态	安排了工作，还未开始
RUNNABLE	可运行状态	可工作的，又可以分成正在工作中和即将开始工作
BLOCKED	阻塞状态	会议室有人使用，只能排队等
WAITING	无限等待状态	等待老板通知，没有时间限制
TIMED_WAITING	有时间限制的等待状态	午休30分钟，到时间自动回来
TERMINATED	终止状态	工作完成了

不过要注意：RUNNABLE 不完全说是线程一定正在运行；Java 中把正在运行和等待 CPU 调度都归到 RUNNABLE 状态；提到这我们可以联系到之前关于操作系统的进程的两个状态：就绪状态和阻塞状态；

4.1 线程状态的转换

NEW 状态其实就是 new 了 Thread 对象，还没有 start()

TERMINATED 状态是线程已经做完了他该做的了，内核中的线程已经结束，但 Thread 对象还在；

RUNNABLE 状态就是刚刚提到的，可工作，有可分成正在工作中和即将开始工作；

TIMED_WAITTING 状态描述的是指定时间的阻塞，当等待时间结束后，线程会自动恢复到可运行状态，重新参与 CPU 调度；也就是：

有明确的等待时间
等待时间到了以后，线程不会一直停留
线程是否立即执行取决于 CPU 调度

WAITING 状态表示无限等待状态，例子有thread.join()，会一直等待，等到天荒地老；

BLOCKED 状态表示阻塞状态，在我们后面继续了解锁的时候会重点遇到；

NEW --> RUNNABLE --> TIMED_WAITING --> TERMINATED 转换如下：

public class Demo6 {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(thread.getState());
        thread.start();
        System.out.println(thread.getState());
        Thread.sleep(1000);
        System.out.println(thread.getState());
        thread.join();
        System.out.println(thread.getState());
    }
}

// 输出结构：
// NEW
// RUNNABLE
// TIMED_WAITING
// TERMINATED

对于上面的结果，解释 RUNNABLE、TIMED_WAITING：

在第二个输出状态时，主线程由于本身就在运行，在创建新的线程时会需要进过调度，所以通常运行上述代码都是 main 先跑到第二个状态打印，虽然此时 thread 线程已经启动，但还没进入 sleep(3000)，这也是为什么后面还需要 main 线程先 sleep(1000)的原因；

而 WAITING 状态就如下演示：

public class Demo6 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2");

        t2.start();
        t1.start();
    }
}

如果让 t2 自己打印自己的状态，就会受到执行时机影响，所以通常用外部工具观察线程状态，如下：

4.2 多线程带来的问题

直接先抛出一例子：

public class Demo7 {
    public static int count;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });


            t1.start();
            t2.start();
            t1.join();
            t2.join();
        System.out.println(count);
    }
}

写 join 的原因是避免 main 线程先执行完，所以应该先等到两个线程并入 main 线程后再执行打印

执行后会发现，count 结果是一个随机数，而且还是随机小于 100000 的数字；像这样导致结果和预期不符合的就属于 BUG，需要修复，这也是多线程并发执行容易引起的安全问题；

深入一下底层会发现：count++看似是一行代码，实际上对应到的是 3 个 CPU 指令

load：将内存中 count 的值加载到 CPU 寄存器
add：把寄存器中的内容 +1
save：把寄存器中的内容保存回内存上

并且现代计算机操作系统都是抢占式调度，意思就是：

即使一个进程（或线程）还没有执行完，操作系统也可以强制暂停它，把 CPU 分配给其他进程。

也就说明，上面的代码中执行这三个步骤会是随机的、不可预期的

左侧是我们所预期的，但实际会是右边这种，当然这样的情况有很多种；

右侧的操作过程描述：

假设当前内存上的值为 0；

t1 线程会先去读取内存的 0 并加载到当前寄存器上，也就是拷贝一份

随后 t2 也进行了同样的操作，但它先完成了 add 并最终存入内存中，此时内存的值为 1

但此时 t1 线程还是在之前加载的 0 上面进行操作运算，最后得到值为 1 并覆盖掉 t2 线程得到的 1 放在内存上

所以在上面的代码 5w 次循环过程中，中间会发生很多类似的操作，最终的值一定是 <=10w；

对于发生线程安全问题通常有以下：

操作系统对于线程的调度是随机的，也就是操作系统抢占式【根本原因】；
多个线程同时修改同一个变量；
修改操作，不是原子；
内存可见性问题；
指令重排序；

前两个问题我们已经讨论出，我们具体讨论 2 和 3 ，4 和 5 留到后面

问题 2：

对于多个线程修改同一变量，我们只能通过调整代码结构去规避一些线程不安全的代码，但这方案不够通用；Java 中有个东西，String 就是采取了“不可变”特性，确保线程安全；

String 实现“不可变”的效果是将内部的 char 数组设为 private（与 final 无关），导致无法访问，因此无法修改；

问题 3：

此处所说的原子性，就是指是数据库里事务提到的 ACID 中的原子性；

如果修改操作只是对应到一个 CPU 指令就可以认为是原子的，CPU 不会出现“一条指令执行一半”，但是如果对应到多个 CPU 指令就不是原子的，比如：++、--、+=、-=......；

原子性：

上面图片中被两个客户端并发拆开了，但【检查+扣减】应该作为一个整体，不可拆开；

所以在 Java 中解决线程安全问题最主要的方案就是加锁。

通过加锁操作，让不是原子的操作，打包成一个原子的操作；

计算机中的锁与生活中的锁，是同样的概念。互斥/拍他

这也就是下一节我们要讲的~

对了，对于上面的线程安全问题，我们这样解决：

public class Demo7 {
    public static int count;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                for (int i = 0; i < 50000; i++) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                for (int i = 0; i < 50000; i++) {
                    count++;
                }
            }
        });

            t1.start();
            t2.start();
            t1.join();
            t2.join();
        System.out.println(count);
    }
}

5.`synchronized` 关键字

Java 中的 synchronized本质就是加锁；但要注意，有时候也不是写了 synchronized 就 100%线程安全，这个需要具体代码具体分析~

拿一段代码举个例子：

public class Demo6 {
	public static void main(String[] args) {
		Object o1 = new Object();
		Object o2 = new Object();
		Thread t1 = new Thread(() -> {
			synchronized(o1) {
				try {
					Thread.sleep(100000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			synchronized(o2) {
				System.out.println("t1线程两个锁都获取到");
			}
		});
		Thread t2 = new Thread(() -> {
			synchronized(o1) {
				try {
					Thread.sleep(100000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			synchronized(o2) {
				System.out.println("t2线程两个锁都获取到");
			}
		});

		t1.start();
		t2.start();
	}
}

当这段代码开始运行后，可以调用 jconsole 去查看一下线程状态；

此时可以看到 t2 线程处于 BLOCKED 状态，也就是我们之前所说的阻塞状态；这里阻塞的原因就是 t1 线程上锁 o1 之后一直 sleep。此时线程 t2 想同步运行，但是锁在 t1 手上，所以 t2 第一段代码就执行不了，必须等到 t1 线程释放锁之后 t2 才能继续运行。这就是前面提到的 BLOCKED 阻塞状态；

5.1 `synchronized` 的特性

5.1.1 互斥性

我们首先需要知道锁是什么，在生活中好很理解：

对，这就是锁，因为厕所只能容纳一人，当他进去时就得上锁，出来时就得解锁；在代码中就这样理解，一个线程先上了锁，其他线程只能等待这个线程释放，这也就是互斥的含义；

synchronized中文名叫：同步锁；在 JVM 层面对应的是：Monitor Lock 监视器锁

也就是说每一个 Java 对象都可以关联一个监视器；

它在代码中的流程：

Thread t1 = new Thread(() -> {
    synchronized (locker) {
        for (int i = 0; i < 50000; i++) {
            count++;
        }
    }
});

尝试获取对象对应的锁 -> 获取成功 -> 执行代码 -> 释放锁

如果锁已经被其他线程占用，那么线程就会等待，直到其他线程释放锁，这中间还会存在锁竞争；

至于为什么需要互斥，就拿之前的火车票问题来说，只剩一张票了，两个客户端申请访问时必须只能一个一个访问，而不能并发访问；

以上就是互斥的必要性；

5.1.2 可重入性

synchronized 第二个特点就是：可重入性

引入可重入的概念目的其实就是为了解决死锁问题，那么什么是死锁问题？

假如下方的代码是不可重入的，那么当已经进入锁住状态的方法一调用方法二时，由于锁已被用且还未释放，因此方法二无法加锁且无法进入。最后就导致阻塞等待，两个方法都无法继续往下执行；

可重入性概念刚理解可能不太好明白，意思是：

一个线程已经拥有某把锁之后，可以再次进入有同一把锁保护的代码；

比如：

public class Demo {
    synchronized public void method1(){
        method2();
    }

    synchronized public void method2(){
        System.out.println("执行method2");
    }
}

当前线程调用method1()方法，线程 A 进入method1() -> 获得对象锁 -> 调用method2() -> method2()也是 synchronized；

又或者像是这样：

synchronized (counter) {		// 1.此处开始锁住
    synchronized (counter) {		// 2.直接放行
        synchronized (counter) {		// 3.直接放行
            counter.add();
        }	// 3->2 退出第三层
    }	// 2->1 退出第二层
}	// 1->0 退出第一层

至于 JVM 如何知道哪个“}”是真正要解锁的那个呢？

JVM 执行的是 .class 字节码，不是 Java 源代码里的 {}。
synchronized 代码块之所以能正确加锁、解锁，是因为编译器会把它编译成专门的字节码指令，而不是 JVM 运行时去判断“这个 } 属于谁”。

如果synchronized不可重入，这里就会发生线程 A 访问method2()时一直等待释放锁，因此会永远等待，也就是发生死锁；但由于可重入性的原因，因此此处不会发生阻塞；

5.1.3 死锁问题（重）

关于死锁问题，已经在上面初步解释过了，就再具体说一遍：

死锁就是

家钥匙锁车里了，车钥匙锁家里了

很好理解吧~

构成死锁主要有这四个必要条件（重点）

1.锁是互斥的。一个线程拿到锁之后，另一个线程再尝试获取锁，必须要阻塞等待；（锁的基本性质）

2.锁是不可抢占的。线程 1 拿到锁，线程 2 也尝试获取这个锁，线程 2 必须阻塞等待，而不是线程 2 直接把锁抢过来；（锁的基本特性）

3.请求和保持。一个线程拿到锁 1 之后，不释放锁 1 的前提下，获取锁 2

4.循环等待。多个线程、多把锁之间的等待过程构成“循环”

以上 1、2 点至少 Java 的 synchronized 是遵守这两点，

破坏掉上述的 3 或 4 任何一个条件都能够打破死锁；

（打破 3：把嵌套的锁改为并列的锁）

（打破 4：加锁的顺序做出约定）

在代码中构成死锁问题通常有下面三种情况：

情况一：两个线程、两把锁交叉等待

Thread t1 = new Thread(() -> {
    synchronized (lockA) {
        synchronized (lockB) {
        }
    }
});

Thread t2 = new Thread(() -> {
    synchronized (lockB) {
        synchronized (lockA) {
        }
    }
});

这是 Java 中典型的死锁，如果执行成这样

t1：拿到 A

t2：拿到 B

t1：等待 B

t2：等待 A

这就死锁了，这也可以叫所顺序不一致导致的死锁；注意我说的是如果，因为线程 t1 与 t2 是并发的，有可能 t1 和 t2 一样快，有可能 t1 比 t2 快...这样的结果是不确定的。

针对情况一就是同一加锁顺序，也就是说如果：必须同时获取多把锁，所有代码必须按照固定顺序获取。

情况二：哲学家就餐问题（多线程、多资源形成环形等待）

假设有 5 个哲学家，每个人面前都有一根筷子，总共 5 根，每个哲学家必须左筷子+右筷子才能吃饭。

换成代码就是这样理解：5 个人就相当于 5 个线程、5 根筷子就相当于 5 把锁，每个线程只需要拿到其中两根筷子即可~

大部分情况下上述模型可以很好的运转，只是在一些极端情况下会造成死锁，譬如：

同一时刻，大家都想吃面条，同时拿起左手的筷子

虽然上述情况的概率很小，但是只要基数足够大，任何小概率事件都是大事件；

针对情况二给出两种解决方法：

方法一：规定筷子获取顺序，让所有哲学家统一遵守“先拿编号小的，再拿编号大的”。

方法二：最多允许 4 个哲学家同时拿筷子，此时至少有一个哲学家有机会凑齐两根筷子，也就是限制同时参与资源竞争的线程数量。

5.2 `synchronized`使用示例

synchronized 本质上要修改指定对象的“对象头”。从使用角度看，synchronized 也是必要搭配一个具体的对象来使用；

5.2.1 `synchronized` 修饰代码块

这里要明确指定锁哪个对象。

格式：

synchronized(锁对象){
    // 需要保证线程安全的代码
}

synchronized(lock){
    count++;
}

前面已经解释过，线程进入代码块 -> 尝试获取 lock 对象的锁 -> 获取成功 -> 执行 count++ -> 释放 lock 锁

如果此时另外一个线程也执行synchronized(lock)，那么因为他们使用的是同一个 lock 所以只能排队。

至于为什么一定要是同一个对象，是因为两个线程，针对同一个对象加锁，才会产生互斥效果；如果是不同的锁对象，此时不会有互斥效果，线程安全问题就没有得到改变...

这里提到的锁对象，关于这个对象的类型是什么并不重要（在 Java 中任何一个对象都可以用作'锁'），重要的是是否有多个线程尝试针对这同一个对象加锁（是否在竞争同一个锁）

再拿前面的多线程 50000 次循环并发举例：

Thread t1 = new Thread(() -> {
    for (int i = 0; i < 50000; i++) {
        synchronized (locker) {    
            count++;
        }
    }
});

Thread t1 = new Thread(() -> {
    synchronized (locker) {
        for (int i = 0; i < 50000; i++) {
            count++;
        }
    }
});

以上两段代码看似运行结果相同，但实际运行过程差别很大，特别是在效率上；

这是代码一的运行过程：

这是代码二的运行过程：

至于为什么 Java 中不使用 lock + unlock 函数的方式的话，这个就有点意思了：

当然其实 Java 中也是有 lock/unlock 风格的锁，但一般很少用，因为...

Lock locker  = new Locker();
public void func() {
locker.lock();
// something code
locker.unlock();

这样的写法其实会容易忘记把 unlock 补上，就会导致其他线程死锁；

你要是说“只要我写了 lock，就会立即加上 unlock~”，那你纯纯就是大猪蹄子行为；

就像是你给女朋友保证，这辈子我只爱你一个，永远不会变心~

再来个例子：

void func() {
    lock();

    if (cond) {
        unlock();
        return;
    }

    if (cond2) {
        unlock();
        return;
    }
    func2();
    
    unlock();
}

其中 func2()又是调用：

void func2() {
    func3();
}

void func3() {
    func4();
}

void func4() {
    throw new Exception();
}

此时，代码中抛出异常，那么也有可能使 unlock 执行不到~

所以 Java 中采取 synchronized 就能保证，只要出了“}”一定能释放锁，无论因为 return 还是因为异常里，也无论里面调用了哪些代码，都是可以确保 unlock 操作执行到的；

5.2.2 `synchronized` 修饰普通方法

synchronized 还可以直接修饰方法：

public class Counter {
    private int count;
    public synchronized void increment(){
        count++;
    }
}

其实像是 StringBuffer、Vector 这些对象，方法上就是带有 synchronized：

所以会说这些对象会线程安全；

不过如果 synchronized 修饰的是静态方法的话，就相当于针对类对象加锁（从反射可以了解）；

synchronized 修饰普通实例方法：锁的是 this
synchronized 修饰静态方法：锁的是当前类对应的 Class 对象，也就是 类名.class

例如：

public class Counter {
    private int count;
    public synchronized void increment(){
        count++;
    }
}

此处：

public synchronized void increment()

等价于：

public void increment(){
    synchronized(this){
        count++;
    }
}

也就是说：

普通 synchronized 方法锁住的是当前对象。

在实际中通常会是这样：

Counter counter = new Counter();

然后会这样去调用counter.increment()，实际上锁的是 counter 对象，也就是 this==counter

然后多个线程：

Thread t1 = new Thread(() -> {
    counter.increment();
});

Thread t2 = new Thread(() -> {
    counter.increment();
});

此时线程 A：

获取 counter 对象锁

执行 increment

线程 B：

等待 counter 对象锁

而如果是：

Counter counter1 = new Counter();
Counter counter2 = new Counter();

这样的话两个线程分别尝试获取两把不同的锁，就不会产生竞争；

写法	锁对象
`synchronized(lock){}`	lock对象
`public synchronized void method(){}`	当前对象 this
`public synchronized static void method(){}`	当前类 Class 对象

当然啦你也可以这样去理解：

代码块：

synchronized(lock)就像指定某个房间上锁；锁是指 lock 房间

普通方法：

synchronized method就像是给当前员工办公室上锁；锁是指当前员工对象

静态方法：

static synchronized method就是给整个公司总部上锁；这里的锁就是指整个 Class

锁虽好，但不可贪~

synchronized(lock){
    // 很多代码
}

可能会多人会犯这样一个错误，虽然线程安全，但是效率可能就不太好。因为真正需要保护的可能就只有count++，就像我前面举过的例子：synchronized (locker)放在 for 循环内与 for 循环外的对比。当你锁住的代码越多，线程等待的时间就越长，并发能力就越低。所以在实际开发中：

synchronized 的范围应该尽量控制，只保护真正需要同步的数据~

6.`volatile` 关键字

在前面讲线程安全问题的时候，提到过几个容易引发问题的原因：

原子性、内存可见性以及指令重排序

其中原子性的问题就在上面的synchronized已经大概了解如何处理了，但还有一个一直被搁置的问题：

一个线程修改了变量之后，为什么另一个线程有时候看不到？

当然前面其实遇到过一次，在中断线程的时候写过：public volatile boolean isQuit = false;

当时只是说“加上 volatile 后，一个线程修改 isQuit，另外一个线程能够及时看到。”

那现在就来正式解释一下~

6.1 内存可见性

先来举个例子：

假设老师布置作业后，让课代表把作业内容卸载教室后面的黑板上：“今日作业：完成练习册第 10 页”

这个黑板相当于全班同学都能看到的公共信息区域。

但是张三觉得每次回头看黑板太麻烦，于是第一次看到作业后，就把内容记在自己的草稿纸上：“今日作业：完成练习册第 10 页”

李四也记了一份自己的。后来老师临时修改了作业，于是让课代表把后黑板改成：“今日作业：完成练习册第 10～12 页”

此时，黑板上的内容已经更新了。

但问题来了：

如果张三之后一直只看自己之前记下来的草稿纸，而没有重新去看后黑板，他看到的仍然只会是“今日作业：完成练习册第 10 页”

张三并不知道公共信息已经发生了变化。这就很像多线程中的内存可见性问题：

一个线程已经修改了共享变量，但是另一个线程没有及时看到这个变量的最新值。

对于上述这样的情况，你可以抽象理解为“主内存”和“线程工作内存”模型

代码示例：

public static int flag = 0;
public static void main(String[] args) {

    Thread t1 = new Thread(() -> {
        while (flag == 0) {
            
        }
        System.out.println("t1 线程结束");
    });

    Thread t2 = new Thread(() -> {
        // 针对 flag 进行修改
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入 flag 的值：");
        flag = scanner.nextInt();
    });
    t1.start();
    t2.start();
}

这段代码当运行起来后，输入任何数字后按单线程的思想应该不进入循环而停下来，但事实并非

显然这是一个 BUG（线程安全问题）

一个进程读取，一个进程修改，修改线程的值，并没有被读线程读到。这也就是要说的“内存可见性问题”

其实上面的问题是，每个线程在读取主内存的时候都会先拷贝一份放到自己的工作内存中，如果要修改就会先在自己的工作内存中完成修改，随后就将修改好的值放入主内存中。但是由于 t1 只是进行读操作，它只会去读相对较近的内存（也就是 t1 的工作内存）

线程在运行过程中，并不一定每一次使用变量都重新读取共享区域中的最新结果，而可能使用自己工作内存中的值。我所说的“工作内存”可以先抽象理解为 CPU 寄存器、缓存有关的区域，因为访问这些位置速度更快，但也可能产生数据不一致。

产生这样的原因：

研究 JDK 的大佬们就希望通过让编译器 & JVM 对程序员写的代码，自动的进行优化

本来写的代码是进行 xxxxx，编译器 / JVM 会在你原有逻辑不变的前提下，对你的代码进行调整，是程序效率更高

JVM 和 CPU 为了提高执行效率，可能会对变量读取、缓存以及指令执行进行优化。在单线程环境中，这些优化不能改变程序原有语义；但在多线程环境下，如果程序没有通过 volatile、synchronized 等机制建立正确的线程间同步关系，就可能出现一个线程无法及时观察到另一个线程修改结果的情况~

上面的过程细化理解就是：

while (flag == 0) {

}

load 为读内存操作，cmp 是 CPU 寄存器操作；load 的时间开销可能是 cmp 的几千倍

其中的flag == 0为 cmp 运算操作，而比较操作又细化为 load、cmp（加载、运算）短时间内这个循环会进行很多次，执行过程中 JVM 感知到 load 反复执行的结果好像都是一样的。JVM 就会想：执行这么多次读 flag 操作发现值都为 0，既然结果一样，为什么还要反复执行这么多次呢~

于是就把读内存的操作优化成读寄存器（把内存的值读到寄存器了，后续再 load 就不再重新读内存）

此后，等到用户开始输入新的值真正修改 flag 时，t1 线程就感知不到了；当然如果引入 sleep 去等用户输入的话，那样效率又太低了；

于是就引入了 volatile 关键字，通过这个关键字来修饰某个变量，此时编译器这对这个变量的读取操作就不会被优化成寄存器了

public volatile static int flag = 0;

volatile解决了内存可见性问题·，但不是解决原子性问题；

6.2 JMM Java 内存模型

前面我们提到的“主内存”和“线程工作内存”模型其实就是 JMM，其含义你可以理解为：

Java 用来规定“多个线程之间如和读写共享变量，以及这些读写什么时候对线程可见”的一套规则。

在 Java 官方文档的描述中：

每个线程，有一个自己的“工作内存”，同时这些线程共享同一个“主内存”，当一个线程循环进行上述读取变量操作的时候，就会把主内存中的数据拷贝到该线程的工作内存中。后续另一个线程修改，也是先修改自己的工作内存，拷贝到主内存里。由于第一个线程仍然在读自己的工作内存，因此刚知不道主内存的变化。

这与我们前面讲到的把读内存的操作，优化成读寄存器操作是一样的意思。

以及上面所说的“工作内存”（work memory）就是指与 CPU 寄存器、缓存等相关的区域；

然后明确synchronized 能够保证原子性，而 volatile 保证的是内存可见性。

好了，以上就是关于 volatile 的内容...

7.`wait` 和 `notify`

前面学习多线程的时候，一直在强调一件事：

多个线程之间的执行顺序通常是不好控制的

谁先拿到 CPU、谁先执行，本身就带有一定随机性，但实际开发里肯定是不能“各干各的”。线程里一定也是存在“ 你先做完，我再继续”的协作关系。

所以 Java 就因此提供了：wait()、notify()、notifyAll()来实现线程之间的等待和唤醒；注意wait()、notify()、notifyAll()都是 Object 类的方法，所以 Java 中的任意对象都提供了 wait()和 notify()。

wait()/wait(long timeout)：让当前线程进入等待状态；

notify()/notifyAll()：唤醒在当前对象上等待的线程；

7.1 `wait()` 方法

从上面我们知道了 wait()方法的作用是：让当线程先别干了，进入等待；

比如：

Object lock = new Object();

Thread t1 = new Thread(() -> {
	synchronized (lock) {
		System.out.println("开始等待");
		lock.wait();
		System.out.println("等待结束");
	}
}

当执行到lock.wait()时候线程就会停下来，至于后面要打印的内容就不会立即执行了；

此时当前线程主要会经历这样三个过程：

当前线程进入等待状态 -> 释放当前持有的 lock 锁 -> 以后被唤醒时，再重新尝试获取 lock 锁

其中的释放锁这一步很关键；

那至于为什么要释放锁呢，继续举个例子：

（财务室在synchronized (lock) {}中）

假设李四进入财务室，此时李四手里拿着钥匙，然后李四发现：“我现在还缺一份材料，得等王五送过来。”

于是此时就调用 lock.wait()，然后王五想进财务室送材料：“钥匙还在李四手里，我进不去”

那么李四：“材料不来我就不继续 ”，接着王五：“你不放钥匙我就送不进去”

这个时候两个人就直接卡住了，所以所以 wait()必须要释放锁让王五进来。

当然啦，如果你wait()不写在 synchronized 中就会抛异常~

而wait()要等到什么时候呢？

wait()默认是一直等，等到被唤醒，所以它对应的状态通常就是 WAITTING 状态，但wait()是提供带参数的，时间参数单位是毫秒。然后关于wait(0)，类似于sleep(0)，不是等待 0 毫秒，而是无限期等待，直到被 notify()、notifyAll() 唤醒，或者线程被中断。

ok 我们上面也说了“notify()、notifyAll() 唤醒，或者线程被中断”通常就是这三种方式能把wait()唤醒。其中关于线程被中断这点，是指另外一个线程直接 thread.interrupt()，那么等待的线程会通过InterruptedException收到通知，与前面的 sleep()、join()是同一类思路；

但是wait()会释放所，而 sleep()不会释放锁~

注意被 notify 唤醒，不代表线程马上执行。因为线程醒来以后，会先从：

WAITING 状态出来 -> 重新去竞争那把 lock -> 拿到所以后 -> 才能继续执行 wait() 后面的代码

被唤醒以后，线程并不能马上继续执行，而是需要重新参与这把锁的竞争。什么时候真正拿到锁，仍然由线程调度决定。

记得要求 synchronized的锁对象必须和wait的对象是同一个；

7.2 `notify()`方法

然后接着刚才说的，李四进入到财务室然后睡着了，王五已经把材料放在桌子上，这个时候问题随之而来：

李四都已经睡着了，谁来告诉他“别睡了，可以继续干活了”？

这个时候就需要 notify()，而notify()的作用确实就是唤醒一个正在当前对象上**wait()**的线程；

当然了，既然wait()要配上synchronized，那notify()也是必须得配上synchronized使用了。因为他们都是围绕着同一个对象对应的monitor锁进行协调。所以这边必须对应一把锁。

对了，务必还要确保先wait()，后 notify()。相反如果先notify()那么wait()也就无法唤醒。

比如：

public class Demo {
    public static void main(String[] args)
            throws InterruptedException {

        Object lock = new Object();
        Thread t1 = new Thread(() -> {=
            synchronized (lock) {
                System.out.println("李四：材料没来，我先等等");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("李四：材料到了，继续工作");
            }
        }, "李四");

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("王五：材料送到了");
                lock.notify();
                System.out.println("王五：我已经通知李四了");
            }
        }, "王五");

        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}

以上代码的执行过程就如下方：

注意上面所描述到的“李四重新竞争 lock”，李四的线程并不是接着马上就向后运行，而是重新与其他线程相互竞争；当然，也不是 notify 唤醒后 wait 马上就进入工作的...

那有个问题，假如有多个线程都在 wait 呢？

notify 还是规定只能唤醒一个，但是具体叫醒谁，并没有固定保证。但是如果想唤醒全部 wait 就可以用到 notifyAll；可以这样理解：notify 就是“老师面对三个趴桌子睡觉的人喊：起来一个帮我搬书！”，那么起来的是谁不一定；而 notifyAll 就是老师对这三个人都点名，让他们都起来去搬书。

然后在这里就可以区分 WAITING 和 BLOCKED了，假设李四调用了 lock.wait()，那么李四就是 WAITING（因为他主动释放锁，并通知被人等待），此时王五拿着 lock，赵六也想拿到锁但进不去，那赵六就是 BLOCKED。

7.3 `notifyAll()` 方法

（本来不想写 7.3，但是想了想还是需要补充一下哈）

前面举的这个例子，“老师面对三个趴桌子睡觉的人”如果想都叫醒就是用 notifyAll，但是调用了lock.notifyAll()也并不是三个线程马上一起执行后续代码，只是三个线程被唤醒，但还是需要重新竞争原来的那把锁。

7.4 `wait()` 和 `sleep()`的区别

到这里，我们已经很清晰的知道了 wait 和 sleep 完全没有可比性，毕竟一个是用于线程之间的通信，一个是让线程阻塞一段时间；唯一相同的就是都可以让线程放弃执行一段时间.

但还是需要总结下：

wait 需要搭配 synchronized 使用，而 sleep 不需要；
wait 是 Object 的方法，而 sleep 是 Thread 的静态方法；

我让 GPT 综合给出了一个表格，内容如下：

对比	`wait()`	`sleep()`
所属类	`Object`	`Thread`
主要作用	线程之间等待、协作	让当前线程休眠
是否释放锁	释放锁	不释放锁
是否必须在 `synchronized` 中	是	否
无参时典型状态	`WAITING`	`sleep` 必须指定时间
指定时间时	`TIMED_WAITING`	`TIMED_WAITING`
如何恢复	`notify/notifyAll`、超时、中断等	时间到或被中断

进程基础：资源管理、调度与上下文切换

Tue, 01 Sep 2026 00:00:00 GMT

你有没有想过，当我们双击一个程序时，操作系统到底做了什么？

以 Windows 环境为例，磁盘中的.exe（可执行程序）文件本质上是一个静态程序，里面包含着程序运行所需的机器指令、数据，本身不会执行。只有当操作系统把程序加载到内存，为它分配运行需要的资源，并且让 CPU 执行其中的指令后，这个静态的可执行文件才真正变成一个正在运行的程序。

这个运行的程序实例，就是我想说的进程（Process）

1. 程序与进程

1.1 程序

点击键盘 CTRL + SHIFT + ESC 就会弹出下面这样一个界面，也就是任务管理器，正常会运行上百个进程。了解到这里，就应该想问出进程到底是什么？为什么操作系统需要进程？一个磁盘中的程序，又是如何变成一个正在运行的进程的？

首先得知道：程序不等于进程

程序 = 存放在磁盘上的一组指令和数据

就比如一个这样存放在你的电脑硬盘里的文件：

C:\Program Files\Google\Chrome\Application\chrome.exe

只要chrome.exe还没有启动，他就只是磁盘上的一个程序。

主要因为一下几点：

不占 CPU 执行时间；
没有正在使用的寄存器；
没有自己的运行状态；
没有变化的内存数据；

综上，所以说程序是静态的。

1.2 进程

当我们双击chrome.exe后，事情就不一样了，Windows 操作系统就会开始为它准备运行环境。

补充一下操作系统（Operating System, OS）扮演的角色：

操作系统就是计算机里的“总管 + 调度中心 + 翻译层”，可以理解为酒店里的经理吧或者说公司里的运营官，嗯对；操作系统是介于硬件和软件之间，负责统一管理真正干活的 CPU、内存、硬盘、显卡、网卡...这些硬件，对没错就是牛马们。

这时候呢，操作系统就有以下动作：

此时，它就不再只是一个磁盘中的文件里，而是程序的一次运行实例；

根据上面的描述，我总结出一句：

程序描述“要做什么”，进程描述“程序现在运行到什么状态”

2. 一个进程中有什么

不知道会不会有个疑惑觉得为什么会需要“进程”这个东西？

就比如我当前电脑正在同时运行这些软件：

CPU、内存、磁盘这些资源都很有限，操作系统就得知道哪些程序正在运行、占用了多少内存、谁正在等待 I/O、谁已经准备好运行，以及接下来应该让谁获得 CPU。

所以对操作系统来说，它就会把每一个进程抽象为用一个或多个结构体来描述和管理。

知道上面结果后就会容易想，一个进程中都有什么？或者一个进程运行本身需要哪些东西？

我给出一个简单的模型：

虚拟地址空间本身是一个比较大的话题，涉及代码段、数据段、堆、栈、内存映射...一些内容。这里暂时把它理解为：操作系统为每个进程提供的一套独立的虚拟内存视图，具体的内存管理机制后面有机会再展开~😁

上图其中运行所需的系统资源也包含里很多，比如 Chrome 运行起来后，就会需要内存、网络连接 Socket、文件描述符、权限信息、若干线程。到这里我们能知道一个进程运行起来，需要代码、数据、内存以及各种操作系统资源。

但是，接着我再抛出一个问题：

“操作系统怎么知道这些东西属于哪一个进程？”

3. PCB：操作系统如何管理进程

上面已经说过“操作系统会把每一个进程抽象为用一个或多个结构体来描述和管理”。但其实，在操作系统原理中，通常把描述和管理一个进程所需要的核心信息统称为 PCB（Process Control Block，进程控制块），它会再把多个进程组织起来。

你可以脑补为这样：

struct PCB {
    int pid;              // 进程编号
    int state;            // 运行、就绪、阻塞……
    registers regs;       // CPU寄存器现场
    memory_info memory;   // 内存信息
    file_info files;      // 打开的文件
    priority prio;        // 优先级
    ...
};

操作系统里就会有很多这样的“进程档案”，但真正的进程包含的东西比这个结构体多得多，我让 ai 给了一份内容：

可以把 PCB 理解为“进程的档案袋”，然后这样一整套运行的程序信息，就被操作系统抽象为一个“进程”。

我整理为一段话就是：

进程是正在运行的程序实例，而 PCB 是操作系统用来描述和管理这个进程的“档案”。

PCB 中的一些关键点：

pid（进程的身份标识符）、内存管理信息（记录或指向进程的地址空间、页表等内存管理结构）、文件描述符表（记录打开了哪些文件/资源的表，这是在 Linux 中用叫法，Windows 常称句柄）、CPU 寄存器（保存进程当前正在使用的数据、地址和运算状态）......

4. 进程是如何被 CPU 运行的

前面说过，PCB 中会记录一个进程当前的状态。但一个进程从创建到结束，并不会一直占着 CPU 运行……实际上，在现如今的操作系统中，同一时间会存在上百甚至上千个进程，而 CPU 的核心数远没有那么多，就拿我的电脑举例：

20 个内核，28 个逻辑处理器你可以理解为：

20 个牛马，其中一些牛马有两张工作台，因此公司排班中能看到 28 个工作位，也就是在干 28 个人的活

也就是说：

想运行的进程很多，但真正能够同时在 CPU 上执行的进程数量是有限的。

所以操作系统就得解决两个问题：

1.一个进程当前到底处于什么状态？

2.CPU 下一步该运行到哪个进程？

这两个问题就涉及到刚刚提到过一点的状态、调度和上下文切换了；

4.1 进程的生命周期与状态

同样先给出一个简化模型，有点模糊哈将就将就：

以上是最常见的几个状态，最典型的两个就是就绪状态（Ready）和 阻塞状态（Blocked/Waiting）

就绪状态（Ready）

什么都准备好了，可以理解为随叫随到

运行状态（Running）

当 CPU 真正开始执行这个进程中的指令时，进程就进入运行状态。

阻塞状态（Blocked/Waiting）

进程当前不适合到 cpu 上执行。

不过在操作系统中，一般不区分就绪和执行，默认都是就绪。

举个例子：

假设 Chrome 发起一次网络请求：

在等待服务器返回的时候，即使一直把 CPU 给 Chrome，那它也没有办法继续执行。所以操作系统会让它进入阻塞状态，把 CPU 让给其他可以运行的进程。

这里的阻塞就可以理解为：CPU 给我也没用，我正在等别的东西。

等到网络数据回来后，这个进程就重新具备运行条件，于是：

阻塞状态->等待事件完成->就绪状态

注意，它通常不是直接变成运行状态，而是先进入就绪状态。

因为即使它已经准备好了，CPU 可能仍然正在执行其他进程。

至于什么时候再次获得 CPU，还需要由操作系统决定。

以上过程就是所说的 CPU 进程调度。

4.2 CPU 如何选择下一个进程

这一段的话，我就不是那么了解了，这部分就是借助 ai 理解了哈，如果有不对请纠正；

假设系统中同时存在这些进程：

Chrome、IDEA、微信、MySQL、AppleMusic

并且以上都处于就绪状态，但当前只有一个 CPU 核心可以使用，此时该怎么办呢？

当然不能放肆给大家一起抢了，不然你的电脑就崩溃了哈哈

所以需要到操作系统中的专门负责这一版块的组件了，称之为调度器（Scheduler）。

调度器可以简单理解为：

从所有可以运行的进程中，选择一个进程获得 CPU。

刚刚的假设呢，至于调度器要选谁，当然也不是随机的。操作系统还是会根据一些因素来决策，就比如：进程优先级、已经等待的时间、之前运行的时间、进程类型、系统调度策略...

关于这里我有一个例子有点意思：

假设我是一个妹子~我长得好看又有才华，就有很多人追我~

有以下三个

A：有钱

B：帅

C：会添

然后我同时和三个男朋友一起谈~

为了让这三个人不能刚知道对方存在

我就规划好，周一二和 A 约会；周三四和 B 约会；周五六和 C 约会；周日留给自己；默认每个小哥哥都是“随叫随到”

当前就是分时复用，并发执行

定制时间表并且按照时间表来执行，就是进程调度的过程~

当然这个例子只是用来理解“有限资源被多个任务轮流使用”，真正的 CPU 调度并没有一张提前写死的约会时间表，而是会根据任务状态、优先级和调度策略动态决定。

以上就涉及到 CPU 的一些调度算法了，关于调度算法这点我就不是很会啦~

不过只需要知道 CPU 不是某个进程永久占有的资源，而是由操作系统不断在多个可运行任务之间进行分配。

哦对了，这里还需要涉及一个概念——时间片（Time Slice / Quantum）。

又假如哈：

操作系统让 Chrome 得到了 CPU，Chrome 当然也不会一直运行下去，通常是毫秒级的一小段 CPU 时间，具体长度取决于操作系统和调度策略。

这段允许它连续使用 CPU 的时间，就可以理解为一个时间片。当时间片结束后，操作系统可能就会暂停 Chrome，然后让另一个进程运行，操作系统就是在不断的这样切换切换，让我们一直以为所有程序都在同时运行。当然，现代 CPU 通常有挺多个核心，所以也的确可以有多个任务在不同 CPU 核心上真正同时执行。

不过你想，一个 CPU 的常规为 1 秒计算 21 亿次，而且还不是睿频，所以可以想象到 CPU 切换的速度。

然后呢，在同一时刻真正同时执行多个任务的情况，通常称为并行；而在单个 CPU 核心上快速交替执行多个任务，更接近于并发。

上述提到的不断来回切换这里就产生了一个问题，就是 CPU 怎么知道刚刚的程序执行到哪个步骤？CPU 的寄存器里的数据怎么办？显然，操作系统不能简单地“停下来就不管了”。

所以这就需要进行上下文切换。

4.3 进程切换与上下文切换

CPU 在执行一个进程时，会存在大量和当前执行状态有关的信息。

就比如有：程序计数器、CPU 寄存器、栈指针、部分处理器状态；

其中程序计数器（Program Counter，PC）非常重要，你可以把它理解为：CPU 下一条应该执行哪条指令。

就比如 Chrome 当前执行到：

指令 100
指令 101
指令 102  ← 当前执行位置
指令 103
指令 104

这个时候 CPU 突然切换到正在做笔记的语雀，那么此时执行到了 102 的这个位置的信息就必须保存下来。所以在切换之前，操作系统会先保存当前进程的执行现场，然后被保存的这些运行信息，就是进程的“上下文”的一部分了。

我还有个例子哈，就是刚刚的三个小哥哥~

我和 A 约会的时候，

A：下个月，你陪我去一趟三亚，你提前准备准备~

我：好的好的~

B：下个月，我的妈妈要过生日，想让你陪我去挑选一下礼物，提前准备准备~

我：好的好的~

这个时候，当然不能出现我拿着一个金手镯子面对 A 问我准备如何；我当然也不能准备了一套性感的泳衣面对 B 问我准备如何啦。所以我就得在和 ABC 约会·的时候，每次结束都拿一个小本本把当天一些重要的事情记录下来，下次再和这个人约会时，就先翻一下小本子，回忆一下上次的进展。

这个例子还是很生动吧，然后这整个过程包括 Chrome 那个例子就是：上下文切换（Context Switch）。

这也就是为什么前面 PCB 中要保存：CPU 寄存器信息、程序计数器、进程状态、调度信息这些内容的原因了。

当然了，上下文切换也并不是免费的，毕竟切换这个过程还是有些性能开销的，就比如像是保存寄存器、恢复寄存器、切换相关内存管理信息、更新进程状态、执行调度逻辑...

不过到这里还有一个新问题，之前我们一直把一个进程看成是一个相对独立的运行单位，每个进程都有自己的地址空间和系统资源。

但是现实中的程序并不是完全互不相干的，就比如：

浏览器进程要和渲染进程交换数据

客户端要和服务器通信

一个程序产生的数据可能要交给另一个程序处理

我们又说不同进程之间默认相互隔离，那么一个进程要如何把数据交给另一个进程，就得需要继续了解进程之间如何交互协作了。

5. 进程之间如何协作

现在看，前面一直把一个进程看作一个相对独立的运行单位。

每个进程都有自己的运行状态、虚拟地址空间以及各种系统资源，这样的设计其实就是为了像是：

如果其中一个进程出现了问题，通常不会直接把另一个进程的内存也一起搞坏，抽象理解为：

就像是大家各住各的房子，正常情况下不能直接翻墙去别人家拿东西。这样的隔离可以提高可以提高系统的安全性和稳定性，但问题也随之出现。

我们上面提到过，现实中的程序并不是完全互不相干的，就比如浏览器：

当前 Chorme 一个进程需要多个进程一起完成浏览器工作

当用户在地址栏输入一个网址，那么这个信息可能还需要交给其他进程处理，就比如：渲染进程可能需要知道页面内容是什么、GPU 相关进程可能需要知道有什么图形任务需要处理...

这些进程之间如果不能交流，显然用户就达不到他想要的结果。所以操作系统必须在“进程隔离”的基础上，再提供一些受控制的数据交换方式。这些机制统称为：进程间通信（Inter-Process Communication，IPC）。

这些机制可以倾向于这么理解：

就是你们这些进程不能随便进对方家，但是我可以给你们提供电话、快递柜、公共会议室之类的方式进行交流。

具体来说，操作系统提供了管道、共享内存、消息队列、Socket 等多种进程间通信方式，也就是前面说的 IPC。每一种方式具体怎么实现，还有不少内容，这里暂时先不展开。（其实是我不太懂了😁）

到这里其实已经能发现，进程的一个重要特点就是彼此之间相对独立。

独立当然有好处，一个进程出了问题不容易直接影响另一个进程，但这种独立也意味着：如果两个进程想共享数据，就得借助 IPC；创建和管理多个进程本身也需要一定的系统资源。

那么问题又来了。

假设现在不是两个独立程序需要协作，而是同一个程序内部需要同时做很多事情呢？

比如一个音乐软件可能需要同时：

播放音乐

响应鼠标操作

更新界面

读取本地文件

请求网络数据

如果每做一件事情都创建一个新的进程，显然有点太“重量级”了。

有没有一种比进程更加轻量，同时又能让一个程序内部存在多个执行任务的东西？

这就要继续说到——线程（Thread）。

6. 为什么有了进程还需要线程

从前面已经知道，一个进程可以看作一个正在运行的程序实例，它有自己的地址空间、系统资源，也可以被操作系统独立管理。但是，如果同一个程序内部，需要同时做很多事情怎么办？

比如一个音乐软件运行时，可能需要同时：

播放音乐

响应鼠标点击

更新界面

读取文件

请求网络数据

当然，我们可以给每一个任务都创建一个新的进程，比如：

播放音乐进程

界面更新进程

网络请求进程

文件读取进程

但如果每个软件都这样需要这么多进程的话，实在是太“重”了。因为每创建一个新的进程，操作系统都要给它准备相对独立的地址空间以及各种管理信息；另外不同进程之间如果需要交换数据，还要借助前面提到的 IPC。

如果这些任务本来就同属一个程序，还每做一件事情就创建一个新进程，显然不太划算。

所以就出现了一个比进程更加轻量的执行单位：线程（Thread）

注意：进程是操作系统资源分配的基本单位；线程是 CPU 上调度执行的基本单位；

相比于进程：进程更像是一个程序的运行环境，而线程则是在这个环境中真正执行任务的执行流。

继续用前面的“房子”来比喻的话：

进程 = 一套房子

线程 = 住在房子里干活的人

不同进程就像不同的房子，彼此之间默认相互隔离。

而同一个进程中的多个线程，则像住在同一套房子里的人，它们可以共同使用客厅、厨房、冰箱这些公共资源，但每个人又可以同时做自己的事情。

我再换个比喻，这个可能会更生动些：

两个老铁两个酒桌两套房间

我现在有 100 只鸡，需要人在房间的酒桌上吃完

此时如果有两个人，就得需要搞两套房间，两个酒桌，每个人就可以只需要吃 50 只鸡，但需要的花销就比较大

一个房间一个酒桌两个老铁来吃

两个人在一个酒桌一个房间，两人一起吃 100 只，效率仍然能大幅度提高，还减少了酒桌和房间的开销

引入更多线程的话，就如下图嘿嘿

不过虽然提高了线程的数目，能够提高效率，但也不是“线性增长”。线程数目达到一定程度之后，就算线程再多，也没法起到效果了。毕竟...桌子就那么大啦

线程数目太多的话，线程的调度开销的也会非常明显，从而拖慢了程序的性能。

所以：

进程解决的是程序运行和资源隔离的问题，而线程解决的是一个进程内部如何同时存在多个执行任务的问题。

而且严格来说，前面一直说“CPU 调度进程”主要是为了方便理解。现代操作系统中，真正被 CPU 调度执行的单位通常是线程。

至于线程到底是怎么创建的、多个线程是怎么同时运行的、为什么会出现线程安全问题，以及 Java 中的多线程到底是怎么回事，就留到下一篇继续说了。

JDBC 访问 MySQL：连接、预编译语句与事务处理

Fri, 28 Aug 2026 00:00:00 GMT

适用环境：Java 8 及以上、JDBC 4.2、MySQL 8.0.39。

该部分内容为了解，实际中数据库连接已被包装好，仅需调用即可

1. JDBC 是什么

JDBC（Java Database Connectivity）是 Java 访问关系型数据库的一套标准 API，具体实现是由数据库厂商去完成的。它规定了连接数据库、发送 SQL、接收结果和处理异常的统一接口，真正与 MySQL 通信的代码则由 MySQL 驱动实现。

可以把三者的关系理解为：

Java 程序 → JDBC 标准接口 → MySQL Connector/J 驱动 → MySQL 服务器

业务代码主要面向 java.sql、javax.sql 中的接口编程。更换数据库时虽然仍要调整驱动、地址和方言 SQL，但操作流程基本不变。

一次完整的 JDBC 操作通常包括：

引入数据库驱动；
获取 Connection 连接；
定义 SQL，并创建 PreparedStatement；
为 SQL 中的占位符绑定参数；
执行 SQL；
处理执行结果：增删改读取影响行数，查询读取 ResultSet；
按照结果集、执行对象、数据库连接的顺序释放资源。

如果多条增删改语句属于同一个业务，还要在同一个连接中统一提交或回滚事务。上面的顺序就是后文各节的编排顺序，也对应一段 JDBC 程序从开始到结束的实际执行过程。

2. 引入 MySQL 驱动

2.1 Maven 依赖

maven：类似应用商店，在maven仓库中维护了所有的Java工程需要用到的依赖，IDEA中已经内置好了maven

由于我的mysql版本为8.4.xx，因此使用的maven对应的是下面这部分依赖；

不同版本可以到Maven Repository: mysql此处找对应版本依赖

第一个 MySQL Connector-j 为最新版本的依赖推荐

IDEA创建模块选择maven后，在其下的pom.xml插入该依赖

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.4.0</version>
    <scope>compile</scope>
</dependency>

驱动必须进入运行时类路径，否则连接时会出现 No suitable driver 一类错误。

如无法加载该依赖，则还需修改镜像源

2.2 配置国内镜像

内置的maven路径：IDEA安装目录/plugins/maven/lib/maven3/conf/setting.xml

<!-- 加入如下 Mirror 节点，使用国内阿里云仓库镜像 开始 -->
<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

<mirror>
    <id>central</id>
    <mirrorOf>*</mirrorOf>
    <name>aliyun central</name>
    <url>https://maven.aliyun.com/repository/central</url>
</mirror>

<mirror>
    <id>spring</id>
    <mirrorOf>*</mirrorOf>
    <name>aliyun spring</name>
    <url>https://maven.aliyun.com/repository/spring</url>
</mirror>
<!-- 加入如下 Mirror 节点，使用国内阿里云仓库镜像 结束 -->

2.3 是否还要手动加载驱动

旧代码常写 Class.forName("com.mysql.cj.jdbc.Driver")。从 JDBC 4 开始，驱动通常会自动注册，现代项目一般可以不用写。自动加载失败时，先检查运行时依赖；旧环境或特殊类加载器才可能显式调用。

3. 核心接口

接口或类	作用
`DriverManager`	根据 JDBC URL 获取连接，适合简单程序和入门练习
`DataSource`	对“连接来源”的抽象，更适合配置、容器和连接池环境
`Connection`	表示一次数据库会话，也负责事务控制
`Statement`	执行不带参数的静态 SQL，不适合拼接外部输入
`PreparedStatement`	预编译 SQL、绑定参数，是日常增删改查的首选
`CallableStatement`	调用存储过程，继承自 `PreparedStatement`
`ResultSet`	保存查询结果，并通过游标逐行读取
`SQLException`	JDBC 操作异常，可取得状态码、错误码和错误信息

这些对象多数是接口，变量也应尽量声明为接口类型，减少对具体驱动的依赖。

4. 建立数据库连接

4.1 JDBC URL

MySQL 连接地址的基本格式是：

jdbc:mysql://主机:端口/数据库?参数1=值1&参数2=值2

本机练习可以写成：

jdbc:mysql://127.0.0.1:3306/jdbc_demo?sslMode=DISABLED&allowPublicKeyRetrieval=true

其中，127.0.0.1:3306 是主机和端口，jdbc_demo 是数据库。后两个参数用于关闭 TLS、允许获取认证公钥，只适合可信的本地环境。生产环境应配置 TLS 和严格的证书校验，不能为了消除报错而照搬这两个参数。

4.2 使用 `DriverManager`

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public final class JdbcConfig {
    private static final String URL =
        "jdbc:mysql://127.0.0.1:3306/jdbc_demo"
        + "?sslMode=DISABLED&allowPublicKeyRetrieval=true";
    private static final String USER = System.getenv("DB_USER");
    private static final String PASSWORD = System.getenv("DB_PASSWORD");

    // 私有构造方法，禁止随意创建JdbcConfig对象
    private JdbcConfig() {}
	
    // 建立数据库连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }
}

由于方法都是静态方法，所以只需要使用JdbcConfig.function()调用即可，不需要创建对象。

账号和密码通过环境变量读取，避免直接写入源码并提交到仓库。应用程序也不应长期使用 root，应为它创建只拥有所需权限的独立账号。

4.3 `DataSource` 与连接池

DataSource 是 JDBC 提供的一个标准接口，但不等于连接池。MysqlDataSource 是基础数据源；HikariCP 等连接池会实现或包装它。使用连接池后，close() 通常表示归还连接，仍要及时调用。

DataSource 作用是：

向程序提供 Connection，并把连接地址、用户名、密码等配置集中管理起来；

使用方式为：

Connection connection = dataSource.getConnection();

但使用连接池仍然需要close()：

connection.close();

连接池可以理解为一个专门存放数据库连接的“容器”。

程序启动后，连接池会提前建立多个连接：

连接池
├── Connection 1：空闲
├── Connection 2：正在使用
├── Connection 3：空闲
└── Connection 4：空闲

比起 DriverManager 每次调用 getConnection()通常都要重新建立一次数据库连接，连接池够创建多个连接；可以避免频繁创建和关闭连接，节省开销。

5. 定义 SQL、创建执行对象与参数绑定

不要把外部输入拼进 SQL，例如 "... where name='" + inputName + "'"。输入中的引号或逻辑表达式可能改变语句结构，形成 SQL 注入。

可以举个例子（SQL注入演示）：

System.out.println("请输入学号：");
            String sno = scanner.next();
            String sql = "select id,name,sno,age,class_id from student_design2 where sno = '"+ sno +"'";
            // 5.执行SQL，获取查询结果
            resultSet = statement.executeQuery(sql);

由于使用的是 Scanner.next() ,Scanner.next() 遇到空格就停止读取。

因此我们可以用别的表示方法绕过空格，比如 /**/ ，如果是网页中注入的话，通过url可以有：

%20 --代表url编码的空格，在空格过滤时可以代替。

%09--用于在输出或显示文本时在该位置产生一个固定的水平间距，类似于tab键。

%0a--代表换行符

%0b--用于在输出或显示文本时在该位置产生一个固定的垂直间距，类似于tab键。

%0d--回车换行

%a0--代表的是非断行空格

%00--%00代表的是ASCII码中的空字符

都是之前学攻防的底子哈哈哈哈哈

因此可以这样注入：'/**/or/**/1=1;#，使得查询语句被这样闭合

select id, name, sno, age, class_id from student_design2 where sno = ' sno ' or 1=1;#

使用 # 将后续语句屏蔽，由于 1=1 恒成立，因此完成全查询

所以应把 SQL 结构与参数值分开：

用预编译的方式 PreparedStatement 解决SQL注入问题

String sql = "select id, name, age from student where name = ? and age >= ?";

try (PreparedStatement ps = connection.prepareStatement(sql)) {
    ps.setString(1, inputName);
    ps.setInt(2, minAge);

    // 参数绑定完成后，在同一个 try 代码块中执行 SQL
}

这里的实际顺序是：先定义带 ? 的 SQL，再通过连接创建 PreparedStatement，最后调用 setXxx() 绑定参数。绑定完成后，才能在同一个 PreparedStatement 上执行 SQL。

使用时要记住：

? 是参数占位符，编号从 1 开始；
占位符外不要再加引号，应写 name = ?，不能写 name = '?'；
setString、setInt、setBigDecimal 等方法会按类型安全传值；
Java 值为 null 时可使用 setNull(index, Types.INTEGER)，或在驱动支持的情况下使用 setObject；
占位符只能代表“值”，不能代替表名、列名、ASC/DESC 等 SQL 结构。动态结构必须使用白名单选择，不能直接拼接外部输入。

PreparedStatement 既降低 SQL 注入风险，也让类型转换和重复执行更清晰，应作为业务代码的默认选择。

6. 执行 SQL 的三个方法

方法	适用场景	返回值
`executeQuery()`	`SELECT` 查询	`ResultSet`
`executeUpdate()`	`INSERT`、`UPDATE`、`DELETE`，以及部分 DDL	`int`，表示驱动报告的影响行数
`execute()`	结果类型事先不确定、可能返回多个结果	`boolean`，`true` 表示当前结果为 `ResultSet`

日常代码应选含义最明确的方法。不要对查询调用 executeUpdate()，也不要为了省事全部使用 execute()。

调用存储过程时使用 CallableStatement，形如 prepareCall("{call procedure_name(?, ?)}")；输出参数先用 registerOutParameter 注册。

7. 增删改查写法

以下代码假设 student 表含有自增主键 id、姓名 name、年龄 age 和创建时间 created_at。

7.1 新增并取得自增主键

String sql = "insert into student(name, age) values (?, ?)";

try (Connection conn = JdbcConfig.getConnection();
     PreparedStatement ps = conn.prepareStatement(
         sql, Statement.RETURN_GENERATED_KEYS)) {

    ps.setString(1, "小林");
    ps.setInt(2, 20);

    int rows = ps.executeUpdate();
    if (rows == 1) {
        try (ResultSet keys = ps.getGeneratedKeys()) {
            if (keys.next()) {
                long newId = keys.getLong(1);
                System.out.println("新增编号：" + newId);
            }
        }
    }
}

只有创建语句时传入 Statement.RETURN_GENERATED_KEYS，执行后才能规范地读取生成的主键。

7.2 删除

String sql = "delete from student where id = ?";

try (Connection conn = JdbcConfig.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setLong(1, 1L);

    int rows = ps.executeUpdate();
    System.out.println("删除行数：" + rows);
}

删除前要确认 WHERE 条件正确，并检查影响行数。没有 WHERE 条件的 DELETE 可能删除整张表中的记录。

7.3 修改

String sql = "update student set age = ? where id = ?";
try (Connection conn = JdbcConfig.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setInt(1, 21);
    ps.setLong(2, 1L);
    int rows = ps.executeUpdate();
    System.out.println("修改行数：" + rows);
}

新增、删除和修改都使用 executeUpdate()，并通过返回的影响行数判断条件是否匹配、操作是否符合预期。

7.4 查询

String sql = "select id, name, age from student where age >= ?";

try (Connection conn = JdbcConfig.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setInt(1, 18);

    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            System.out.println(id + "，" + name + "，" + age);
        }
    }
}

查询使用 executeQuery() 获得 ResultSet，然后移动游标并读取每一行。查询结果的具体读取规则见下一节。

8. 读取 `ResultSet`

查询刚返回时，游标位于第一行之前。每次调用 next()，游标向后移动一行；有数据时返回 true，越过最后一行时返回 false。所以多行查询使用 while (rs.next())，只期待一行时可以使用 if (rs.next())。

读取列时推荐使用列名或别名，可读性比数字下标更好。联表查询若出现重名列，可写 c.name as class_name，再通过 rs.getString("class_name") 读取。

常见类型对应关系：

MySQL 类型	推荐 Java 类型	常用方法
`VARCHAR`、`TEXT`	`String`	`getString`、`setString`
`INT`	`int` / `Integer`	`getInt`、`setInt`
`BIGINT`	`long` / `Long`	`getLong`、`setLong`
`DECIMAL`	`BigDecimal`	`getBigDecimal`、`setBigDecimal`
`DATE`	`LocalDate`	`getObject(..., LocalDate.class)`
`DATETIME`、`TIMESTAMP`	`LocalDateTime`	`getObject(..., LocalDateTime.class)`
`BLOB`	`byte[]` 或流	`getBytes`、`getBinaryStream`

getInt、getLong 等基本类型方法遇到 SQL NULL 会返回 0，因此可在读取后调用 wasNull()；如果业务上需要区分“空值”和“数字 0”，应使用包装类型保存结果。金额不要用 double，应使用 BigDecimal。

9. 释放资源

执行结果处理完毕后，应关闭 ResultSet、Statement 或 PreparedStatement、Connection。推荐使用 try-with-resources：

String sql = "select id, name, age from student where id = ?";

try (Connection connection = JdbcConfig.getConnection();
     PreparedStatement ps = connection.prepareStatement(sql)) {

    ps.setLong(1, 1L);

    try (ResultSet rs = ps.executeQuery()) {
        if (rs.next()) {
            System.out.println(rs.getString("name"));
        }
    }
}

Java 会自动按照声明的相反顺序关闭资源，因此实际关闭顺序是：

ResultSet；
PreparedStatement；
Connection。

这与手动在 finally 中“先关闭结果集，再关闭执行对象，最后关闭连接”的顺序相同。try-with-resources 比逐个判空关闭更简洁，也能在发生异常时可靠释放资源。使用连接池时，connection.close() 通常表示把连接归还连接池，仍然必须调用。

10. JDBC 事务

新连接默认开启自动提交，即每条 SQL 执行成功后立即提交。一个业务动作包含多条 SQL 时，必须在同一个 Connection 上关闭自动提交，再统一提交或回滚。

public static void transfer(long fromId, long toId, BigDecimal amount)
        throws SQLException {
    try (Connection conn = JdbcConfig.getConnection()) {
        boolean oldAutoCommit = conn.getAutoCommit();
        try {
            conn.setAutoCommit(false);

            String debitSql = "update account set balance = balance - ? "
                            + "where id = ? and balance >= ?";
            try (PreparedStatement debit = conn.prepareStatement(debitSql)) {
                debit.setBigDecimal(1, amount);
                debit.setLong(2, fromId);
                debit.setBigDecimal(3, amount);
                if (debit.executeUpdate() != 1) {
                    throw new SQLException("扣款失败：账号不存在或余额不足");
                }
            }

            String creditSql =
                "update account set balance = balance + ? where id = ?";
            try (PreparedStatement credit = conn.prepareStatement(creditSql)) {
                credit.setBigDecimal(1, amount);
                credit.setLong(2, toId);
                if (credit.executeUpdate() != 1) {
                    throw new SQLException("收款账号不存在");
                }
            }

            conn.commit();
        } catch (SQLException e) {
            conn.rollback();
            throw e;
        } finally {
            conn.setAutoCommit(oldAutoCommit);
        }
    }
}

关键是多条语句共用同一连接，全部成功才 commit()，任意一步失败都 rollback()。归还池前还要恢复原来的 autoCommit，避免影响下一位使用者；事务中途不能重新获取连接。

数据库表还必须使用支持事务的存储引擎，例如 InnoDB，否则 Java 代码写了回滚也达不到预期效果。

11. 异常排查

排错时应保留 SQLException 的状态码、数据库错误码和信息：

catch (SQLException e) {
    System.err.println("SQLState：" + e.getSQLState());
    System.err.println("错误码：" + e.getErrorCode());
    System.err.println("错误信息：" + e.getMessage());
    throw e;
}

现象	常见检查方向
`No suitable driver`	驱动依赖是否进入运行时、URL 是否以 `jdbc:mysql:` 开头
`Access denied`	用户名、密码、连接来源和 MySQL 授权是否匹配
`Unknown database`	数据库是否创建，URL 中名称是否拼错
`Communications link failure`	MySQL 是否启动，地址、端口、防火墙是否正确
`Public Key Retrieval is not allowed`	优先配置 TLS；可信本机可按需启用公钥获取
SQL 语法异常	在数据库客户端中验证 SQL，并检查字段、表名和占位符数量

日志可记录 SQL 模板、SQLState 和错误码，但不能输出密码等敏感参数。异常也不能空处理，否则上层会误以为业务成功。

参考

MySQL 用户与权限：账号、授权、角色与安全实践

Sat, 22 Aug 2026 00:00:00 GMT

适用环境：MySQL 8.0.39。

1. 用户和权限

MySQL 安装完成后通常会有管理账号 root。它适合安装、维护和授权，但不适合作为普通项目的连接账号。

MySQL 的访问控制可以分成两步：

身份验证：根据用户名、连接来源和密码确定能否登录。
权限验证：登录成功后，每执行一条 SQL，MySQL 都会检查该账号是否拥有相应权限。

所以，“密码正确”只表示可以连接，并不代表可以查询、插入或删除数据。

2. MySQL 账号的组成

2.1 账号不是单独的用户名

MySQL 账号的完整格式为：

'user_name'@'host_name'

user_name：用户名；
host_name：允许该用户从什么主机连接。

例如，下面是两个不同的账号：

'app_user'@'localhost'
'app_user'@'192.168.1.10'

虽然用户名相同，但是是两个独立账号，密码和权限也可以不同。MySQL 按“用户名 + 主机”定位账号。

用户名和主机名要分别加引号：

-- 正确
'app_user'@'localhost'

-- 错误理解：这是用户名 app_user@localhost，主机部分被省略
'app_user@localhost'

省略主机等价于 'user_name'@'%'，允许从任意主机匹配。实际创建账号时应该明确写出主机。

2.2 常见主机范围

写法	含义	建议
`'localhost'`	只允许本机连接	本机应用优先使用
`'192.168.1.10'`	只允许指定 IP	范围明确，安全性较高
`'192.168.1.0/24'`	允许指定 IPv4 网段	MySQL 8.0.23 起支持 CIDR
`'192.168.1.0/255.255.255.0'`	使用 IPv4 地址和子网掩码	可用于限制网段
`'%'`	任意主机	范围过大，不建议直接使用

MySQL 8.0.35 起，主机部分的 %、_ 通配符已被弃用。MySQL 8.0.39 应优先使用明确 IP、主机名或 CIDR，并配合防火墙限制来源。

3. 查看用户和当前身份

3.1 查看已有账号

用户信息保存在 mysql 系统数据库的授权表中。管理员可以查看常用账号属性：

select
    user,
    host,
    plugin,
    account_locked,
    password_expired
from mysql.user;

字段含义如下：

user、host：共同组成完整账号；
plugin：账号使用的认证插件；
account_locked：账号是否被锁定；
password_expired：密码是否已经过期；

mysql.infoschema、mysql.session、mysql.sys 等通常是 MySQL 自己使用的保留账号，不应随意改密或删除。也不建议直接对 mysql.user 执行 INSERT、UPDATE、DELETE；应使用专门的账号管理语句，让 MySQL 正确维护所有授权表和内存权限数据。

3.2 `USER()` 与 `CURRENT_USER()`

select user(), current_user();

二者含义不同：

USER()：客户端连接时提供的用户名，以及客户端来源；
CURRENT_USER()：MySQL 最终用于身份验证和权限检查的账号。

普通情况下两者看起来相同，但匿名账号匹配、代理用户等场景下可能不同。判断权限属于哪个账号，应以 CURRENT_USER() 为准。

3.3 查看权限和账号定义

-- 查看当前账号的权限
show grants;

-- 查看指定账号的权限
show grants for 'app_user'@'localhost';

-- 查看账号的认证、密码策略和锁定状态等定义
show create user 'app_user'@'localhost';

如果结果中出现：

grant usage on *.* to 'app_user'@'localhost';

USAGE 不代表拥有全局操作权限，而表示账号存在，但在该层级没有实际权限。

4. 创建用户

4.1 基本语法

create user [if not exists]
    'user_name'@'host_name'
    identified by 'password';

示例：

create user if not exists
    'sqllearn_app'@'localhost'
    identified by 'Study-MySQL_2026!';

执行后只完成三件事：创建账号、限制连接来源、设置登录密码。新账号默认没有业务数据库的访问权限，还需要单独执行 GRANT。

IF NOT EXISTS 可避免账号已存在时报错，但不会修改已有账号。简单密码可能被密码策略拒绝。

MySQL 8.0 中推荐把创建和授权分开写：

create user if not exists 'sqllearn_app'@'localhost'
identified by 'Study-MySQL_2026!';

grant select, insert, update, delete
on sqllearn.*
to 'sqllearn_app'@'localhost';

这样能清楚区分“创建身份”和“授予权限”。

4.2 创建限定网段的账号

create user 'report_user'@'192.168.1.0/24'
identified by 'Report-Read_2026!';

该账号只能从匹配的 IPv4 网段连接。远程连接还取决于 MySQL 监听地址、防火墙和云服务器安全组。

5. 修改和删除用户

5.1 修改密码

推荐使用 ALTER USER：

alter user 'sqllearn_app'@'localhost'
identified by 'New-Study_2026!';

修改当前已认证账号的密码：

-- USER() 是 ALTER USER 为当前账号提供的专用写法
alter user user()
identified by 'My-New-Password_2026!';

也可以使用 SET PASSWORD：

-- 修改指定账号密码
set password for 'sqllearn_app'@'localhost'
= 'New-Study_2026!';

-- 修改当前账号密码
set password = 'My-New-Password_2026!';

优先掌握 ALTER USER，因为它还能管理账号锁定和密码过期等属性。

5.2 锁定、解锁和要求改密

-- 暂停账号登录，但保留账号和权限
alter user 'sqllearn_app'@'localhost' account lock;

-- 恢复账号登录
alter user 'sqllearn_app'@'localhost' account unlock;

-- 要求用户下次连接时修改密码
alter user 'sqllearn_app'@'localhost' password expire;

暂时停用时先锁定，确认废弃后再删除，便于恢复。

5.3 重命名和删除账号

rename user
    'sqllearn_app'@'localhost'
to  'sqllearn_service'@'localhost';

RENAME USER 会保留旧账号的权限。删除语法为：

drop user if exists 'sqllearn_service'@'localhost';

DROP USER 会删除账号及其授权记录，但不会删除它创建的数据库和表。删除前应检查它是否是视图、触发器或存储程序的 DEFINER。已有连接也不会被强制立即断开。

6. 权限类型和作用层级

6.1 常用权限

权限	作用
`SELECT`	查询数据
`INSERT`	插入数据
`UPDATE`	修改数据
`DELETE`	删除数据
`CREATE`	创建数据库或表，具体能力取决于授权层级
`ALTER`	修改表结构
`DROP`	删除数据库、表或视图；`TRUNCATE TABLE` 也需要该权限
`INDEX`	创建或删除索引
`CREATE VIEW`	创建或修改视图
`SHOW VIEW`	查看视图定义
`EXECUTE`	执行存储过程或函数
`ALL PRIVILEGES`	指定层级内的全部可用权限，不包含 `GRANT OPTION` 和 `PROXY`

FILE、CREATE USER、PROCESS 等影响范围较大，普通应用通常不需要。

6.2 权限层级

同一种权限可以授予不同范围：

授权对象	层级	含义
`.`	全局级	整个 MySQL 服务中的所有数据库
`sqllearn.*`	数据库级	`sqllearn` 中现有及以后创建的对象
`sqllearn.student`	表级	只作用于 `student` 表
`SELECT(name, age)`	列级	只能查询指定列
`PROCEDURE sqllearn.p_demo`	存储过程级	只作用于指定过程

范围越大，风险越高。应用账号一般使用数据库级或更小的范围，不应轻易授权 *.*。

GRANT ALL ON sqllearn.* 只表示拥有 sqllearn 数据库层级能够授予的全部权限，不会因此获得 FILE、CREATE USER 等全局管理权限。

7. 授予权限

7.1 基本语法

grant priv_type [, priv_type ...]
on priv_level
to 'user_name'@'host_name'
[with grant option];

priv_type：权限类型

priv_level：权限作用范围，如数据库、某数据库中的某表...

with grant option：允许该用户把自己拥有的权限继续授权给其他用户

示例：授予 sqllearn 数据库的常用增删改查权限。

grant select, insert, update, delete
on sqllearn.*
to 'sqllearn_app'@'localhost';

创建只读账号：

create user 'sqllearn_read'@'localhost'
identified by 'Read-Only_2026!';

grant select
on sqllearn.*
to 'sqllearn_read'@'localhost';

在select权限下执行insert操作会有如下报错：

限制到一张表：

grant select
on sqllearn.student
to 'sqllearn_read'@'localhost';

限制到部分列：

grant select (id, name, age)
on sqllearn.student
to 'sqllearn_read'@'localhost';

7.2 `WITH GRANT OPTION`

grant select
on sqllearn.*
to 'team_leader'@'localhost'
with grant option;

该选项还允许 team_leader 把这项权限授予其他账号。普通业务用户不需要这种能力。

7.3 权限何时生效

通过 CREATE USER、GRANT、REVOKE、ALTER USER 等专用语句修改账号时，MySQL 会主动更新权限数据，通常不需要执行 FLUSH PRIVILEGES。

FLUSH PRIVILEGES表示刷新权限操作；

已有连接中不同层级的变化可能在不同时间体现：

表级、列级权限通常在下一条请求时体现；
数据库级权限可能要再次执行 USE 数据库名；
静态全局权限或密码变化通常要重新连接后体现。

若授权后仍报错，先确认授权账号与 CURRENT_USER() 是否一致，再根据层级重新选择数据库或连接。

FLUSH PRIVILEGES 主要用于直接修改授权表后重新加载，或 --skip-grant-tables 启动后的恢复；直接修改授权表并不推荐。

8. 回收权限

8.1 基本语法

revoke [if exists] priv_type [, priv_type ...]
on priv_level
from 'user_name'@'host_name';

回收写权限，只保留原有查询权限：

revoke insert, update, delete
on sqllearn.*
from 'sqllearn_app'@'localhost';

回收 sqllearn 数据库上的全部权限：

revoke all privileges
on sqllearn.*
from 'sqllearn_app'@'localhost';

清除该账号在所有层级的权限和转授权能力：

revoke all privileges, grant option
from 'sqllearn_app'@'localhost';

注意：

REVOKE 只撤销权限，不删除账号；账号仍可能登录，但无法执行未获授权的操作。
只想撤销某个数据库的权限时，应写 sqllearn.*，不要误写成范围更大的全局清除语句。
REVOKE IF EXISTS 从 MySQL 8.0.30 起支持。
撤权后使用 SHOW GRANTS 核对结果，不要只根据 SHOW DATABASES 判断。

区分授予和回收语法：

授予

grant ... to 用户;

回收

revoke ... from 用户;

9. 使用角色管理权限

许多用户需要同一组权限时，可以把权限封装成角色，再分配给用户。

-- 1. 创建角色
create role 'r_sqllearn_read';

-- 2. 给角色授权
grant select
on sqllearn.*
to 'r_sqllearn_read';

-- 3. 创建实际登录账号
create user 'analyst'@'localhost'
identified by 'Analyst-Read_2026!';

-- 4. 把角色授予用户；授予角色时没有 ON 子句
grant 'r_sqllearn_read'
to 'analyst'@'localhost';

-- 5. 设置为默认激活角色
set default role 'r_sqllearn_read'
to 'analyst'@'localhost';

查看当前会话已经激活的角色：

select current_role();

角色适合账号较多、权限模板相同的场景。少量账号直接 GRANT 即可。

10. 常见错误

10.1 `Access denied for user`（1045）

表示连接阶段失败，优先检查：

用户名或密码是否正确；
连接来源是否匹配账号的 host；
使用的是否是预期账号，例如 'user'@'localhost' 与 'user'@'%' 并非同一个账号；
客户端连接的是不是预期 MySQL 服务器和端口。

10.2 `Access denied ... to database`（1044）

账号已经登录，但没有目标数据库的访问权限。使用管理员账号执行：

show grants for 'user_name'@'host_name';

检查授权数据库名和账号主机是否准确。

10.3 `command denied ... for table`（1142）

说明账号能够访问数据库，但缺少当前命令所需权限。例如能 SELECT 却不能 INSERT，就需要检查是否授予 INSERT，而不是重新设置密码。

10.4 授权后仍未生效

依次检查：

select current_user();
show grants;

如果账号正确，再尝试重新执行 USE 数据库名 或重新连接。使用专用授权语句时不应把 FLUSH PRIVILEGES 当成固定步骤。

参考

flowchart LR
    A["用户和权限管理"]

    A --> U["用户"]
    U --> U1["mysql.user"]
    U --> U2["'user'@'host'"]
    U --> U3["CREATE USER"]
    U --> U4["ALTER USER"]
    U --> U5["SET PASSWORD"]
    U --> U6["DROP USER"]

    A --> P["权限"]

    P --> G["GRANT"]
    G --> G1["SELECT"]
    G --> G2["多个权限"]
    G --> G3["ALL"]
    G --> G4["WITH GRANT OPTION"]

    P --> S["权限范围"]
    S --> S1["*.*"]
    S --> S2["db_name.*"]
    S --> S3["db_name.table_name"]

    P --> SG["SHOW GRANTS"]
    SG --> SG1["USAGE"]

    P --> R["REVOKE"]
    R --> R1["回收权限"]

MySQL 视图：定义、更新规则与执行算法

Mon, 10 Aug 2026 00:00:00 GMT

适用环境：MySQL 8.0。

视图可以理解为“有名字、可重复查询的 SELECT”，主要用于封装查询、限制可见数据和提供稳定的查询接口

1. 视图

视图（View）是一张虚拟表，它的内容来自一个或多个基表、其他视图或表达式的查询结果；创建视图时，MySQL 主要保存的是视图名称、列信息和 SELECT 定义，而不是另存一份结果数据

flowchart LR
    Q["查询视图"] --> V["执行视图定义"]
    V --> S["student 基表"]
    V --> C["score 基表"]

视图有以下特点：

查询视图时，MySQL 根据视图定义读取当时的基表数据；
基表数据改变后，再次查询视图通常会看到新结果；
删除视图只删除查询定义，不会删除基表及其数据；
普通视图不是数据副本、备份或快照，也不会自动提高查询速度；
视图定义仍会保存在数据字典中，所以“视图不存结果数据”不等于完全不占任何空间。

例如，下面的视图只展示学生编号、姓名和年龄：

create view v_student_basic as
select id, name, age
from student;

查询视图与查询普通表的写法相同：

select * from v_student_basic;

2. 视图优点

简化复杂查询

多表连接、筛选和计算可以封装到视图中。应用以后只查询视图，不必反复编写同一段复杂 SQL。

限制可见的行和列

视图可以不暴露密码、身份证号等敏感列，也可以通过 WHERE 只展示某些行。但这只有与权限控制结合才真正安全：如果用户仍拥有基表的 SELECT 权限，他依然可以绕过视图直接查询基表。

提供相对稳定的查询接口

应用统一查询视图。底层表调整后，有时只需重新定义视图即可保持视图的列名不变，减少应用改动。但这种独立性并非绝对：删除视图依赖的列仍可能使视图失效。

统一名称和业务口径

视图可以为列起更清楚的名称，并把“总分如何计算”“有效记录如何筛选”等规则集中在一处，避免不同程序写出不同口径。

3. 创建视图

3.1 基本语法

create view 视图名 [(视图列名列表)] as
select 查询列
from 表名
[where 条件];

较完整的 MySQL 语法为：

create [or replace]
    [algorithm = {undefined | merge | temptable}]
    [definer = 用户]
    [sql security {definer | invoker}]
view 视图名 [(视图列名列表)] as
select_statement
[with [cascaded | local] check option];

algorithm：这个是视图执行算法，MySQL 查询视图时，有三种处理方式。undefined（默认）、merge（合并）、tempable（临时表）
definer：指定创建这个视图的人。如definer='root'@'localhost'表示该视图属于root用户
sql security：表示查询视图时，使用谁的权限
- definer 则表示使用创建视图用户的权限；
- invoker 则表示当前查询用户自己的权限；
with check option：防止通过视图修改出视图范围之外的数据
- cascaded：检查所有关联视图；
- local：只检查当前视图；

示例：

create or replace
algorithm = merge
definer = 'root'@'localhost'
sql security definer
view v_java_student (student_id, student_name, class_name)
as
select
    s.id,
    s.name,
    c.name
from student_design2 s
join class_design2 c
    on c.id = s.class_id
where c.name = 'Java001班'
with cascaded check option;

3.2 使用别名确定视图列名

以下示例连接学生、班级、课程和成绩表。显式 JOIN ... ON ... 能把连接条件与普通筛选条件分开，比逗号连接更容易阅读，也能减少漏写连接条件造成笛卡尔积的风险。

create view v_student_score as
select
    s.id          as student_id,
    s.name        as student_name,
    s.sno,
    s.age,
    s.gender,
    s.enroll_date,
    c.id          as class_id,
    c.name        as class_name,
    co.id         as course_id,
    co.name       as course_name,
    sc.id         as score_id,
    sc.score
from student s
join class c
    on c.id = s.class_id
join score sc
    on sc.student_id = s.id
join course co
    on co.id = sc.course_id;

来自不同表的列可能同名，例如四张表都可能有 id。视图中的列名必须唯一，所以要用 AS 改成 student_id、class_id 等明确名称。

3.3 在视图名后指定列名

也可以统一列出视图的列名：

create view v_student_name_age
    (student_id, student_name, student_age) as
select id, name, age
from student;

括号中的名称数量必须与 SELECT 返回的列数完全相同。两种命名方法选择一种即可；复杂查询通常使用 AS 别名更直观，因为名称紧挨对应表达式。

3.4 创建时的注意事项

视图与表属于同一数据库名称空间，不能在同一数据库中同名。
建议明确写出字段，不要长期依赖 SELECT *。视图定义在创建时确定；基表以后新增列，不会自动加入既有视图。
如果基表的依赖列被删除或改名，查询视图可能报错，需要重新定义视图。
不要依赖视图定义中的 ORDER BY 保证顺序。查询视图时应在最外层明确排序；外层自己的 ORDER BY 会取代视图内的排序。
CREATE VIEW 是 DDL，会触发隐式提交，不要把它混入需要回滚的业务事务。

4. 查询和使用视图

视图可出现在普通表能够出现的许多查询位置，并可继续筛选、连接、分组和排序：

-- 查询全部视图数据
select *
from v_student_score;

-- 对视图结果继续筛选和排序
select student_name, course_name, score
from v_student_score
where score >= 90
order by score desc;

-- 视图与真实表连接
select v.student_name, v.course_name, v.score, s.enroll_date
from v_student_score v
join student s
    on s.id = v.student_id;

视图也可以隐藏查询细节。例如只对外提供姓名和总分：

create view v_student_total_points as
select
    s.id as student_id,
    s.name as student_name,
    sum(sc.score) as total_points
from student s
join score sc
    on sc.student_id = s.id
group by s.id, s.name;

select student_name, total_points
from v_student_total_points
order by total_points desc;

用户只能从该视图获得定义中已有的列，不能临时查询未被视图暴露的学号或各科明细。若确实需要这些字段，应修改视图、另建视图或在有权限时查询基表。

5. 视图与基表数据的关系

5.1 修改基表会影响视图结果

update score
set score = 99
where student_id = 1 and course_id = 1;

select *
from v_student_score
where student_id = 1 and course_id = 1;

UPDATE 修改的是 score 基表。视图没有独立保存旧结果，所以再次查询时会显示修改后的成绩。

5.2 修改可更新视图会影响基表

创建一个行与基表行一一对应的简单视图：

create view v_class_one_student as
select id, name, age, class_id
from student
where class_id = 1;

update v_class_one_student
set age = 20
where id = 1;

如果这个视图满足可更新条件，这条语句最终修改的是 student 基表中 id=1 的记录。因此能看出，视图不是基表的副本；通过视图写数据同样需要事务、权限和条件控制。

6. 可更新视图

视图能够被 UPDATE、DELETE 或 INSERT 操作的核心条件是：视图中的一行能够明确对应到底层表中的一行。最容易更新的是“单表 + 简单列 + 普通 WHERE”视图。

以下结构通常会使视图不可更新：

聚合函数或窗口函数，如 SUM()、COUNT()、AVG()；
DISTINCT；
GROUP BY、HAVING；
UNION、UNION ALL；
查询列表中的子查询；
某些多表连接；
在 FROM 中引用不可更新视图；
只查询常量，没有可对应的基表行；
明确使用 ALGORITHM = TEMPTABLE。

例如 v_student_total_points 使用了 SUM() 和 GROUP BY。一条总分记录由多条成绩记录合成，MySQL 无法判断“把总分改成 500”应当修改哪一科，所以它只适合查询。

ORDER BY 可以出现在视图定义中，但不能把它简单记成“只要有 ORDER BY，视图就一定不可更新”。可更新性取决于完整定义和处理方式；为了职责清楚，可写视图通常不在内部排序，而在查询视图时排序。

“可更新”也不一定代表“可插入”。通过视图插入时，视图还要能为基表中所有没有默认值的必填列提供值，而且目标列通常必须是简单的基表列引用。

检查 MySQL 记录的可更新状态：

select table_name, is_updatable
from information_schema.views
where table_schema = database();

IS_UPDATABLE='YES' 表示该视图可用于某些更新操作，不表示任意 INSERT、UPDATE、DELETE 都必然合法；实际操作还受列、连接方式和权限等条件限制。

7. WITH CHECK OPTION

普通可更新视图有一个容易忽略的问题：通过视图修改数据后，新数据可能不再满足视图的 WHERE 条件，于是该行会从视图中“消失”。

create view v_class_one_student as
select id, name, age, class_id
from student
where class_id = 1;

-- 若没有检查选项，这次修改可能成功，随后该行不再出现在视图中
update v_class_one_student
set class_id = 2
where id = 1;

在可更新视图后加入 WITH CHECK OPTION，可以阻止通过该视图写入不再满足视图条件的数据：

create or replace view v_class_one_student as
select id, name, age, class_id
from student
where class_id = 1
with check option;

此时把 class_id 改为 2 会失败，因为修改后的记录不符合 class_id=1。它既检查 UPDATE 后的行，也检查通过视图 INSERT 的行。

视图基于其他视图时还可指定检查范围：

WITH LOCAL CHECK OPTION：检查当前视图的条件，并按下层视图原有的检查设置继续处理；
WITH CASCADED CHECK OPTION：检查当前视图及所有下层视图的条件；
不写 LOCAL 或 CASCADED 时，默认是 CASCADED。

没有嵌套视图时，直接写 WITH CHECK OPTION 最容易理解。

8. 修改、查看与删除视图

8.1 修改定义

create or replace view v_student_basic as
select id, name, age, gender
from student;

CREATE OR REPLACE VIEW 在视图不存在时创建，在已存在时替换。也可以使用：

alter view v_student_basic as
select id, name, age, gender
from student;

ALTER VIEW 要求目标视图已经存在。两种方式都是重新定义视图，不会直接修改基表数据；它们属于 DDL，同样可能隐式提交当前事务。

8.2 查看视图

-- 查看当前数据库中的视图
show full tables where table_type = 'VIEW';

-- 查看完整创建语句，排查算法、安全模式和检查选项
show create view v_student_basic;

-- 查看视图对外提供的列
desc v_student_basic;

-- 检查视图依赖是否仍然有效
check table v_student_basic;

还可查询更完整的元数据：

select
    table_name,
    is_updatable,
    check_option,
    security_type
from information_schema.views
where table_schema = database();

8.3 删除视图

drop view if exists v_student_basic;

-- 一次删除多个视图
drop view if exists v_student_score, v_student_total_points;

IF EXISTS 可避免视图不存在时直接报错。删除视图不会删除 student、score 等基表数据；但如果其他视图依赖被删除的视图，依赖者可能变得不可用。DROP VIEW 也是会隐式提交的 DDL。

9. 视图处理原理

MySQL 处理视图主要有三种算法：

算法	基本原理	主要特点
`MERGE`	把外层查询与视图定义合并成一个查询	通常更容易继续优化，满足其他条件时可更新
`TEMPTABLE`	先把视图结果放入本次语句使用的内部临时表，再查询临时结果	该视图不可更新；临时结果不是永久保存的物化视图
`UNDEFINED`	由 MySQL 选择，可能优先尝试 `MERGE`	默认思路，通常不必手动指定

例如：

create algorithm = merge view v_adult_student as
select id, name, age
from student
where age >= 18;

执行：

select *
from v_adult_student
where id < 100;

采用 MERGE 时，可以近似理解为 MySQL 合并两个条件后查询基表：

select id, name, age
from student
where age >= 18 and id < 100;

视图不会自动拥有索引，普通视图也不能像表一样单独创建索引。查询性能主要取决于展开后的 SQL、基表索引、数据量和优化器选择；应使用 EXPLAIN 分析最终查询，不能把“创建视图”等同于“查询加速”。

10. 视图的安全上下文

完整语法中的 SQL SECURITY 决定执行视图时按照谁的权限检查底层对象：

SQL SECURITY DEFINER：按视图定义者的权限执行，是默认值；
SQL SECURITY INVOKER：按调用视图的用户权限执行。

create sql security invoker view v_student_public as
select id, name, age
from student;

要使用视图保护数据，应让普通用户只有所需视图的权限，而没有敏感基表的直接权限。仅仅不把敏感列写进视图，并不能阻止一个本来就能查询基表的用户。

参考

MySQL 事务：ACID、隔离级别与 MVCC

Fri, 07 Aug 2026 00:00:00 GMT

适用环境：MySQL 8.0，主要讨论 InnoDB

事务不是把 SQL 写在一起就结束，而是为一组相关操作划定“共同成功或共同失败”的边界。

1. 事务

事务（Transaction）是数据库执行工作的逻辑单位，可以包含一条或多条 SQL。事务结束只有两种主要结果：

COMMIT：确认全部修改，使结果持久化；
ROLLBACK：撤销本事务尚未提交的修改；

例如“张三向李四转账 100 元”至少包含扣款和入账两次更新。如果扣款成功后程序异常，而入账没有执行，总金额就会错误；所以两次更新必须属于同一事务

事务能力由存储引擎提供；InnoDB 支持事务，MyISAM 不支持，先检查表的引擎：

show engines;
show table status like 'bank_account';
show create table bank_account;

一次事务最好只操作支持事务的表。若混入非事务表，ROLLBACK 不能撤销其修改，会破坏“共同成功或失败”。

2. ACID 特性

特性	含义	转账中的表现	InnoDB 的主要实现
Atomicity 原子性	操作不可只完成一部分	扣款和入账一起成功或撤销	undo log、回滚机制
Consistency 一致性	事务前后都满足数据与业务规则	总额不变、余额合法	约束、应用规则，以及其他三项共同保证
Isolation 隔离性	并发事务尽量像互不干扰地执行	转账中间状态不被错误使用	MVCC、锁、隔离级别
Durability 持久性	成功提交的结果能在故障后恢复	返回成功后转账不会因宕机消失	redo log、刷盘与崩溃恢复

一致性不是“开启事务后数据库自动理解全部业务”。数据库可保证主键、外键、CHECK 等规则，但“转账总额不变”“库存不能超卖”等业务不变量仍要由正确 SQL、锁定方式和应用判断共同保证。

3. 基本语法与事务边界

show engines; 	    -- 查看支持事务的存储引擎

start transaction;  -- 从这里开始，后面的修改先不要自动提交
-- 或 begin;

-- 执行 select / insert / update / delete 后
commit;             -- 提交并结束事务/永久保存

rollback;			-- 回滚当前事务/撤销修改

START TRANSACTION 与 BEGIN 在普通 SQL 中都能开启事务；前者还能使用：

start transaction read only;
start transaction read write;
start transaction with consistent snapshot;

READ ONLY 适合明确的只读事务，InnoDB 可据此优化。WITH CONSISTENT SNAPSHOT 在 REPEATABLE READ 下立即建立一致性快照。

MySQL 不支持普通事务嵌套。在未结束的事务中再次执行 START TRANSACTION，会先隐式提交原事务，不是创建子事务。存储过程里的 BEGIN ... END 表示程序块；需要开启事务时应明确写 START TRANSACTION。

4. 转账事务实操

4.1 开启事务，执行修改后回滚

开启事务

# 开启事务
mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

# 在修改之前查看表中的数据
mysql> SELECT * FROM bank_account;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | 张三 | 1000.00 |
|  2 | 李四 | 1000.00 |
+----+------+---------+
2 rows in set (0.00 sec)

执行修改

# 张三余额减少 100
mysql> UPDATE bank_account
       SET balance = balance - 100
       WHERE name = '张三';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

# 李四余额增加 100
mysql> UPDATE bank_account
       SET balance = balance + 100
       WHERE name = '李四';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

# 修改之后、回滚之前查看表中的数据
mysql> SELECT * FROM bank_account;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | 张三 |  900.00 |
|  2 | 李四 | 1100.00 |
+----+------+---------+
2 rows in set (0.00 sec)

回滚事务

# 回滚事务
mysql> ROLLBACK;
Query OK, 0 rows affected (0.00 sec)

# 再次查询，发现修改没有生效
mysql> SELECT * FROM bank_account;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | 张三 | 1000.00 |
|  2 | 李四 | 1000.00 |
+----+------+---------+
2 rows in set (0.00 sec)

4.2 开启事务，执行修改后提交

开启事务

# 开启事务
mysql> BEGIN;
Query OK, 0 rows affected (0.00 sec)

# 在修改之前查看表中的数据
mysql> SELECT * FROM bank_account;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | 张三 | 1000.00 |
|  2 | 李四 | 1000.00 |
+----+------+---------+
2 rows in set (0.00 sec)

执行修改

# 张三余额减少 100
mysql> UPDATE bank_account
       SET balance = balance - 100
       WHERE name = '张三';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

# 李四余额增加 100
mysql> UPDATE bank_account
       SET balance = balance + 100
       WHERE name = '李四';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

# 修改之后、提交之前查看表中的数据
mysql> SELECT * FROM bank_account;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | 张三 |  900.00 |
|  2 | 李四 | 1100.00 |
+----+------+---------+
2 rows in set (0.00 sec)

提交事务

# 提交事务
mysql> COMMIT;
Query OK, 0 rows affected (0.01 sec)

# 再次查询，数据已经被修改，说明数据已经持久化到磁盘
mysql> SELECT * FROM bank_account;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | 张三 |  900.00 |
|  2 | 李四 | 1100.00 |
+----+------+---------+
2 rows in set (0.00 sec)

5. 自动提交与隐式提交

MySQL 新连接默认开启自动提交。未显式开启事务时，每条成功语句各自形成一个事务，执行后立即提交：

select @@session.autocommit;	-- 查看当前设置
set autocommit = 0;  -- 当前会话关闭自动提交
set autocommit = 1;  -- 恢复自动提交

两种常用方式：

-- 方式一：保留默认自动提交，只临时开启一次事务
start transaction;
update bank_account set balance = balance + 10 where id = 1;
commit;

-- 方式二：持续关闭当前连接的自动提交
set autocommit = 0;
update bank_account set balance = balance - 10 where id = 1;
commit;              -- 之后仍需继续显式提交或回滚

当 autocommit=0 时，会话结束而最后一个事务未提交，MySQL 会回滚它；从 0 改成 1 会隐式提交当前事务。

以下语句通常会隐式提交当前事务，不能指望随后 ROLLBACK 撤销：

DDL：CREATE、ALTER、DROP、TRUNCATE、RENAME；
部分账户、管理和锁表语句；
再次执行 START TRANSACTION，或执行使值从 0 变为 1 的 SET autocommit=1。

注意：

[!CAUTION]

只要使用 start transaction 或 begin 开启事务，必须要通过 commit 提交才会持久化，与是否设置 set autocommit 无关；

手动提交模式下，不用显式开启事务，执行修改操作后，提交或回滚事务时直接使用commit 或 rollback；

已提交的事务不能回滚；

6. 保存点

涉及语法：

savepoint 保存点名称;

回滚到指定保存点：

rollback to 保存点名称;

例如：

保存点用于只撤销事务后半段，不等于提交前半段：

start transaction;
savepoint before_transfer;

update bank_account set balance = balance - 100 where id = 1;
update bank_account set balance = balance + 100 where id = 2;
rollback to savepoint before_transfer;  -- 撤销上面两次更新

-- 改用 50 元重新执行
update bank_account set balance = balance - 50 where id = 1;
update bank_account set balance = balance + 50 where id = 2;

release savepoint before_transfer;      -- 删除保存点，不提交事务
commit;

ROLLBACK TO SAVEPOINT 不结束事务；目标保存点之后创建的保存点会被删除。COMMIT 或不带保存点的 ROLLBACK 才会结束事务并清除全部保存点。InnoDB 回滚到保存点时不保证释放之后取得的全部内存行锁，因此保存点不能代替“缩短事务”。

7. 事务的隔离性和四种隔离级别

7.1 隔离性

MySQL服务被多个客户端同时访问，每个客户端执行的DML语句以事务为基本单位，那么不同的客户端在对同一张表中的同一条数据进行修改时就可能出现相互影响的情况，为保证不同事务直接执行时不受影响，因此事务之间就需要相互隔离

7.2 隔离级别及设置语法

隔离级别	脏读	不可重复读	幻读（SQL 标准）	InnoDB 主要行为
`READ UNCOMMITTED` 读未提交	可能	可能	可能	普通读可能看到未提交版本，业务中很少使用
`READ COMMITTED` 读已提交	避免	可能	可能	每条一致性读建立新快照；通常不使用间隙锁
`REPEATABLE READ` 可重复读	避免	避免	标准允许	InnoDB 默认；普通读复用快照，范围锁定读用 Next-Key Lock 防典型幻读
`SERIALIZABLE` 串行化	避免	避免	避免	显式事务中的普通读会按共享锁读处理，冲突等待更多

从上往下：并发性能越低，隔离度（安全性）越高

隔离越强不代表所有事务真的在全库中逐个执行。即使是 SERIALIZABLE，互不冲突的事务仍可并发；它主要通过更严格的锁让冲突操作等待，因此吞吐量通常更低。

涉及语法：

查看全局隔离级别
```
select @@global.transaction_isolation;
```

查看当前会话隔离级别

select @@session.transaction_isolation;

以下是设置SESSION隔离级别

设置事务的隔离级别和访问模式，可以使用以下语法：

# 通过 GLOBAL | SESSION 分别指定不同作用域
SET [GLOBAL | SESSION] TRANSACTION transaction_characteristic;

transaction_characteristic: {
      ISOLATION LEVEL level
    | access_mode
}

# 隔离级别
level: {
      REPEATABLE READ     # 可重复读
    | READ COMMITTED      # 读已提交
    | READ UNCOMMITTED    # 读未提交
    | SERIALIZABLE        # 串行化
}

# 访问模式
access_mode: {
      READ WRITE          # 事务可以读取和修改数据
    | READ ONLY           # 事务只能读取数据，不能修改普通表中的数据
}

# 示例

# 设置全局事务隔离级别为串行化
# 对之后新建的连接生效，不影响当前及已有连接
SET GLOBAL TRANSACTION ISOLATION LEVEL SERIALIZABLE;

# 设置当前会话的事务隔离级别为串行化
# 对当前会话后续的所有事务生效，不影响正在执行的事务
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;

# 不指定作用域时，只对当前会话的下一个事务生效
# 随后的事务恢复为之前的会话隔离级别
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

# 方式一：直接设置系统变量
SET GLOBAL transaction_isolation = 'SERIALIZABLE';

# 隔离级别中原本使用空格的位置，需要改成连字符
SET SESSION transaction_isolation = 'REPEATABLE-READ';


# 方式二：使用 @@GLOBAL 和 @@SESSION 设置系统变量
SET @@GLOBAL.transaction_isolation = 'SERIALIZABLE';

# 隔离级别中原本使用空格的位置，需要改成连字符
SET @@SESSION.transaction_isolation = 'REPEATABLE-READ';

使用系统变量赋值时值中写连字符，如 SET SESSION transaction_isolation='READ-COMMITTED'；使用 SET TRANSACTION ... LEVEL 语法时写空格。改变隔离级别前应确认作用域，做双会话实验时直接设置 SESSION 最清楚。

7.3 脏读示例

脏读：一个事务读取到了另一个事务尚未提交的数据。

客户端 A 设置 READ UNCOMMITTED

客户端 B 设置 READ UNCOMMITTED

客户端 A 开启事务并修改，但不提交

start transaction;

update bank_account
set balance = 100000
where name = '王五';

select *
from bank_account
where name = '王五';

客户端 A 自己看到：王五 100000.00

客户端 B 读取数据

start transaction;

select *
from bank_account
where name = '王五';

在 READ UNCOMMITTED 下，按照资料的实验逻辑，客户端 B 可以看到事务A尚未提交的修改：王五 100000.00

此时发生了脏读

客户端A                         客户端B
事务A                           事务B

START TRANSACTION
     │
UPDATE 王五=100000
     │
没有COMMIT
     │
     ├──────────────────────→ SELECT
     │                         读到100000
     │
ROLLBACK
     │
王五恢复2000
                               SELECT
                               读到2000

7.4 不可重复读示例

不可重复读：同一个事务中，使用相同条件读取同一行数据，两次得到的字段值不同。

客户端A                             客户端B
事务A                               事务B

START TRANSACTION
    │
SELECT 王五
    │
    └── 2000

                                START TRANSACTION
                                       │
                                UPDATE 王五=1000
                                       │
                                   尚未COMMIT

SELECT 王五
    │
    └── 2000
        ↑
        看不到B未提交的数据

                                   COMMIT
                                     │
                                     ↓
                                1000正式提交

SELECT 王五
    │
    └── 1000

事务A中：
第一次 = 2000
第二次 = 1000

→ 不可重复读
事务 A 中的两条查询完全相同，但第一次得到 2000，第二次得到 1000，因此称为“不可重复读”。

因为 InnoDB 在 READ COMMITTED 下，每次普通一致性查询都会建立一个新的数据快照，所以第二次查询可以看到其他事务新提交的修改。

在 REPEATABLE READ 下，同一个事务中的普通 SELECT 通常使用第一次查询建立的快照，所以能够保持重复读取结果一致。

7.5 幻读示例

幻读：同一个事务中，使用相同范围条件查询两次，第二次查询出现或消失了一些符合条件的记录

假设第一次查询余额不低于 1000 元的账户：

-- 事务 A
start transaction;

select *
from bank_account
where balance >= 1000;

第一次结果有两行：

id	name	balance
1	张三	1000
2	李四	1000

然后事务 B 插入一条符合条件的数据并提交：

-- 事务 B
start transaction;

insert into bank_account (name, balance)
values ('王五', 2000);

commit;

事务 A 再次执行相同查询：

select *
from bank_account
where balance >= 1000;

如果第二次结果变成三行：

id	name	balance
1	张三	1000
2	李四	1000
3	王五	2000

事务 A 会感觉像凭空出现了一条记录，因此称为“幻读”。

注意：

不可重复读是指同一行的值变了，而幻读是结果集中的行变了。

不可重复读通常是由另一个事务执行 update 并提交引起；

幻读通常是由另一个事务执行 insert 或 delete 并提交引起。

但 MySQL InnoDB 比较特殊

在InnoDB的 REPEATABLE READ 下，典型的幻读通常已经被解决。涉及到MVCC，Next-Key Lock。

7.6 串行化 SERIALIZABLE 解释

尽量让事务表现得像一个一个顺序执行。

事务A
  ↓
执行完成

事务B
  ↓
执行完成

事务C
  ↓
执行完成

8. MVCC 与一致性读原理

MVCC（多版本并发控制）让读操作在许多情况下不必阻塞写操作。InnoDB 聚集索引记录内部包含：

DB_TRX_ID：最后一次插入或更新该行的事务 ID；
DB_ROLL_PTR：指向 undo log 中的旧版本；
没有合适聚集键时还会使用隐藏的 DB_ROW_ID。

flowchart LR
    Q["一致性读与 Read View"] --> C["当前版本：trx 120"]
    C --> U1["undo 旧版本：trx 105"]
    U1 --> U2["undo 更旧版本：trx 88"]
    Q -.-> U1

查询读取当前记录后，用 Read View 判断创建该版本的事务对自己是否可见；不可见就沿 DB_ROLL_PTR 在 undo 版本链中寻找第一个可见版本。Read View 可近似理解为“生成快照时哪些事务已提交、哪些仍活跃”的可见性规则，不是复制出一整份数据库。

READ COMMITTED：每条普通 SELECT 建立新 Read View，所以同一事务后一次查询可能看到新提交；
REPEATABLE READ：通常由第一次一致性读建立 Read View，事务内后续普通读复用它；
当前事务自己的修改始终可见。

长事务会让旧版本长期不能清理，使 undo 膨胀并增加版本链读取成本，所以不要无故让事务长时间保持开启。

参考

MySQL 索引原理：B+ 树、数据页与查询优化

Tue, 04 Aug 2026 00:00:00 GMT

适用环境：MySQL 8.0，存储引擎以 InnoDB 为主。

索引的最终目标不是“数量多”，而是让常用查询以更少的页面访问得到更少的候选行。

1. 索引

索引是存储引擎维护的、有序的数据结构。它保存索引键及定位记录所需的信息，使 MySQL 不必从第一行扫描到最后一行

索引类似书的目录，但数据库索引还会随着数据变化而维护：

select 可能因索引减少扫描、排序和回表；
insert、delete、更新索引列时，需要同步修改索引；
索引占用磁盘与缓冲池空间；
优化器按成本选择执行计划，有索引不等于一定使用；

因此，索引是“以空间和写入成本换取读取效率”，适合高频查询，而不是给所有列机械建索引

2. InnoDB 主要使用 B+ 树

[!NOTE]

InnoDB 是 MySQL 的一种存储引擎，负责真正管理表的数据、索引、事务等底层操作

2.1 Hash 为什么不是默认选择

Hash 根据哈希值定位桶，平均等值查找很快，但键值没有顺序，难以支持 <、between、前缀排序和连续范围扫描。InnoDB 的普通索引只支持 B-tree；MEMORY 引擎才允许显式选择 Hash。InnoDB 内部的自适应哈希索引是一种自动优化机制，不能等同于用户创建的索引。

2.2 二叉树为什么不适合磁盘索引

普通二叉搜索树可能退化成链表；

AVL、红黑树虽能控制高度，但每个节点只有两个分支；

面对海量数据时树仍然较高；

索引节点通常按“页”存储，向下一层可能意味着访问另一个页面，所以数据库更希望一层容纳更多分支，减少树高和页面访问次数

2.3 B+ 树

2.3.1 B+树的优势

B+ 树是多路平衡查找树，核心特点如下：

非叶子节点主要保存分隔键和子页面指针，同一页可容纳较多分支，树通常很矮；
真正的索引记录集中在叶子层，从根到任意叶子的路径长度相同；
叶子页按键值顺序组织，并通过链表相连，找到范围起点后可顺序扫描；
插入、删除会触发页分裂、合并或重平衡，仍能保持有序和平衡；

flowchart TD
    R["根页：分隔键"]
    R --> I1["内部页 A"]
    R --> I2["内部页 B"]
    I1 --> L1["叶子页：1～20"]
    I1 --> L2["叶子页：21～40"]
    I2 --> L3["叶子页：41～60"]
    L1 <--> L2
    L2 <--> L3

等值查询沿根页逐层缩小范围；范围查询先定位第一个叶子记录，再沿叶子页有序扫描。MySQL 文档常统称其为 B-tree，讨论 InnoDB 实现原理时通常称 B+ 树。

2.3.2 B树与B+树的区别

区别	B树	B+树
数据存在哪里	所有节点	只有叶子节点
非叶子节点	保存数据	只保存索引
叶子节点	没有特殊关系	通过链表连接
范围查询	一般	非常方便
数据库使用	较少	大量使用

3. MySQL 中的页

3.1 InnoDB 的数据页

页是 InnoDB 管理索引和数据的基本单位，索引页默认大小为 16KB：

show variables like 'innodb_page_size';

每一个页中即使没有数据也会使用16KB的存储空间；

一次查询需要的页若已在 Buffer Pool 中，可直接从内存读取；不在时才需要从磁盘加载。按页读取利用了局部性：刚访问的数据及其附近数据，近期再次使用的概率较高。

一个索引页可概括为：

区域	作用
File Header / Trailer	页号、校验及前后页等信息
Page Header	记录数、目录槽数、空闲空间等页内状态
Infimum / Supremum	表示页内最小、最大边界的系统记录
User Records	按索引键组织的用户记录
Page Directory	保存分组末端记录的槽，辅助页内二分定位

数据页的基本结构如下图：

页内记录通过链表维持逻辑顺序；查询时先对 Page Directory 的槽做二分定位，再在很小的分组内查找。B+ 树解决“定位哪一页”，页目录解决“在这一页的哪里”。叶子页之间的双向链表则服务于跨页范围扫描。

类似“三层 B+ 树可存两千多万行”只是基于固定页大小、索引项和行大小的估算。真实容量会受主键长度、行格式、变长列、页填充率和分裂影响；实际查询也不等于固定发生三次磁盘 I/O，因为根页和热点页通常已被缓存。

3.2 页文件头和页文件尾

页文件头与页文件尾中包含的信息如下图：

上图中我们只关注：上一页页号和下一页页号，就类似链表中的头节点、尾节点链接形成一个双向链表

3.3 页主体

页主体是保存真实数据的主要区域，在每当创建一个新页时，都会自动分配两个行，分别是页内最小行Infimun、页内最大行Supremun，这两行实际不存储任何真实信息，而是做为数据行链表的头和尾。

此外，每一个数据行都有一个记录下一行的地址偏移量的区域next_record将页内所有数据行组成了一个单向链表，其结构图如下：

当有一个新页插入数据时，将Infimun连接第一个数据行,最后一行真实数据行连接Supremun，该单向链表就如下图结构所示：

3.4 页目录

为了避免沿着链表顺序逐个比对查找每个页数百行数据，InnoDB通过二分查找法来解决查找效率问题；

所利用的方式就是在每一页中加入一个叫页目录Page Directory的结构，将页内包括头行、尾行在内的所有行进行分组，约定头行单独为一组，其他组最多8条数据，同时把每个组最后一行在页中的地址按主键从小到大的顺序记录在页目录中；

页目录中的每一个位置称为一个槽，每个槽都对应了一个分组，一旦分组中的数据行超过分组的上限8个时，就会分裂出一个新的分组；

所以后续在查询某行时，通过二分查找，先找到对应的槽，随后在槽内最多8个数据行中进行遍历即可；

3.5 数据页头

数据页头记录了当前页保存数据相关的信息，如下图：

4. 聚集索引、二级索引与回表

4.1 聚集索引

每张 InnoDB 表都有一个聚集索引，其叶子记录保存完整行数据，数据按聚集键组织：

有 primary key：使用主键作为聚集索引；
无主键：选择第一个所有列都为 not null 的 unique 唯一索引作为聚集索引；
两者都没有：创建名为 GEN_CLUST_INDEX 的隐藏聚集索引，使用 6 字节行 ID，也就是偷偷生成DB_ROW_ID，按照这个 GEN_CLUST_INDEX 隐藏ID建立聚集索引；

所以“主键索引就是聚集索引”只适用于通常的 InnoDB 主键场景，并非概念上的绝对同义关系。主键应尽量短、稳定；因为主键值还会存入每个二级索引。递增主键通常有利于顺序插入，但仍应先满足业务身份和分布式设计要求

4.2 二级索引与回表

聚集索引之外的索引称为二级索引。其叶子记录主要保存“二级索引列 + 对应主键值”。例如往篇中提及的在 student_design2(name) 上建索引后，按姓名查询的过程是：

搜索姓名索引，得到匹配记录的主键 id；
再用 id 搜索聚集索引，取得完整学生行。

第二步叫回表。如果查询所需列已全部包含在同一个二级索引中，可直接返回，这叫覆盖索引。例如索引 (class_id, name) 可覆盖：

select class_id, name
from student_design2
where class_id = 1;

覆盖索引减少回表，但不要为了覆盖 select * 而建立过宽索引；宽索引会降低单页容量并增加写入成本。

5. 索引的分类

分类角度	类型	含义
业务与约束	主键、唯一、普通	主键标识行；唯一索引限制重复；普通索引只加速访问
索引列数	单列、复合	一个索引由一列或多列按顺序组成
InnoDB 存储	聚集、二级	叶子保存完整行，或保存索引键与主键
专用用途	全文、空间	全文检索使用倒排结构；空间索引使用 R-tree

约束负责数据规则，索引负责访问路径，两者不是同一种对象。primary key、unique 会用唯一索引实现；外键要求相关列存在可用索引，从表缺少时 MySQL 会自动创建，但这不代表外键就是索引。

6. 索引操作

6.1 手动创建索引

6.1.1 主键索引

主键列的值必须唯一且非空，一张表只能定义一个主键，但主键可以由多列组成。

方式一：建表时使用列级语法

适合单列主键，写法最简洁。

create table t_user_pk1 (
    id bigint unsigned primary key auto_increment,
    username varchar(30) not null
);

方式二：建表时使用表级语法

主键定义与字段定义分开，结构更清晰，并且可以定义复合主键。

create table t_user_pk2 (
    id bigint unsigned auto_increment,
    username varchar(30) not null,
    primary key (id)
);

方式三：给已有表添加主键

先添加主键，再设置自增，是因为 auto_increment 列必须受到索引支持。

create table t_user_pk3 (
    id bigint unsigned not null,
    username varchar(30) not null
);

alter table t_user_pk3
    add primary key (id);

alter table t_user_pk3
    modify id bigint unsigned not null auto_increment;

添加前必须检查已有的 id 是否包含 NULL 或重复值，否则主键创建会失败。CREATE INDEX 不能创建主键，已有表必须使用 ALTER TABLE ... ADD PRIMARY KEY；

6.1.2 唯一索引

唯一索引用于电话号码、学号、邮箱等不可重复的业务字段。若字段允许 NULL，MySQL 唯一索引通常允许多个 NULL；要求必须填写且唯一时，应同时定义 NOT NULL。

方式一：建表时使用列级语法

create table t_user_uk1 (
    id bigint unsigned primary key auto_increment,
    username varchar(30) not null unique
);

方式二：建表时命名唯一约束

显式命名便于根据业务含义识别和删除，工程中更推荐这种写法。

create table t_user_uk2 (
    id bigint unsigned primary key auto_increment,
    username varchar(30) not null,
    constraint uk_user_username unique (username)
);

方式三：给已有表添加唯一约束

alter table t_user_uk3
    add constraint uk_user_username unique (username);

方式四：使用独立的索引语句

create unique index uk_user_username
    on t_user_uk4 (username);

UNIQUE 强调“不允许重复”的数据规则，UNIQUE INDEX 强调实现该规则的索引结构；在 MySQL 中，两者都会建立唯一索引；

6.1.3 普通索引

普通索引只提供查询访问路径，不限制字段值重复。索引名建议使用 idx_表或业务_字段，便于维护。

方式一：建表时创建

create table t_user_idx1 (
    id bigint unsigned primary key auto_increment,
    phone varchar(20),
    index idx_user_phone (phone)
);

方式二：使用 `ALTER TABLE` 给已有表添加

alter table t_user_idx2
    add index idx_user_phone (phone);

方式三：使用 `CREATE INDEX` 独立创建

create index idx_user_phone
    on t_user_idx3 (phone);

方式二和方式三最终都给已有表增加索引。ALTER TABLE 适合把多项表结构调整写在一起，CREATE INDEX 的语义则更直观。

MySQL 8.0.13 及以上还支持函数索引，表达式需要额外一层括号：

create index idx_user_birth_year
    on t_user_idx3 ((year(birthday)));

函数索引保存的是表达式结果，适合不能改写成原列范围查询、且确实频繁使用相同表达式的场景；

6.2.4 复合索引

复合索引包含两个或更多索引列，创建语法与单列索引相同，只需按查询需要排列多个字段。具体利用规则见第 7 节“复合索引与最左前缀”。

方式一：建表时创建

create table t_user_multi1 (
    id bigint unsigned primary key auto_increment,
    class_id bigint unsigned not null,
    username varchar(30) not null,
    index idx_user_class_name (class_id, username)
);

方式二：使用 `ALTER TABLE` 添加

alter table t_user_multi2
    add index idx_user_class_name (class_id, username);

方式三：使用 `CREATE INDEX` 创建

create index idx_user_class_name
    on t_user_multi3 (class_id, username);

复合索引也可以具有主键或唯一属性：

-- 复合主键：同一学生与同一课程只能形成一条记录
primary key (student_id, course_id)

-- 复合唯一索引：同一班级中学号不能重复
unique index uk_student_class_sno (class_id, sno)

6.2 查看索引

6.2.1 查看完整索引信息

下面三种写法等价，实际使用一种即可：

show index from t_user_multi1;
show indexes from t_user_multi1;
show keys from t_user_multi1;

MySQL 命令行客户端可用 \G 将宽表结果纵向显示：

show keys from t_user_multi1\G

\G 是客户端结束符，不是标准 SQL 语法。在 DBeaver 中通常直接执行带分号的 SHOW INDEX，通过结果网格查看即可。

字段	含义
`Key_name`	索引名称；主键固定为 `PRIMARY`
`Non_unique`	`0` 表示不允许重复，`1` 表示允许重复
`Seq_in_index`	当前列在复合索引中的顺序，从 `1` 开始
`Column_name`	索引列名
`Cardinality`	不同值数量的估算，不是精确统计值
`Index_type`	索引结构，InnoDB 普通索引通常显示 `BTREE`
`Visible`	该索引是否对优化器可见
`Expression`	函数索引使用的表达式，普通列索引通常为 `NULL`

6.2.2 查看表结构摘要

desc t_user_multi1;

DESC 的 Key 列只提供摘要：PRI 表示主键，UNI 表示唯一索引，MUL 表示该列可出现重复值的索引。它不能完整展示索引名和复合索引列顺序，因此不能代替 SHOW INDEX。

6.2.3 查看真实建表定义

show create table t_user_multi1;

修改或删除索引前先查看建表语句，可以确认字段完整属性、约束名和索引名，避免删除错对象。

6.2.4 查看是否使用索引

使用 explain + select 查询可以知道该查询是否使用了索引以及使用了哪个索引

例如：

select_type：查询类型，常见有simple、primary、subquery、derived、union；
type：MySQL 访问这张表时采用什么方式。排序有以下

【好 <- system、const、eq_ref、ref、fulltext、ref_or_null、index_merge、unique_subquery、index_subquery、range、index、ALL -> 差】；

All：全表扫描

index：扫描全部索引树

range：扫描部分索引，索引范围扫描，对索引的扫描开始于某一点，返回匹配值域的行，常见于between、<、>等的查询

ref：使用非唯一索引或非唯一索引前缀进行的查找，不是主键或不是唯一索引

（eq_ref和const的区别）

eq_ref：唯一索引性扫描，对于每个索引键，表中只有一条记录与之匹配。常见于主键或唯一索引扫描

const、system：单表中最多有一个匹配行，查询起来非常迅速，例如根据主键或唯一索引查询。system是const类型的特例，当查询的表只有一行的情况下，使用system。

NULL：不用访问表或者索引，直接就能得到结果
possible_keys：MySQL 判断这条 SQL 可能使用的索引，但不代表最终真的用了；
key：这个才表示 MySQL 最终实际选择使用的索引；
Extra：执行情况的说明和描述，常见有以下

Extra	含义
`Using index`	使用覆盖索引，不需要回表读取完整行
`Using where`	还需要通过 WHERE 条件进行过滤
`Using index condition`	使用索引条件下推（ICP）
`Using temporary`	使用临时表
`Using filesort`	需要额外排序
`Using index for group-by`	GROUP BY / DISTINCT 等利用索引优化
`Impossible WHERE`	WHERE 条件不可能成立
`Select tables optimized away`	优化器可以直接得到结果，不需要按常规方式访问表
`NULL`	没有额外信息

6.3 修改索引

MySQL 可以重命名索引：

alter table t_user_multi1
    rename index idx_user_class_name to idx_user_class_username;

但不能直接修改索引包含的字段或字段顺序。此时应先删除旧索引，再创建新索引；把两个动作写在同一条 ALTER TABLE 中，可以清楚表达一次结构调整：

alter table t_user_multi1
    drop index idx_user_class_username,
    add index idx_user_name_class (username, class_id);

MySQL 8.0 还可修改非主键索引的可见性，用于验证优化器不使用该索引时的执行计划：

alter table t_user_multi1
    alter index idx_user_name_class invisible;

alter table t_user_multi1
    alter index idx_user_name_class visible;

不可见索引仍会在写入时维护，所以它不能减少索引的空间和写入成本。

6.4 删除索引

删除前先执行 SHOW CREATE TABLE 或 SHOW INDEX，原因是主键、唯一约束、外键和普通索引的删除语法及依赖关系不同。

6.4.1 删除主键索引

alter table t_user_pk1
    drop primary key;

主键名固定为 PRIMARY，不能使用普通的 DROP INDEX 索引名 代替。若主键列带有 auto_increment，并且主键是支持该自增列的唯一索引，直接删除会报错。应先核对字段完整定义，再移除自增属性：

-- 第一步：确认 unsigned、not null、default、comment 等原有属性
show create table t_user_pk1;

-- 第二步：只移除 auto_increment，其他需要保留的属性必须重新写全
alter table t_user_pk1
    modify id bigint unsigned not null;

-- 第三步：自增依赖解除后再删除主键
alter table t_user_pk1
    drop primary key;

MODIFY 不会自动保留未写出的字段属性，因此不能不看原定义就机械执行 MODIFY id BIGINT。生产表还应先检查该主键是否被其他表的外键引用。

6.4.2 删除普通、唯一或复合索引

以下两种写法等价：

drop index idx_user_phone on t_user_idx1;

alter table t_user_idx1
    drop index idx_user_phone;

删除唯一索引会同时取消它所实现的唯一性规则。删除复合索引会删除整个索引，不能只从索引中直接移除某一列；若需改变列组成，应删除后重建。

外键约束与支持外键的索引是两个对象。如果某索引仍被外键检查需要，MySQL 会拒绝直接删除；应先确认依赖，再决定是保留索引、建立替代索引，还是删除对应外键约束。

参考

MySQL 多表查询：JOIN、子查询、UNION 与执行计划

Tue, 28 Jul 2026 00:00:00 GMT

适用环境：MySQL 8.0（示例按 MySQL 8.0.39 编写）

1. 联合查询解决什么问题

规范化会把实体拆到不同表中；读取完整业务信息时，需要重新组合数据

“联合查询”在本章中是一个宽泛概念，主要包括：

类型	解决的问题	常用语法
表连接	横向组合有关联的表，增加列	`join`、`left join`
子查询	把一个查询的结果交给另一个查询使用	`in`、`exists`、标量子查询
集合查询	纵向合并多个结构相同的结果集，增加行	`union`、`union all`
查询结果写入	把查询出的行保存到表中	`insert ... select`、`create table ... select`

外键不会自动连接表，查询仍须写连接条件

2. 多表查询的逻辑与实际执行

2.1 用笛卡尔积理解逻辑结果

若 A 表有 3 行、B 表有 4 行，交叉连接会产生 3 × 4 = 12 行：

select *
from table_a cross join table_b;

内连接可在逻辑上理解为“组合后保留满足条件的行”：

select s.name, c.class_name
from student_design2 s
join class_design2 c on c.id = s.class_id;

漏写条件会使行数成倍膨胀；一对多连接还会按匹配数重复左侧行

2.2 MySQL 不一定真的生成完整笛卡尔积

笛卡尔积是逻辑模型，不等于物理执行。优化器会根据统计信息、索引和成本：

决定表的连接顺序，而不一定按 SQL 中的书写顺序
为每张表选择全表扫描、索引范围扫描或索引查找
选择嵌套循环连接或 Hash Join 等算法
尽早过滤无效行

MySQL 常用嵌套循环，合适的连接索引可加快内层查找。8.0.18 起支持 Hash Join，8.0.20 起用它替代 Block Nested-Loop 的场景

SQL 的逻辑处理顺序可简化为：

3. 内连接 INNER JOIN

3.1 语法

select 查询列
from 表1 别名1
[inner] join 表2 别名2 on 连接条件
where 普通过滤条件;

join 默认就是 inner join，内连接只返回两边能够匹配的行。

from a, b where ... 也能表达内连接，但工程中推荐显式 join ... on，因为它把连接条件与普通过滤分开，更不容易漏写条件

3.2 表别名与列歧义

多个表都有 id、name 时，裸写列名可能出现错误 1052。应使用短别名和 别名.列名：

select
    s.id as student_id,
    s.name as student_name,
    c.class_name
from student_design2 s
join class_design2 c on c.id = s.class_id
where s.name = '孙悟空';

3.3 三表、四表连接

查询每名学生的课程与成绩：

select
    s.sno,
    s.name,
    c.course_name,
    sc.score
from student_design2 s
join score_design2 sc on sc.student_id = s.id
join course_design2 c on c.id = sc.course_id
order by s.id, c.id;

每增加一张表都要确认连接列和连接基数；结果异常时检查条件、列和源数据。

3.4 连接后分组

统计每名学生已出分课程数和平均分：

select
    s.id,
    s.name,
    count(sc.score) as graded_count,
    avg(sc.score) as avg_score
from student_design2 s
join score_design2 sc on sc.student_id = s.id
group by s.id, s.name;

count(sc.score) 不统计 NULL，适合统计已出分课程；count(*) 统计结果行。开启 only_full_group_by 时，查询列应参与分组、被聚合，或能被分组列函数依赖

4. 外连接 OUTER JOIN

4.1 左连接与右连接

-- 保留左表全部行
select ...
from 表1 left join 表2 on 连接条件;

-- 保留右表全部行
select ...
from 表1 right join 表2 on 连接条件;

left join 保留左表全部行，右侧无匹配时补 NULL。交换表顺序即可把右连接改为左连接，项目中统一左连接通常更易读

统计所有班级人数，包括 0 人班级：

select
    c.id,
    c.class_name,
    count(s.id) as student_count
from class_design2 c
left join student_design2 s on s.class_id = c.id
group by c.id, c.class_name;

必须用 count(s.id)；若用 count(*)，外连接产生的空行会让空班级被统计为 1

4.2 查找“没有关联记录”的数据

查找没有任何选课记录的学生：

select s.id, s.sno, s.name
from student_design2 s
left join score_design2 sc on sc.student_id = s.id
where sc.student_id is null;

应检查右表中本来就不允许为 NULL 的主键或外键列。不要用 sc.score is null 判断“没有记录”，因为本系统允许 score 为 NULL 表示已选课但尚未出分。

这叫反连接模式，也可用 not exists 表达

4.3 ON 与 WHERE 的关键区别

on 决定如何匹配，where 过滤连接后的结果。右表条件放在 where 中会删除补出的 NULL 行，使左连接近似退化为内连接：

-- 只返回存在及格成绩的学生
select s.name, sc.score
from student_design2 s
left join score_design2 sc on sc.student_id = s.id
where sc.score >= 60;

要保留所有学生，只匹配及格成绩，应把条件写入 on：

select s.name, sc.score
from student_design2 s
left join score_design2 sc
    on sc.student_id = s.id and sc.score >= 60;

4.4 全外连接

MySQL 8.0 没有原生 full outer join，可用“左连接 + 反向左连接的未匹配部分”：

select a.id, b.id
from table_a a
left join table_b b on b.id = a.id
union all
select a.id, b.id
from table_b b
left join table_a a on a.id = b.id
where a.id is null;

5. 自连接 SELF JOIN

自连接不是新关键字，而是同一张表在一个查询中扮演不同角色，必须使用不同别名。比较同一学生的 MySQL 与 Java 成绩：

select s.name, m.score as mysql_score, j.score as java_score
from score_design2 m
join score_design2 j on j.student_id = m.student_id
join student_design2 s on s.id = m.student_id
join course_design2 cm on cm.id = m.course_id
join course_design2 cj on cj.id = j.course_id
where cm.course_name = 'MySQL'
  and cj.course_name = 'Java'
  and m.score > j.score;

用 m、j 区分两种成绩，用 student_id 保证比较同一学生。

6. 子查询

子查询嵌套在另一条语句中，其用法取决于返回一个值、一行、多行还是结果表。

6.1 标量子查询：返回一个值

查询高于全体平均分的成绩：

select student_id, course_id, score
from score_design2
where score > (
    select avg(score) from score_design2
);

单值比较要求子查询至多返回一行一列；返回多行会出现错误 1242。

6.2 多行子查询：IN

查询 Java 或 MySQL 课程的成绩：

select *
from score_design2
where course_id in (
    select id
    from course_design2
    where course_name in ('Java', 'MySQL')
);

in 表示等于集合中的任意值。若子查询含 NULL，not in 可能得到 unknown 而查不到行；排除关联记录时优先用 not exists，或显式排除 NULL。

6.3 EXISTS 与关联子查询

查询至少选过一门课的学生：

select s.id, s.name
from student_design2 s
where exists (
    select 1
    from score_design2 sc
    where sc.student_id = s.id
);

内层引用外层 s.id，属于关联子查询。exists 只判断匹配行是否存在；没有选课则用 not exists。

子查询不一定比连接慢。MySQL 可能将 in、exists 转为半连接或物化结果，应通过执行计划验证。

6.4 多列子查询

行构造器可让多个列作为一个整体比较：

select *
from score_demo
where (student_id, course_id, score) in (
    select student_id, course_id, score
    from score_demo
    group by student_id, course_id, score
    having count(*) > 1
);

内外列的数量、顺序、类型须对应。正式表已有复合主键，重复选课应在写入时被拒绝

6.5 FROM 中的子查询与 CTE

from 中的子查询称为派生表，MySQL 要求给它别名：

select t.class_id, t.avg_score
from (
    select s.class_id, avg(sc.score) as avg_score
    from student_design2 s
    join score_design2 sc on sc.student_id = s.id
    group by s.class_id
) t
where t.avg_score >= 80;

MySQL 8.0 还可用 with 名称 as (子查询) 定义 CTE，提高复杂查询可读性。派生表或 CTE 不代表一定创建磁盘临时表；优化器可能合并它，也可能物化后使用

6.6 如何选择

返回关联表列用 join；判断存在性用 exists；与单值比较用标量子查询；与集合比较用 in；复杂逻辑可用 CTE。先保证语义清楚，再验证性能

7. 集合查询

连接是在同一行上横向补列；集合操作把多个查询的结果纵向叠加

7.1 UNION 与 UNION ALL

select sno, name from current_student
union
select sno, name from archived_student;

select sno, name from current_student
union all
select sno, name from archived_student;

union 默认去除完全相同的结果行，需要额外的去重工作
union all 保留重复行，通常更快；业务允许重复时优先考虑
各查询必须返回相同列数，同一位置的数据类型应兼容
最终列名取第一个查询的列名或别名
整体排序应在最后写一次，并使用最终结果的列名：

select sno, name from current_student
union all
select sno, name from archived_student
order by sno;

7.2 MySQL 8.0.31 之后的集合运算

MySQL 8.0.31 新增 intersect（交集）和 except（差集）：

查询1 intersect [all | distinct] 查询2;

查询1 except [all | distinct] 查询2;

8.0.39 支持；旧版需用连接改写。集合运算默认 distinct。

8. 保存查询结果

8.1 INSERT ... SELECT

把查询结果插入已有表：

insert into excellent_student (student_id, avg_score)
select student_id, avg(score)
from score_design2
group by student_id
having avg(score) >= 90;

目标列与查询列的数量、顺序、类型须对应，并应显式写目标列名。目标表约束仍会执行；自增列通常省略

它只复制数据。大量迁移前先单独核对 select，并按原子性要求使用事务

8.2 CREATE TABLE ... SELECT

根据查询结果直接创建新表：

create table class_score_report as
select
    s.class_id,
    count(sc.score) as graded_count,
    avg(sc.score) as avg_score
from student_design2 s
join score_design2 sc on sc.student_id = s.id
group by s.class_id;

它适合临时报表，但不会自动创建索引，auto_increment 等属性也可能丢失，表达式应起别名。复制同构表通常使用：

create table student_backup like student_design2;
insert into student_backup select * from student_design2;

like 复制字段属性和索引，但不复制外键；完成后用 show create table 检查

9. 用 EXPLAIN 理解执行计划

不要凭 SQL 外观猜性能，应查看执行计划：

explain analyze
select s.name, sc.score
from student_design2 s
join score_design2 sc on sc.student_id = s.id;

explain 展示估算计划；explain analyze 会实际执行并显示行数与耗时，不要对高风险语句随意使用

重点检查：

实际连接顺序及各步读取行数
key 是否使用预期索引，是否出现不必要的 ALL 扫描
估算与实际行数是否差异很大
是否出现 Hash Join、临时表、排序或大量循环

连接列两侧类型应一致，被驱动表的连接列需要可用索引；复合索引应依据真实筛选和排序设计。索引会增加写入成本，并非越多越好

10. 常见错误与排查

现象	常见原因	检查方法
结果行数异常巨大	漏写条件，或误判连接基数	分步连接并统计行数
错误 1052	多表存在同名列	使用 `表别名.列名`
左连接查不到无匹配行	右表条件写进了 `where`	判断条件是否应移入 `on`
无记录被误判	检查了可为 `NULL` 的业务列	检查右表非空主键/外键
错误 1242	标量子查询返回多行	改用 `in`，或保证只返回一行
`not in` 意外返回空集	子查询含 `NULL`	改用 `not exists` 或排除 `NULL`
`union` 报列数错误	各查询列数不同	逐个执行并核对列的位置
聚合结果偏大	连接先重复了事实行	确认表粒度和连接基数

排查时先验证单表条件，再一次加入一张表和一个 on，比较每步行数，最后添加分组与排序。连接错误进入聚合后，常只留下看似合理的错误数字

11. 综合查询

查询所有学生的班级、已选课程数、平均分，并保留没有选课的学生：

select
    s.id,
    s.sno,
    s.name,
    c.class_name,
    count(sc.course_id) as course_count,
    round(avg(sc.score), 2) as avg_score
from student_design2 s
join class_design2 c on c.id = s.class_id
left join score_design2 sc on sc.student_id = s.id
group by s.id, s.sno, s.name, c.class_name
order by avg_score desc, s.id;

设计原因：

学生必须属于有效班级，所以学生与班级使用内连接。
学生可以暂时没有选课，所以成绩使用左连接。
count(sc.course_id) 让无选课学生得到 0，而不是 1。
avg 忽略未出分的 NULL；没有有效成绩时仍为 NULL，不同于 0 分。
聚合发生在连接之后，因此分组必须与“一名学生一行”的目标粒度一致。

12. 总结

内连接只保留匹配行；外连接还保留指定一侧的未匹配行。
on 决定如何匹配，where 过滤连接结果；自连接靠角色别名区分。
子查询按结果形态选择 =、in、exists 或派生表，not in 要警惕 NULL。
union 去重，union all 保留重复且通常更高效。
insert ... select 写入已有表；create table ... select 创建表并写入。
笛卡尔积解释逻辑语义，物理执行和性能必须通过 explain 验证。

参考

关系数据库设计：实体关系、函数依赖与三大范式

Sun, 26 Jul 2026 00:00:00 GMT

适用环境：MySQL 8.0（示例按 MySQL 8.0.39 编写）

1. 数据库设计

数据库设计首先考虑的是以下问题：

业务中有哪些需要长期保存的对象？
每个对象应该保存哪些属性？
一行数据代表什么，即表的粒度是什么？
哪些字段能够唯一标识一行？
对象之间是一对一、一对多还是多对多？
哪些数据会重复，修改时是否可能产生不一致？
常用查询是什么，需要怎样的索引？

1.1 类、实体与表

分析层次	含义	学生系统示例
概念类	从现实业务中抽象出的对象	学生、班级、课程
实体	需要长期保存的数据对象	某个具体学生
表	实体在关系数据库中的存储结构	`student_design2`
属性	实体具有的特征	学号、姓名、出生日期
列	属性在表中的实现	`sno`、`name`、`birthday`

类、实体和表经常近似一一对应，但不能机械地认为“一个 Java 类必须是一张表”。DTO、VO 通常不需要建表，集合属性往往要设计为子表或中间表。

2. 部分概念

2.1 表的粒度

粒度指“一行数据到底描述什么”

例如，成绩表的一行可以定义为：

一名学生对一门课程的最终成绩。

于是 (student_id, course_id) 可以唯一确定一行。如果业务改为“一名学生同一门课程可以补考多次”，原粒度就不够了，应增加 attempt_no，或单独设计考试场次表。

2.2 候选键、主键与业务键

候选键：能够唯一标识一行的最小字段集合。
主键：从候选键中选出的主要行标识。
业务键：业务本身具有唯一性的字段，如学号、课程编号。
代理键：没有业务含义、专门用于标识行的字段，如自增 id。

学生表可以使用自增 id 作为主键，同时给 sno 添加唯一约束。这样连接时主键稳定，数据库又能保证学号不重复。

2.3 函数依赖

若已知 A 的值，就能唯一确定 B 的值，可以写成：

A → B

例如：

学号 → 学生姓名
课程编号 → 课程名、学分
(学号, 课程编号) → 成绩

范式的核心就是检查：每个非关键字段究竟依赖谁。

3. 数据库范式

范式是一组减少重复和异常的设计规则。常见范式包括 1NF、2NF、3NF、BCNF、4NF 和 5NF。一般业务系统先把表设计到第三范式，再根据明确的性能证据决定是否反范式。

3.1 第一范式

一列保存一个业务意义上的值

第一范式（1NF）要求每个字段在当前业务语义下是原子的，不能在一列中保存一组可独立查询和维护的值。

反例：

student_id	name	course_ids
1	张三	`1,2,5`

course_ids 保存了多个课程编号，难以使用外键、连接和普通索引，也容易在增删编号时破坏格式。

正确方式是把选课关系拆成多行：

student_id	course_id
1	1
1	2
1	5

“原子”与业务语义有关。地址在只展示的场景中可以是一个字符串；若要按省、市统计，就应拆成独立字段或关联地区表。因此，字段使用了 MySQL 基本数据类型，并不代表设计天然合理。

3.2 第二范式

消除对复合候选键的部份依赖

第二范式（2NF）建立在 1NF 之上，要求每个非关键字段依赖候选键的全部字段，而不是只依赖其中一部分。

假设把所有数据放进一张表：

student_course(
  sno, course_code, student_name, birthday,
  course_name, credit, score
)

候选键是 (sno, course_code)，但实际依赖关系为：

sno → student_name, birthday
course_code → course_name, credit
(sno, course_code) → score

学生信息只依赖 sno，课程信息只依赖 course_code，因此发生了部分依赖，应拆为：

学生表：保存 sno → 学生属性。
课程表：保存 course_code → 课程属性。
成绩表：保存 (sno, course_code) → score。

不满足 2NF 容易产生四类异常：

数据冗余：学生姓名和课程学分反复保存。
更新异常：修改学分时必须更新多行，可能出现不同值。
插入异常：还没有学生选课时，无法单独录入新课程。
删除异常：删除最后一条成绩时，课程信息也被误删。

如果所有候选键都是单列，就不存在“只依赖键的一部分”，因此不会违反 2NF；但仍可能违反 3NF。

3.3 第三范式

消除非关键字段的传递依赖

第三范式（3NF）建立在 2NF 之上，重点消除非关键字段通过另一个非关键字段间接依赖候选键的情况。

反例：

student(
  id, sno, name, college_id,
  college_name, college_phone
)

依赖链为：

id → college_id → college_name, college_phone

学院名称和电话描述的是学院，不是学生。若每个学生都保存一份学院电话，修改时就会产生大量重复更新。应拆成：

student(id, sno, name, college_id)
college(id, college_name, college_phone)

记忆方式：

非关键字段应依赖于键、依赖于整个键，并且只依赖于键。

3.4 范式不是拆表越多越好

范式主要保证一致性和可维护性，不直接保证查询最快。拆表过多会增加连接查询和维护成本；反范式则会增加重复数据及同步成本。

合理顺序是先按 3NF 建立正确模型，再用真实慢查询和执行计划确认瓶颈。只有收益明确时，才增加汇总表或缓存列，并设计可靠的同步机制；不要仅凭“以后可能更快”就提前反范式。

4. E-R 图与关系落地

E-R 图用于在写 SQL 前表达实体、属性、关系、基数和可选性。矩形通常表示实体，属性描述实体特征，连线表示关系。

4.1 一对一关系（1:1）

一对一关系必须同时保证“能够引用”和“不能重复引用”。只添加普通 account_id 并不能阻止多个用户指向同一个账户。

最严格的实现是让从表主键同时充当外键：

create table user_profile (
    user_id bigint unsigned primary key,
    nickname varchar(30),
    constraint fk_user_profile_user
        foreign key (user_id) references users(id)
);

因为 user_id 是主键，所以同一用户最多只有一份档案。若使用独立主键，则关联列必须再加 unique。外键放在哪一侧，应根据生命周期和访问方向决定。

4.2 一对多关系（1:N）

把“一”方主键保存到“多”方：

class_design2.id ← student_design2.class_id

原因是一个班级对应多名学生，而每名学生只需要保存一个所属班级编号。不要在班级表中保存用逗号拼接的学生编号。

4.3 多对多关系（M:N）

关系数据库不能用一个普通外键直接表达多对多，需要建立中间表：

student_design2
        ↓ 1:N
score_design2
        ↑ N:1
course_design2

中间表不仅保存两端主键，还可以保存关系自身的属性，如成绩、选课时间、状态。若业务规定同一学生只能选同一课程一次，应使用复合主键或联合唯一约束防止组合重复。

5. 从需求到建表的设计过程

操作顺序不能颠倒：先澄清能否退课、重修和多次考试等规则，才能确定实体粒度；再用候选键和基数表达关系，通过范式检查消除错误依赖；最后根据数据范围选择类型与约束，并用真实查询设计索引。建表后还要主动测试重复学号、无效班级、重复选课和越界成绩。

6. 学生选课系统完整设计

下面是我练习用的四张练习表。

create database if not exists design_study
    character set utf8mb4
    collate utf8mb4_0900_ai_ci;

use design_study;

drop table if exists score_design2;
drop table if exists student_design2;
drop table if exists course_design2;
drop table if exists class_design2;

create table class_design2 (
    id bigint unsigned primary key auto_increment,
    class_name varchar(30) not null,
    constraint uk_class_design2_name unique (class_name)
) engine = InnoDB;

create table course_design2 (
    id bigint unsigned primary key auto_increment,
    course_code varchar(20) not null,
    course_name varchar(50) not null,
    credit decimal(3, 1) not null,
    constraint uk_course_design2_code unique (course_code),
    constraint ck_course_design2_credit
        check (credit between 0.5 and 20.0)
) engine = InnoDB;

create table student_design2 (
    id bigint unsigned primary key auto_increment,
    sno varchar(20) not null,
    name varchar(30) not null,
    birthday date,
    gender tinyint unsigned,
    enroll_date date not null,
    class_id bigint unsigned not null,
    constraint uk_student_design2_sno unique (sno),
    constraint ck_student_design2_gender
        check (gender in (0, 1, 2)),
    constraint fk_student_design2_class
        foreign key (class_id)
        references class_design2(id)
        on delete restrict
) engine = InnoDB;

create table score_design2 (
    student_id bigint unsigned not null,
    course_id bigint unsigned not null,
    score decimal(5, 2),
    selected_at datetime not null default current_timestamp,
    constraint pk_score_design2
        primary key (student_id, course_id),
    constraint ck_score_design2_score
        check (score is null or score between 0 and 100),
    constraint fk_score_design2_student
        foreign key (student_id)
        references student_design2(id)
        on delete restrict,
    constraint fk_score_design2_course
        foreign key (course_id)
        references course_design2(id)
        on delete restrict
) engine = InnoDB;

6.1 关键设计原因

学号使用 varchar，因为编号可能有前导 0，也不参与数学运算。
保存 birthday 而不是 age，因为年龄会随时间变化，可在查询时计算。
学分和成绩使用 decimal，避免 float 的近似值误差。
score 允许为 null，用于表示已经选课但尚未出分；0 表示实际得了 0 分。
成绩表使用 (student_id, course_id) 复合主键，直接表达“一名学生一门课程一条记录”。
on delete restrict 防止误删学生或课程后连带丢失成绩。是否级联删除必须由业务规则决定。
班级表不保存 student_count，因为人数可从学生表统计，重复保存会产生同步问题。

如果需要记录补考或多次考试，应将主键改为 (student_id, course_id, attempt_no)，或增加考试场次表，不能继续假设一门课程只有一个成绩。

7. 常用验证与查询

7.1 检查实际表结构

show create table score_design2;
show index from score_design2;

SHOW CREATE TABLE 用于检查主键、外键、检查约束和引擎；SHOW INDEX 用于检查索引列顺序。设计文档写了什么不重要，数据库实际创建出的结构才是最终结果。

7.2 统计班级人数

select
    c.id,
    c.class_name,
    count(s.id) as student_count
from class_design2 c
left join student_design2 s on s.class_id = c.id
group by c.id, c.class_name;

使用 left join 是为了让暂时没有学生的班级也能显示为 0 人。

参考资料

MySQL 约束：数据完整性、主外键与检查规则

Sat, 25 Jul 2026 00:00:00 GMT

适用环境：MySQL 8.0（本文实操按 MySQL 8.0.39 编写）

1. 数据库约束

1.1 概念

数据库约束（Constraint）是数据库对表中数据设置的规则。

当执行 insert、update 或某些 delete 操作时，MySQL 会检查数据是否满足这些规则：

满足规则：允许操作
不满足规则：拒绝操作并返回错误

比如，一个学生系统可能有以下要求：

学生姓名不能为空
年龄不小于 16 岁
每名学生的学号不能重复
每条学生记录必须有一个唯一编号
学生填写的班级编号必须在班级表中真实存在

如果只把这些要求写在需求文档中，数据库并不会自动遵守;

只有把它们定义为约束，数据库才会在每次写入时主动检查

可以把约束理解为数据库的“数据守门员”。应用程序可以提前校验用户输入，但数据库约束负责守住最终的数据底线。

1.2 数据完整性的四个角度

这张图说明：

primary key 解决“这一行是谁”的问题；
not null、default、check 和数据类型共同限制“这一列可以放什么”；
unique 解决“业务值不能重复”的问题；
foreign key 解决“引用的另一行是否存在”的问题；

1.3 常用约束

约束	中文名称	核心作用	典型字段
`not null`	非空约束	不允许列值为 SQL `null`	姓名、创建时间
`default`	默认值约束	未指定列值时自动使用默认值	状态、年龄、创建时间
`unique`	唯一约束	限制一列或一组列的非空组合不能重复	学号、手机号、用户名
`primary key`	主键约束	唯一且非空地标识每一行	`id`
`foreign key`	外键约束	保证从表引用的主表记录存在	`class_id`、`student_id`
`check`	检查约束	限制值范围或列之间的关系	年龄、分数、开始结束时间

1.4 列级表级写法

约束可以写在列定义后面，也可以单独写成表级约束。

列级写法

create table constraint_demo (
    id bigint primary key auto_increment,
    name varchar(20) not null,
    age int default 18,
    sno varchar(20) unique,
    score decimal(5, 2) check (score between 0 and 100)
);

这种写法简洁，适合只涉及一个字段的约束。

表级写法

create table constraint_demo (
    id bigint auto_increment,
    name varchar(20) not null,
    sno varchar(20),
    score decimal(5, 2),

    constraint pk_constraint_demo primary key (id),
    constraint uk_constraint_demo_sno unique (sno),
    constraint ck_constraint_demo_score
        check (score between 0 and 100)
);

表级写法优点：

可以给约束起名称，后续删除和排错更方便。
可以定义包含多个字段的复合约束。

本文在综合建表中优先采用“字段定义在前、命名约束集中放在后面”的写法，原因是结构更清晰，也更符合正式项目的维护需求。

1.5 约束命名

对象	推荐前缀	示例
主键约束	`pk_`	`pk_student_design2`
唯一约束或唯一索引	`uk_`	`uk_student_design2_sno`
外键约束	`fk_`	`fk_student_design2_class`
检查约束	`ck_`	`ck_score_design2_score`
普通索引	`idx_`	`idx_student_design2_name`

命名的目的是让错误信息、建表语句和后续修改更容易读懂

注意：MySQL 中主键对应的索引名称固定显示为 PRIMARY。pk_ 名称仍可用于设计文档、迁移脚本的可读性以及其他数据库系统，但不要依赖 MySQL 一定保留自定义主键名称。

2. NOT NULL 非空约束

2.1 作用

not null 表示该列不能保存 SQL 中的空值 null。

例如，学生姓名是识别学生的基本信息。如果允许姓名为 null，就可能出现一条不完整的学生记录。

2.2 不加非空约束时

drop table if exists student_not_null_demo;

create table student_not_null_demo (
    id bigint,
    name varchar(20)
);

insert into student_not_null_demo (id, name)
values (1, null);

select * from student_not_null_demo;

结果中会出现：

id	name
1	`NULL`

原因是 name 没有 not null，MySQL 认为 null 是合法值。

2.3 添加非空约束

drop table if exists student_not_null_demo;

create table student_not_null_demo (
    id bigint,
    name varchar(20) not null
);

再次插入：

insert into student_not_null_demo (id, name)
values (1, null);

会出现类似错误：

ERROR 1048 (23000): Column 'name' cannot be null

错误产生的原因是待插入的 null 违反了 name 列的非空约束。

正常数据可以成功写入：

insert into student_not_null_demo (id, name)
values (1, '张三');

2.4 `NULL`、空字符串和数字 0 的区别

区别：

值	含义	是否违反 `not null`
`null`	未知、缺失或不适用	是
`''`	已知是一个长度为 0 的字符串	否
`' '`	由空格组成的字符串	否
`0`	一个明确的数字	否

以下语句不会违反 not null：

insert into student_not_null_demo (id, name)
values (2, '');

但空字符串通常也不是合法姓名。not null 只能阻止 null，不能自动阻止空字符串。因此正式项目还需要后端校验，或根据业务使用更合适的 check 约束。

2.5 查看非空约束

desc student_not_null_demo;

Null 列的含义：

NO：不允许为 null。
YES：允许为 null。

更完整的检查方式：

show create table student_not_null_demo;

desc 适合快速查看字段概况，show create table 更适合检查真实、完整的建表定义。

2.6 给已有列添加非空约束

先检查是否已经存在 null：

select *
from student_not_null_demo
where name is null;

必须先检查，原因是已有脏数据会导致添加约束失败。

如果业务允许把缺失姓名统一改成“待补充”，可以先清理：

update student_not_null_demo
set name = '待补充'
where name is null;

然后修改字段：

alter table student_not_null_demo
modify name varchar(20) not null;

使用 modify 时要把字段类型、长度以及需要保留的字段属性重新写完整。不要只写 not null，否则可能意外丢失原有定义。

2.7 删除非空约束

MySQL 没有单独的 drop not null 写法。要把该列重新修改为允许 null：

alter table student_not_null_demo
modify name varchar(20) null;

3. DEFAULT 默认值约束

3.1 作用

default 用于指定字段的默认值。

当 insert 语句没有给该字段赋值时，MySQL 会自动使用默认值。

例如，学生的默认年龄设为 18：

drop table if exists student_default_demo;

create table student_default_demo (
    id bigint primary key auto_increment,
    name varchar(20) not null,
    age int default 18
);

3.2 省略字段时使用默认值

insert into student_default_demo (name)
values ('张三');

select * from student_default_demo;

结果：

id	name	age
1	张三	18

原因是插入时没有指定 age，因此 MySQL 使用了默认值 18。

3.3 显式写 `NULL` 不等于省略字段

insert into student_default_demo (name, age)
values ('李四', null);

由于 age 允许为 null，最终存入的是 null，而不是默认值 18。

两种情况要明确区分：

没有给 age 赋值：使用默认值。
明确给 age 赋 null：保存 null，前提是该列允许为 null。

如果要求年龄既不能缺失，又希望不填写时使用 18，应同时使用：

age int not null default 18

此时：

insert into student_default_demo (name)
values ('王五');

会使用默认值；而：

insert into student_default_demo (name, age)
values ('赵六', null);

会违反 not null。

3.4 使用 `DEFAULT` 关键字

除了省略字段，也可以显式要求使用默认值：

insert into student_default_demo (name, age)
values ('钱七', default);

更新时也可以恢复为默认值：

update student_default_demo
set age = default
where name = '钱七';

3.5 常用的时间默认值

create table article_demo (
    id bigint primary key auto_increment,
    title varchar(100) not null,
    create_time datetime not null default current_timestamp,
    update_time datetime not null
        default current_timestamp
        on update current_timestamp
);

含义：

新增记录时，create_time 和 update_time 自动写入当前时间。
更新记录时，update_time 自动变为本次更新时间。

这适合记录数据创建时间与最后修改时间。

3.6 修改和删除默认值

添加或修改默认值：

alter table student_default_demo
alter column age set default 18;

删除默认值：

alter table student_default_demo
alter column age drop default;

删除默认值不会删除已有数据，只会影响之后没有指定该字段的新写入。

3.7 `DEFAULT` 不能替代业务校验

默认值只负责“未填写时用什么”，不负责“填写的值是否合理”。

例如：

age int default 18

仍然允许写入 -100。如果年龄必须不小于 16，还应增加：

constraint ck_student_age check (age >= 16)

4. UNIQUE 唯一约束

4.1 作用

unique 保证某一列或某一组列的值不重复。

典型场景包括：

学号不能重复。
用户名不能重复。
手机号不能重复。
同一个学生不能重复选择同一门课程。

4.2 单列唯一约束

drop table if exists student_unique_demo;

create table student_unique_demo (
    id bigint primary key auto_increment,
    name varchar(20) not null,
    sno varchar(20),

    constraint uk_student_unique_demo_sno unique (sno)
);

正常插入：

insert into student_unique_demo (name, sno)
values ('张三', '20260001');

重复插入相同学号：

insert into student_unique_demo (name, sno)
values ('李四', '20260001');

会出现类似错误：

ERROR 1062 (23000): Duplicate entry '20260001'
for key 'student_unique_demo.uk_student_unique_demo_sno'

错误原因是学号 20260001 已经存在，违反了唯一约束。

4.3 MySQL 的唯一约束允许多个 `NULL`

如果唯一列本身允许 null，MySQL 允许多行都保存 null：

insert into student_unique_demo (name, sno)
values ('王五', null);

insert into student_unique_demo (name, sno)
values ('赵六', null);

两条语句都可以成功。

原因是 SQL 中的 null 表示未知，两个未知值不会被直接判定为相等。

如果业务要求“学号必须填写并且不能重复”，应该组合使用：

sno varchar(20) not null,
constraint uk_student_unique_demo_sno unique (sno)

4.4 联合唯一约束

联合唯一约束同时检查多个字段的组合。

例如，规定同一个班级内学生姓名不能重复：

create table class_student_name_demo (
    id bigint primary key auto_increment,
    class_id bigint not null,
    name varchar(20) not null,

    constraint uk_class_student_name
        unique (class_id, name)
);

以下两行可以同时存在：

class_id	name	是否允许
1	张三	允许
2	张三	允许

因为组合 (1, '张三') 与 (2, '张三') 不同。

但再次插入 (1, '张三') 会冲突。

联合唯一约束限制的是“字段组合不能重复”，不是要求每个字段各自都唯一。

4.5 唯一约束与唯一索引

下面两种 MySQL 写法都能限制 username 不重复：

constraint uk_index_user_username unique (username)

unique index uk_index_user_username (username)

其中：

uk_index_user_username 是人为指定的名称。
uk 常用来表示 unique key。
index_user 可以表示表名。
username 表示被约束的字段。

从概念上看：

唯一约束表达的是数据规则：“值不能重复”。
唯一索引是 MySQL 实现并快速检查这条规则的数据结构。

因此二者密切相关，但“约束”和“索引”仍然不是同一个概念。普通索引只用于提高查询效率，并不会禁止重复值。

4.6 添加和删除唯一约束

为了让下面的 alter table 可以直接练习，先创建一张尚未设置唯一约束的表：

drop table if exists student_unique_alter_demo;

create table student_unique_alter_demo (
    id bigint primary key auto_increment,
    sno varchar(20)
);

添加前先检查重复数据：

select sno, count(*) as duplicate_count
from student_unique_alter_demo
where sno is not null
group by sno
having count(*) > 1;

必须先检查，原因是只要存在一组重复数据，添加唯一约束就会失败。

添加：

alter table student_unique_alter_demo
add constraint uk_student_unique_alter_sno unique (sno);

在 MySQL 中删除唯一约束通常使用索引名称：

alter table student_unique_alter_demo
drop index uk_student_unique_alter_sno;

5. PRIMARY KEY 主键约束

5.1 作用

主键用于唯一标识表中的每一行数据。

主键具有三个核心特点：

主键值不能重复。
主键列不能为 null。
一张表只能有一个主键约束，但这个主键可以由一个或多个字段组成。

注意“一张表只能有一个主键”不等于“主键只能有一列”。多列可以共同组成一个复合主键。

5.2 常用的自增主键

drop table if exists student_primary_demo;

create table student_primary_demo (
    id bigint primary key auto_increment,
    name varchar(20) not null
);

插入时可以省略 id：

insert into student_primary_demo (name)
values ('张三'), ('李四');

MySQL 会生成主键值。

auto_increment 的作用是让数据库生成递增编号，减少应用程序自行计算主键时产生冲突的风险。

5.3 常用 `BIGINT`

在业务系统中，主键常用：

id bigint primary key auto_increment

原因包括：

bigint 的可用范围大，数据量增长后不容易耗尽。
整数比较和索引处理通常比较直接。
Java 中可以使用 Long 对应。

但“所有项目必须使用自增 bigint”并不是绝对规则。分布式系统也可能使用雪花 ID、UUID 或其他全局 ID。当前学习阶段先掌握自增整数主键最合适。

5.4 自增主键不保证连续

下面这些情况都可能让 ID 出现空缺：

插入失败前已经申请了自增值。
事务回滚。
删除了一行数据。
并发插入。
手工插入了更大的主键值。

因此：

主键只负责唯一标识。
不要把“必须连续”当成主键规则。
不要用主键是否连续判断数据有没有被删除。

例如出现 1、2、4、5 是正常现象，缺少 3 不代表数据库损坏。

5.5 `PRIMARY KEY` 与 `NOT NULL + UNIQUE` 的区别

从数据限制上看，单列主键确实同时具有“非空”和“唯一”的效果，但下面两种定义仍然不是完全相同的概念：

id bigint primary key

id bigint not null unique

主要区别：

对比点	`primary key`	`not null unique`
语义	表中每行的主要身份标识	一个不能为空且不能重复的候选字段
每张表数量	只能有一个主键约束	可以有多个唯一约束
InnoDB 组织方式	主键通常作为聚簇索引键	通常属于二级唯一索引
外键引用	最常用、最清晰	也可作为候选键被引用，但设计语义不同

为什么 `DESC` 有时会把 `NOT NULL UNIQUE` 显示为 `PRI`

当表没有显式主键时，MySQL 的某些元数据展示会把第一个“非空唯一索引”作为主键候选显示。不能因此断定建表语句中真的声明了 primary key。

最可靠的检查方法是：

show create table student_primary_demo;

如果输出中明确存在：

primary key (`id`)

才能确认它是显式定义的主键。

不要仅凭 desc 的 Key 列判断所有约束。desc 是摘要，show create table 才能还原更完整的定义。

5.6 复合主键

成绩表天然适合使用“学生编号 + 课程编号”组成主键：

create table score_primary_demo (
    student_id bigint not null,
    course_id bigint not null,
    score decimal(5, 2),

    constraint pk_score_primary_demo
        primary key (student_id, course_id)
);

以下数据可以同时存在：

student_id	course_id	score
1	1	90.00
1	2	85.00
2	1	88.00

但 (student_id, course_id) = (1, 1) 不能再次出现。

它表达的业务规则是：

同一名学生对同一门课程只能有一条成绩记录。

5.7 复合主键与联合唯一约束

二者都能限制字段组合不重复，但角色不同：

primary key (student_id, course_id)

表示这两个字段的组合就是该行的主要身份标识。

id bigint primary key auto_increment,
unique (student_id, course_id)

表示：

id 是该行的主身份标识。
(student_id, course_id) 是额外的业务唯一规则。

两种设计都可能合理：

设计	优点	适合场景
复合主键 `(student_id, course_id)`	直接表达业务身份，不需要额外 `id`	纯关联表、结构较简单
自增主键 `id` + 联合唯一约束	其他表引用方便，ORM 使用较简单	关联记录还会被其他表引用，或项目统一使用单列主键

5.8 添加和删除主键

为了单独练习主键变更，先使用一张不带 auto_increment 的测试表：

drop table if exists student_primary_alter_demo;

create table student_primary_alter_demo (
    id bigint not null,
    name varchar(20) not null
);

给已有字段添加主键前，要保证该字段没有 null 且没有重复值：

select id, count(*) as duplicate_count
from student_primary_alter_demo
group by id
having count(*) > 1;

添加主键：

alter table student_primary_alter_demo
add primary key (id);

删除主键：

alter table student_primary_alter_demo
drop primary key;

生产环境删除主键属于高风险结构变更，原因是它可能影响外键、索引组织、查询性能及其他依赖。实际项目中应先检查依赖并做好变更方案。

如果主键列还带有 auto_increment，通常不能直接删除它唯一可用的键；应先设计新的键方案并处理 auto_increment 属性。不要把上面的简单测试语句直接用于生产表。

6. FOREIGN KEY 外键约束

6.1 外键解决什么问题作用

外键用于保证表与表之间引用关系的完整性。

例如：

班级表保存班级。
学生表通过 class_id 保存学生所属班级。

如果学生表中出现 class_id = 100，但班级表根本没有编号 100 的班级，这条数据就失去了真实指向。外键可以阻止这种无效引用。

6.2 主表、从表、主键和外键

以班级与学生为例：

术语	对应对象	说明
主表、父表、被引用表	`class_design2`	保存被其他表引用的班级
从表、子表、引用表	`student_design2`	保存外键并引用班级
被引用键	`class_design2.id`	通常是主键或唯一键
外键列	`student_design2.class_id`	保存主表中已经存在的编号

“主表”和“从表”是相对于某一条外键关系而言的。同一张表在不同关系中可能既是主表又是从表。

6.3 创建主表

先创建班级表：

drop table if exists student_fk_demo;
drop table if exists class_fk_demo;

create table class_fk_demo (
    id bigint primary key auto_increment,
    name varchar(30) not null,

    constraint uk_class_fk_demo_name unique (name)
) engine = innodb;

插入班级：

insert into class_fk_demo (name)
values ('Java001班'), ('MySQL001班');

先创建主表的原因是从表在创建外键时必须能够找到被引用的表与字段。

6.4 创建从表并定义外键

drop table if exists student_fk_demo;

create table student_fk_demo (
    id bigint primary key auto_increment,
    sno varchar(20) not null,
    name varchar(20) not null,
    class_id bigint,

    constraint uk_student_fk_demo_sno
        unique (sno),

    constraint fk_student_fk_demo_class
        foreign key (class_id)
        references class_fk_demo (id)
) engine = innodb;

外键核心语法：

constraint 外键名称
foreign key (从表字段)
references 主表名称 (主表被引用字段)

推荐主动给外键命名。否则 MySQL 会生成类似 student_fk_demo_ibfk_1 的名称，出现错误或删除外键时不够直观。

6.5 外键写入

情况一：主表中存在该编号

insert into student_fk_demo (sno, name, class_id)
values ('20260001', '张三', 1);

只要班级表存在 id = 1，就可以成功。

情况二：主表中不存在该编号

insert into student_fk_demo (sno, name, class_id)
values ('20260002', '李四', 100);

会出现类似错误：

ERROR 1452 (23000): Cannot add or update a child row:
a foreign key constraint fails

错误原因是 class_id = 100 在主表中没有对应记录。

情况三：外键值为 `NULL`

insert into student_fk_demo (sno, name, class_id)
values ('20260003', '王五', null);

这条语句可以成功，因为 class_id 没有 not null。

此时 null 可以表达“暂未分配班级”。如果业务要求每名学生必须属于一个班级，应把字段定义为：

class_id bigint not null

外键约束检查的是“非空外键值是否存在于主表”。是否允许不填写，还要由 not null 决定。

6.6 默认情况下为什么不能删除被引用的主表记录

如果 Java001班 已经有学生，执行：

delete from class_fk_demo
where id = 1;

通常会出现：

ERROR 1451 (23000): Cannot delete or update a parent row:
a foreign key constraint fails

MySQL 拒绝删除，原因是删除班级后，学生表中的 class_id = 1 会变成无效引用。

如果一个班级没有任何学生引用，则可以正常删除。

6.7 `ON DELETE` 与 `ON UPDATE`

外键可以指定主表记录被删除或被更新时，从表如何处理。

基本语法：

constraint fk_student_fk_demo_class
foreign key (class_id)
references class_fk_demo (id)
on delete restrict
on update cascade

常用动作：

动作	主表被删除或更新时	适用思路
`restrict`	如果存在从表引用，就拒绝操作	默认且最保守，适合重要业务数据
`no action`	InnoDB 中与 `restrict` 基本等价	SQL 标准写法
`cascade`	自动删除或更新对应从表记录	强依赖关系，如订单与纯明细
`set null`	把从表外键值设为 `null`	关系可以解除，且外键列允许 `null`

set default 虽然会被 MySQL 语法解析器识别，但 InnoDB 不接受这种引用动作，不应把它作为普通可用方案。

`ON DELETE RESTRICT`

on delete restrict

存在学生时禁止删除班级。省略 on delete 时，InnoDB 的默认行为也相当于限制删除。

`ON DELETE CASCADE`

on delete cascade

删除班级时，属于该班级的学生也会自动删除。

这种操作影响范围可能很大。除非从表数据没有独立保留价值，否则不要因为“删除方便”就随意使用级联删除。

`ON DELETE SET NULL`

on delete set null

删除班级时，学生仍然保留，但其 class_id 自动变为 null。

要使用它，外键字段必须允许 null：

class_id bigint

如果写成 class_id bigint not null，就与 set null 的行为矛盾。

`ON UPDATE CASCADE`

on update cascade

如果主表被引用键发生修改，从表外键会同步修改。

主键通常不应频繁改变，因此它更多是完整性保障，而不是日常更新手段。

6.8 如何选择外键动作

可以按下面的顺序思考：

初学和普通业务设计中，优先使用 restrict，等业务语义非常明确时再选择 cascade 或 set null。

6.9 添加和删除外键

前面的建表语句已经创建了外键。为了演示修改流程，先删除原外键：

alter table student_fk_demo
drop foreign key fk_student_fk_demo_class;

重新添加前要检查是否已经存在孤立数据：

select s.*
from student_fk_demo as s
left join class_fk_demo as c
    on s.class_id = c.id
where s.class_id is not null
  and c.id is null;

这条查询的逻辑是：

使用左连接保留所有学生。
尝试根据 class_id 找对应班级。
外键不为空但 c.id 仍为空，说明引用的班级不存在。

存在这种数据时，应先清理或补齐班级，再添加外键。

确认查询没有返回孤立数据后，重新添加：

alter table student_fk_demo
add constraint fk_student_fk_demo_class
foreign key (class_id)
references class_fk_demo (id)
on delete restrict
on update cascade;

如果后续确实不再需要这条关系，可以再次删除：

alter table student_fk_demo
drop foreign key fk_student_fk_demo_class;

注意：删除外键约束后，外键列上的索引可能仍然存在。是否继续保留要根据查询需求决定，可以使用下面的语句检查：

show index from student_fk_demo;

6.10 创建外键的必要条件

常见要求包括：

主表和从表都应使用支持外键的存储引擎，通常是 InnoDB。
对应字段的数据类型要匹配。
整数类型的长度与是否 unsigned 要一致。
字符串外键的字符集与排序规则要一致。
被引用字段要有合适的索引；正式关系设计中通常引用主键或唯一键。
现有数据必须已经满足引用关系。
创建从表前，主表必须存在。

例如，下面两列并不完全匹配：

-- 主表
id bigint unsigned

-- 从表
class_id bigint

一个是无符号 bigint unsigned，另一个是有符号 bigint，创建外键可能失败。应把两边统一。

6.11 外键常伴随索引

MySQL 检查外键时需要快速完成两类查询：

写入从表时，查找主表中是否存在被引用值。
删除或更新主表时，查找从表中是否存在引用。

如果没有索引，每次检查都可能扫描大量数据。因此 MySQL 要求外键两端具有合适的索引；从表没有可用索引时，InnoDB 通常会自动创建。

但是必须区分：

外键是数据关系规则。
索引是帮助查找数据的数据结构。
索引可以为外键检查服务，但索引本身不会保证引用关系。

desc student_fk_demo 中 class_id 的 Key 可能显示 MUL。MUL 只说明该列位于一个可重复值的索引中，不能单凭它证明该列一定有外键。

检查外键应该使用：

show create table student_fk_demo;

6.12 外键不会自动完成连接查询

定义外键后，查询学生及班级仍然需要显式连接：

select
    s.id,
    s.sno,
    s.name as student_name,
    c.name as class_name
from student_fk_demo as s
left join class_fk_demo as c
    on s.class_id = c.id;

外键负责保证关系正确，join 负责按照关系取出数据，二者作用不同。

7. CHECK 检查约束

7.1 作用与版本

check 用于限制列值范围，或限制同一行中多个字段之间的关系。

MySQL 8.0.16 之前虽然能解析 check 语法，但通常不会真正执行检查。从 MySQL 8.0.16 开始才正式执行核心 check 约束。

7.2 限制年龄与性别

drop table if exists student_check_demo;

create table student_check_demo (
    id bigint primary key auto_increment,
    name varchar(20) not null,
    age int not null default 18,
    gender char(1),

    constraint ck_student_check_demo_age
        check (age >= 16),

    constraint ck_student_check_demo_gender
        check (gender in ('男', '女') or gender is null)
);

正常数据：

insert into student_check_demo (name, age, gender)
values ('张三', 17, '男');

年龄不合法：

insert into student_check_demo (name, age, gender)
values ('李四', 15, '女');

会出现类似错误：

ERROR 3819 (HY000): Check constraint
'ck_student_check_demo_age' is violated.

性别不合法：

insert into student_check_demo (name, age, gender)
values ('王五', 18, '未知');

会违反性别检查约束。

使用：

gender in ('男', '女')

比下面的写法更容易扩展和阅读：

gender = '男' or gender = '女'

7.3 `CHECK` 与 `NULL` 的关系

check 表达式的结果为：

true：通过。
false：拒绝。
unknown：通常也通过；涉及 null 的比较往往得到 unknown。

例如：

age int check (age >= 16)

如果 age = null，表达式 null >= 16 不是 false，而是 unknown，因此不能只靠这条 check 阻止 null。

如果要求年龄必须填写且不小于 16，应写：

age int not null,
constraint ck_student_age check (age >= 16)

其中：

not null 负责“必须填写”。
check 负责“填写后必须在合法范围内”。

7.4 限制数值范围

成绩应在 0 到 100 之间：

score decimal(5, 2),
constraint ck_score_range
    check (score between 0 and 100)

between 0 and 100 包含边界 0 与 100。

如果成绩必须存在：

score decimal(5, 2) not null,
constraint ck_score_range
    check (score between 0 and 100)

7.5 检查多个字段之间的关系

create table activity_check_demo (
    id bigint primary key auto_increment,
    activity_name varchar(50) not null,
    start_time datetime not null,
    end_time datetime not null,

    constraint ck_activity_time
        check (end_time > start_time)
);

这里必须使用表级约束，原因是规则同时引用了 start_time 和 end_time。

它保证结束时间一定晚于开始时间。

7.6 添加、暂停执行和删除检查约束

前面的建表语句已经定义了年龄检查。为了演示完整管理流程，先删除原约束：

alter table student_check_demo
drop check ck_student_check_demo_age;

重新添加：

alter table student_check_demo
add constraint ck_student_check_demo_age
check (age >= 16);

暂停执行但保留定义：

alter table student_check_demo
alter check ck_student_check_demo_age not enforced;

重新执行：

alter table student_check_demo
alter check ck_student_check_demo_age enforced;

删除：

alter table student_check_demo
drop check ck_student_check_demo_age;

not enforced 更适合受控迁移，不适合作为长期绕过规则的手段。

7.7 `CHECK` 的边界

适合：

数值范围。
枚举值范围。
同一行字段之间的大小或逻辑关系。
简单、稳定、必须由所有写入入口遵守的规则。

不适合：

需要查询其他表才能判断的复杂规则。
经常变化的业务流程。
需要调用外部服务的规则。
复杂权限与状态机。

这些规则通常应由后端业务代码、事务和其他数据库机制共同完成。

8. 使用 ALTER TABLE 管理已有表的约束

8.1 常用操作

下面各段是独立语法模板，不是一组应当从头到尾连续执行的脚本。使用其中一项前，要先确认当前表是否已经存在同类约束。

添加非空约束

alter table student_design2
modify name varchar(20) not null;

删除非空约束

alter table student_design2
modify name varchar(20) null;

添加默认值

alter table student_design2
alter column age set default 18;

删除默认值

alter table student_design2
alter column age drop default;

添加唯一约束

alter table student_design2
add constraint uk_student_design2_sno unique (sno);

删除唯一约束

alter table student_design2
drop index uk_student_design2_sno;

添加主键

alter table student_design2
add primary key (id);

删除主键

alter table student_design2
drop primary key;

如果主键列带有 auto_increment 或正在被外键引用，不能直接照搬这条语句，必须先处理相关属性与依赖。

添加外键

alter table student_design2
add constraint fk_student_design2_class
foreign key (class_id)
references class_design2 (id);

删除外键

alter table student_design2
drop foreign key fk_student_design2_class;

添加检查约束

alter table student_design2
add constraint ck_student_design2_age
check (age between 16 and 100);

删除检查约束

alter table student_design2
drop check ck_student_design2_age;

9. 约束、索引和数据类型的关系

9.1 三者解决的问题不同

对象	主要问题	示例
数据类型	这一列存储哪一类数据	`int`、`varchar(20)`、`datetime`
约束	哪些数据允许进入数据库	`not null`、`unique`、`foreign key`
索引	怎样更快定位数据	普通索引、唯一索引、主键索引

例如：

sno varchar(20) not null unique

可以拆成三层理解：

varchar(20)：数据类型，限制为最多 20 个字符的变长字符串。
not null：非空规则。
unique：不重复规则，并由 MySQL 建立相应的唯一索引来实现高效检查。

9.2 约束不是索引

约束关注数据正确性

constraint fk_student_class
foreign key (class_id)
references class_design2 (id)

它要求 class_id 必须引用真实班级。

索引关注数据查找效率

index idx_student_name (name)

它可以提高按姓名查找的效率，但允许姓名重复，也不检查班级关系。

9.3 如何检查表中到底有什么

快速查看字段

desc student_design2;

查看完整建表定义

show create table student_design2;

查看索引

show index from student_design2;

查看当前数据库的约束

select
    constraint_name,
    constraint_type,
    table_name
from information_schema.table_constraints
where table_schema = database()
  and table_name = 'student_design2';

推荐理解为：

desc：看摘要。
show create table：看完整定义。
show index：看索引细节。
information_schema：批量查询数据库元数据。

10. 数据迁移与表复制中的约束问题

10.1 `CREATE TABLE ... LIKE`

复制表结构：

drop table if exists student_backup;

create table student_backup
like student_design2;

再复制数据：

insert into student_backup
select *
from student_design2;

这种方式把“创建结构”和“复制数据”分成两步，容易检查和控制。

10.2 `LIKE` 会复制什么

在 MySQL 8.0 中，create table ... like 会复制大量表结构信息，例如：

字段名与数据类型。
not null。
默认值。
主键和索引，因此唯一约束对应的唯一索引也会复制。
check 约束，但 MySQL 会为副本重新生成检查约束名称。

它不会复制：

表中的数据。
外键定义。

所以一定要比较：

show create table student_design2;
show create table student_backup;

不能只看字段表面相同，就判断两个表的完整结构完全一致。

10.3 如何给副本重新添加外键

如果副本确实需要继续引用原班级表，可以执行：

alter table student_backup
add constraint fk_student_backup_class
foreign key (class_id)
references class_design2 (id)
on delete restrict
on update cascade;

外键名称使用 fk_student_backup_class，而不是复用原表名称，原因是名称应明确对应当前关系，也可避免命名冲突。

但备份表是否应该保留外键要看目的：

如果只是保存历史快照，保留外键可能导致主表数据变化时备份受影响。
如果副本仍参与正常业务，保留外键更有利于一致性。

不能机械地认为“结构越一样越好”，应先明确副本用途。

10.4 `CREATE TABLE ... SELECT`

create table student_backup2 as
select *
from student_design2;

这种方式可以一次完成“建表 + 复制查询结果”，但通常不会完整保留原表的主键、唯一索引、外键和其他完整定义。

因此：

临时分析表可以使用。
需要精确保留表设计时，不应只依赖这种方式。
正式复制后必须用 show create table 检查。

推荐的正式学习写法仍然是：

create table student_backup like student_design2;

insert into student_backup
select *
from student_design2;

然后按业务需要单独恢复外键。

11. 主键或唯一键冲突时的写入方式

原资料把这部分放在主键章节中，因为这些语句都依赖主键或唯一键发现冲突。

11.1 普通 `INSERT`

insert into student_design2
    (sno, name, age, class_id)
values
    ('20260001', '张三', 18, 1);

如果 sno = '20260001' 已存在，普通插入会报 1062 重复键错误。

11.2 `INSERT ... ON DUPLICATE KEY UPDATE`

它的含义是：

没有主键或唯一键冲突：插入新行。
发生冲突：更新已经存在的行。

MySQL 8.0.19 之后可以给待插入的新行起别名：

insert into student_design2
    (sno, name, age, class_id)
values
    ('20260001', '张三（已更新）', 19, 1) as new
on duplicate key update
    name = new.name,
    age = new.age,
    class_id = new.class_id;

这里通过学号唯一约束发现冲突，然后更新原来的学生记录。

原资料中“受影响 2 行表示删除原记录再插入一条”的解释不准确。on duplicate key update 执行的是更新；默认连接行为下，更新已有行时受影响行数常显示为 2，这是 MySQL 的计数约定，不代表真的删除了两行或重新插入了一行。

另外，旧写法中常见：

name = values(name)

从 MySQL 8.0.20 起，这种在更新部分使用 values() 引用新值的方式已被弃用。新代码更适合使用上面的行别名。

11.3 `REPLACE`

replace into student_design2
    (id, sno, name, age, class_id)
values
    (1, '20260001', '张三', 20, 1);

逻辑上：

没有主键或唯一键冲突：插入。
有冲突：删除冲突的旧行，再插入新行。

如果单行 replace 显示：

1 row affected：通常只发生了插入。
大于 1：通常删除了冲突行并插入了新行。

11.4 三种写入方式对比

写法	无冲突	有主键或唯一键冲突	适合场景
`insert`	插入	报错	必须确保是全新数据
`insert ... on duplicate key update`	插入	更新旧行	幂等写入、同步某些业务数据
`replace`	插入	删除旧行后插入	明确需要替换语义且已评估副作用

参考

MySQL 8.0 Reference Manual - FOREIGN KEY Constraints

MySQL 8.0 Reference Manual - CHECK Constraints

MySQL 8.0 Reference Manual - CREATE TABLE ... LIKE

MySQL 8.0 Reference Manual - INSERT ... ON DUPLICATE KEY UPDATE

MySQL 基础操作：DDL、DML、DQL 与 CRUD

Wed, 22 Jul 2026 00:00:00 GMT

思路整理： DDL -> DML -> DQL -> 约束 -> 数据库设计 -> 多表查询 -> 索引 -> 事务 -> 视图 -> 用户权限 -> JDBC 学习。

0. MySQL 总览

0.1 数据库是什么

数据库可以理解为：专门用来长期保存、管理、查询、修改数据的软件系统。

普通文件也能保存数据，但当数据量变大、多人同时访问、需要快速查询、需要保证数据安全时，普通文件就不够用了。数据库的价值主要在于：

作用	说明
数据持久化	程序关闭或电脑重启后，数据仍然保存
结构化存储	数据按表、行、列组织，查询和维护方便
数据完整性	通过约束保证数据尽量正确，比如主键不能重复
并发控制	多个人同时操作数据时，尽量避免数据混乱
查询优化	数据库会通过索引、优化器提升查询效率
事务管理	一组操作要么都成功，要么都失败，适合转账、下单等场景
权限控制	不同用户只能操作自己有权限的数据

0.2 关系型数据库是什么

关系型数据库用二维表保存数据。

一张表可以理解为 Excel 表格：

数据库概念	类比	说明
数据库服务器	一台安装 MySQL 的机器	可以管理多个数据库
数据库 database/schema	一个项目的数据空间	一个项目一般建一个数据库
表 table	Excel 中的一张表	保存某一类实体的数据
行 row/record	Excel 中的一行	表示一条数据记录
列 column/field	Excel 中的一列	表示实体的一个属性
主键 primary key	唯一编号	用来唯一标识一行数据

例如学生管理系统中：

数据库：student_system
表：student、class、course、score
行：student 表中的一条学生记录
列：id、name、age、gender、class_id

0.3 MySQL 服务端、客户端、数据库之间的关系

MySQL 安装后主要有两个角度：

组成	说明
`mysqld`	MySQL 服务端程序，真正管理数据
`mysql`	命令行客户端，用来连接服务端并发送 SQL
Navicat / DBeaver / Workbench	图形化客户端，本质也是连接 MySQL 服务端

操作流程可以理解为：

客户端输入 SQL
    -> 发送给 MySQL 服务端
        -> 服务端解析 SQL
            -> 优化 SQL
                -> 存储引擎读写数据文件
                    -> 返回结果给客户端

0.4 SQL 分类

SQL 是结构化查询语言，用来操作关系型数据库。常见分类如下：

分类	全称	作用	常见语句
DDL	Data Definition Language	定义数据库结构	`create`、`drop`、`alter`、`truncate`
DML	Data Manipulation Language	增删改表中数据	`insert`、`update`、`delete`
DQL	Data Query Language	查询数据	`select`
DCL	Data Control Language	权限控制	`grant`、`revoke`
TCL	Transaction Control Language	事务控制	`start transaction`、`commit`、`rollback`

DDL 管结构，DML 改数据，DQL 查数据，DCL 管权限，TCL 管事务。

1. DDL：数据库和表结构操作

DDL 主要负责创建、查看、修改、删除数据库结构。这里的结构包括数据库、表、字段、字段类型、字段约束等。

1.1 数据库操作

1.1.1 查看所有数据库

show databases;

为什么要先看数据库？

因为 MySQL 服务端中可以存在多个数据库。操作前先查看已有数据库，可以避免误操作系统库或别的项目库。

系统库常见有：

系统库	说明
`mysql`	保存用户、权限等系统信息
`information_schema`	保存数据库元数据，比如表、列、索引信息
`performance_schema`	性能监控相关数据
`sys`	系统视图，方便查看 MySQL 运行状态

1.1.2 查看当前正在使用的数据库

select database();

原因：

很多语句默认作用于当前数据库。如果当前数据库不是你想操作的库，就可能创建错表或删除错表。

1.1.3 创建数据库

基本语法：

create database 数据库名;

推荐语法：

create database if not exists 数据库名
default character set utf8mb4
collate utf8mb4_0900_ai_ci;

示例：

create database if not exists mysql_study
default character set utf8mb4
collate utf8mb4_0900_ai_ci;

每部分原因：

写法	原因
`if not exists`	数据库已存在时不报错，只给警告，适合重复执行脚本
`utf8mb4`	支持中文、emoji、更多 Unicode 字符
`collate`	指定排序和比较规则，比如大小写是否敏感

1.1.4 字符集与排序规则

字符集决定字符怎么保存，排序规则决定字符怎么比较和排序

查看 MySQL 支持的字符集：

show charset;

查看排序规则：

show collation;

查看当前服务器默认字符集：

show variables like 'character_set%';

查看当前服务器默认排序规则：

show variables like 'collation%';

常见规则：

排序规则	含义
`utf8mb4_0900_ai_ci`	MySQL 8 默认常见规则，大小写不敏感、重音不敏感
`utf8mb4_general_ci`	老版本常见规则，兼容性较好
`utf8mb4_bin`	按二进制比较，大小写敏感

其中：

缩写	含义
`ci`	case insensitive，大小写不敏感
`cs`	case sensitive，大小写敏感
`ai`	accent insensitive，重音不敏感
`as`	accent sensitive，重音敏感

1.1.5 使用数据库

use 数据库名;

示例：

use mysql_study;

原因：

创建表、插入数据、查询数据通常都要在某个数据库中进行。执行 use 后，后续没有指定库名的表操作都会默认作用在这个库中。

1.1.6 查看建库语句

show create database 数据库名;

示例：

show create database mysql_study;

原因：

可以确认数据库的字符集、排序规则是否符合预期。

1.1.7 修改数据库字符集和排序规则

alter database 数据库名
character set utf8mb4
collate utf8mb4_0900_ai_ci;

示例：

alter database mysql_study
character set utf8mb4
collate utf8mb4_0900_ai_ci;

注意：

这主要影响后续新建对象的默认规则，不一定会自动改变已有表和已有字段的字符集。

1.1.8 删除数据库

drop database if exists 数据库名;

示例：

drop database if exists mysql_study;

原因和风险：

drop database 会删除整个数据库，里面所有表和数据都会被删除。真实项目中不要随便执行，尤其不要在生产环境执行。

1.2 数据类型

创建表时，每个字段都必须指定数据类型。

选择数据类型的核心原则：

能准确表达业务含义；
范围够用，不浪费空间；
需要精确计算的不要用浮点数；
字符串长度尽量贴近实际业务；
时间字段根据是否需要日期、时间、时区特性来选。

1.2.1 常用数据类型分类

分类	常用类型	适合保存
整数类型	`tinyint`、`smallint`、`int`、`bigint`	年龄、编号、数量、状态
小数类型	`decimal`、`float`、`double`	金额、成绩、比例、测量值
字符串类型	`char`、`varchar`、`text`	姓名、手机号、邮箱、文章
日期时间类型	`date`、`time`、`datetime`、`timestamp`	生日、创建时间、更新时间
二进制类型	`binary`、`varbinary`、`blob`	图片、文件、二进制数据

1.2.2 整数类型

类型	空间	有符号范围	无符号范围	常见用途
`tinyint`	1 byte	-128 ~ 127	0 ~ 255	状态、性别、年龄
`smallint`	2 bytes	-32768 ~ 32767	0 ~ 65535	小范围数量
`mediumint`	3 bytes	-8388608 ~ 8388607	0 ~ 16777215	中等范围编号
`int`	4 bytes	-2147483648 ~ 2147483647	0 ~ 4294967295	常规 ID、数量
`bigint`	8 bytes	很大	很大	大型系统 ID、雪花 ID

示例：

create table type_int_demo (
    id bigint primary key auto_increment,
    age tinyint unsigned,
    status tinyint,
    view_count int unsigned
);

为什么年龄用 tinyint unsigned？

年龄不会是负数，tinyint unsigned 范围是 0 到 255，已经足够。比 int 更节省空间。

为什么 ID 常用 bigint？

大型系统中数据量可能很大，分布式 ID 也经常超出 int 范围，所以用 bigint 更安全。

1.2.3 小数类型

类型	特点	适合场景
`float`	单精度浮点数，可能有精度误差	科学计算、要求不高的测量值
`double`	双精度浮点数，也可能有精度误差	高精度测量、非金额计算
`decimal(M,D)`	定点数，不存在二进制浮点误差	金额、工资、价格、财务数据

示例：

create table product (
    id bigint primary key auto_increment,
    name varchar(50) not null,
    price decimal(10, 2) not null
);

decimal(10,2) 表示总共最多 10 位数字，其中小数点后 2 位。

可以保存：

99999999.99

不能保存：

999999999.99

因为总位数超过 10。

为什么金额不要用 float/double？

浮点数在计算机底层用二进制近似表示，可能出现 0.1 + 0.2 != 0.3 这样的精度误差。金额必须精确，所以用 decimal。

1.2.4 字符串类型

类型	特点	最大长度	适合保存
`char(n)`	固定长度	0~255 字符	身份证号、MD5、性别编码
`varchar(n)`	可变长度	取决于行大小和字符集	姓名、标题、邮箱、手机号
`text`	长文本	较大	文章、评论、描述

char 与 varchar 的区别

对比	`char(n)`	`varchar(n)`
长度	固定长度	可变长度
空间	不足 n 也按 n 存储，可能补空格	按实际长度存储，额外记录长度
查询效率	通常略快	通常略慢
适合	长度固定的数据	长度不固定的数据

示例：

create table user_account (
    id bigint primary key auto_increment,
    username varchar(30) not null,
    password_md5 char(32) not null,
    phone char(11),
    intro text
);

为什么密码 MD5 用 char(32)？

MD5 字符串固定 32 位，长度不会变化，用 char(32) 合适。

为什么用户名用 varchar(30)？

用户名长度不固定，有的人 3 个字符，有的人 20 个字符，用 varchar 更节省空间。

1.2.5 日期时间类型

类型	格式	适合保存
`date`	`YYYY-MM-DD`	生日、日期
`time`	`HH:MM:SS`	时间点、耗时
`datetime`	`YYYY-MM-DD HH:MM:SS`	创建时间、更新时间
`timestamp`	`YYYY-MM-DD HH:MM:SS`	时间戳，受时区影响
`year`	`YYYY`	年份

示例：

create table article (
    id bigint primary key auto_increment,
    title varchar(100) not null,
    publish_date date,
    created_at datetime default current_timestamp,
    updated_at datetime default current_timestamp on update current_timestamp
);

为什么创建时间用 datetime？

创建时间需要日期和具体时间，不只是日期，所以不用 date。

datetime 与 timestamp 简单区别：

对比	`datetime`	`timestamp`
时区影响	不受时区自动转换影响	受时区转换影响
范围	更大	较小
常用场景	业务时间	记录系统时间戳

1.3 表操作：查询、创建、修改、删除

1.3.1 查看当前数据库中的所有表

show tables;

原因：

确认当前数据库里有哪些表，避免重复建表或误删表。

1.3.2 查看表结构

desc 表名;

示例：

desc users;

结果中常见字段：

列	说明
`Field`	字段名
`Type`	字段类型
`Null`	是否允许为 `NULL`
`Key`	是否有索引/主键/唯一键
`Default`	默认值
`Extra`	额外信息，比如 `auto_increment`

1.3.3 查看建表语句

show create table 表名;

示例：

show create table users;

原因：

desc 只能看大概结构，show create table 能看到完整建表语句，包括字符集、引擎、约束、索引等。

1.3.4 创建表基本语法

create table 表名 (
    字段名1 数据类型 [约束] [comment '字段注释'],
    字段名2 数据类型 [约束] [comment '字段注释'],
    字段名3 数据类型 [约束] [comment '字段注释']
) engine = InnoDB
  default character set = utf8mb4
  collate = utf8mb4_0900_ai_ci
  comment = '表注释';

示例：

drop table if exists users;

create table users (
    id bigint primary key auto_increment comment '用户ID',
    username varchar(30) not null unique comment '用户名',
    password char(32) not null comment 'MD5密码',
    phone char(11) comment '手机号',
    birthday date comment '生日',
    created_at datetime default current_timestamp comment '创建时间'
) engine = InnoDB
  default character set = utf8mb4
  collate = utf8mb4_0900_ai_ci
  comment = '用户表';

每一步原因：

操作	原因
`drop table if exists users`	练习时方便重复执行，避免表已存在报错
`id bigint primary key auto_increment`	每条用户数据都需要唯一标识，并自动递增
`username not null unique`	用户名不能为空，也不能重复
`password char(32)`	MD5 固定 32 位
`created_at default current_timestamp`	插入时自动记录创建时间
`engine = InnoDB`	InnoDB 支持事务、外键、行级锁，是 MySQL 常用默认引擎

1.3.5 修改表结构：ALTER TABLE

添加字段

alter table 表名 add 字段名 数据类型 [约束] [comment '注释'];

示例：

alter table users add email varchar(100) comment '邮箱';

原因：

项目需求变化时，可能需要给已有表增加新属性。

修改字段类型

alter table 表名 modify 字段名 新数据类型 [约束];

示例：

alter table users modify username varchar(50) not null;

原因：

原来用户名长度 30 不够，需要扩大为 50。

修改字段名和字段类型

alter table 表名 change 旧字段名 新字段名 新数据类型 [约束] [comment '注释'];

示例：

alter table users change phone mobile char(11) comment '手机号';

原因：

change 可以同时改字段名和字段类型。即使只改字段名，也必须写新类型。

删除字段

alter table 表名 drop column 字段名;

示例：

alter table users drop column email;

注意：

删除字段会丢失这一列的所有数据，真实项目中要先备份或确认业务不再使用。

修改表名

alter table 旧表名 rename to 新表名;

示例：

alter table users rename to user_account;

1.3.6 删除表

drop table if exists 表名;

示例：

drop table if exists user_account;

原因和风险：

drop table 删除表结构和数据，表直接不存在。比 delete 更危险。

1.3.7 清空表：TRUNCATE

truncate table 表名;

或者：

truncate 表名;

delete 与 truncate 对比：

对比项	`delete from 表名;`	`truncate table 表名;`
删除对象	删除数据行	清空整张表
是否保留表结构	保留	保留
是否能加 `where`	可以	不可以
自增计数	通常不重置或依情况	通常重置
适合场景	按条件删除	清空测试表
危险程度	高	更高

注意：

truncate 不是删除表，而是清空表。初学阶段只建议在测试表上使用。

2. DML：数据增删改

DML 操作的是表中的数据行，不是表结构。

常见 DML：

操作	语句
新增	`insert`
修改	`update`
删除	`delete`

2.1 INSERT：添加数据

2.1.1 指定字段插入

insert into 表名(字段1, 字段2, 字段3)
values(值1, 值2, 值3);

示例：

insert into users(username, password, phone)
values('zhangsan', 'e10adc3949ba59abbe56e057f20f883e', '13800000000');

原因：

推荐指定字段插入，因为表结构变化时不容易出错。例如后面增加一个字段，原来的插入语句仍然能执行。

2.1.2 全字段插入

insert into 表名 values(值1, 值2, 值3, ...);

示例：

insert into users
values(1, 'lisi', 'e10adc3949ba59abbe56e057f20f883e', '13900000000', '2000-01-01', now());

注意：

全字段插入要求值的个数、顺序必须和表结构完全一致。真实项目中不推荐。

2.1.3 批量插入

insert into 表名(字段1, 字段2)
values
(值1, 值2),
(值1, 值2),
(值1, 值2);

示例：

insert into users(username, password, phone)
values
('wangwu', '12345678901234567890123456789012', '13700000000'),
('zhaoliu', '12345678901234567890123456789012', '13600000000'),
('qianqi', '12345678901234567890123456789012', '13500000000');

原因：

批量插入比多次单行插入效率更高，因为一次 SQL 可以插入多行数据。

2.1.4 插入查询结果

对应语法为：

insert into 新表 (列1, 列2, ...)
select 列1, 列2, ...
from 旧表
where 条件;

同样在此基础上还能继续拓展多种操作，比如带条件迁移、迁移时修改数据，该知识点另有补充。

2.1.5 插入注意事项

字符串和日期要加单引号：

'张三'
'2026-05-08'

数字一般不用引号：

18
99.5

插入指定字段时，值的顺序必须和字段顺序一致。
有 auto_increment 的主键通常不用手动插入。

2.2 UPDATE：修改数据

基本语法：

update 表名
set 字段1 = 值1,
    字段2 = 值2
where 条件;

示例：

update users
set phone = '13811112222'
where username = 'zhangsan';

每一步原因：

部分	原因
`update users`	指定要修改哪张表
`set phone = ...`	指定要修改哪个字段、改成什么值
`where username = ...`	限定只修改某个用户

2.2.1 修改多个字段

update users
set phone = '13811112222',
    birthday = '2001-02-03'
where id = 1;

2.2.2 没有 WHERE 的风险

update users
set phone = '00000000000';

这会把整张表所有用户的手机号都改掉。

结论：

执行 update 前先写 select 验证条件：

select * from users where id = 1;

确认结果正确后，再执行：

update users set phone = '13811112222' where id = 1;

2.3 DELETE：删除数据

基本语法：

delete from 表名 where 条件;

示例：

delete from users where id = 3;

原因：

where 用来限定删除范围。没有 where 会删除整张表所有数据。

2.3.1 删除字段为 NULL 的记录

delete from users where phone is null;

为什么不能写 phone = null？

SQL 中 NULL 表示未知值，不能用 = 判断，必须用：

is null
is not null

2.3.2 DELETE 不能删除某一列的值

错误理解：

delete phone from users where id = 1;

delete 删除的是整行数据，不是某个字段值。

如果只想清空手机号，应使用：

update users set phone = null where id = 1;

或者：

update users set phone = '' where id = 1;

区别：

写法	含义
`null`	没有值、未知
`''`	空字符串，是一个具体字符串值

3. DQL：数据查询

DQL 的核心是 select。查询是 MySQL 中最常用、也是最重要的部分。

3.1 SELECT 语句完整结构

书写顺序：

select 字段列表
from 表名
where 条件列表
group by 分组字段
having 分组后条件
order by 排序字段
limit 分页参数;

执行顺序大致理解为：

from -> where -> group by -> 聚合函数 -> having -> select -> order by -> limit

为什么要理解执行顺序？

因为它能解释很多问题：

where 不能使用聚合函数，因为聚合还没执行；
having 可以使用聚合函数，因为它在分组统计之后执行；
order by 可以使用 select 中的别名，因为排序发生在 select 后面。

3.2 基本查询

3.2.1 查询所有列

select * from 表名;

示例：

select * from users;

注意：

练习时可以用 *，真实项目中尽量写具体字段。因为 * 会查询所有列，可能浪费网络和内存，也容易受表结构变化影响。

3.2.2 查询指定列

select 字段1, 字段2 from 表名;

示例：

select id, username, phone from users;

原因：

只查询需要的列，可以减少数据传输，提高查询效率。

3.2.3 查询表达式

select username, 10 from users;

select username, id + 1000 from users;

示例：

select username, year(now()) - year(birthday) as approx_age
from users;

原因：

select 后面不只能写字段，也可以写表达式、函数、常量。

3.2.4 设置别名

select 字段名 as 别名 from 表名;

as 可以省略：

select username 用户名 from users;

推荐写法：

select username as 用户名, phone as 手机号
from users;

原因：

别名可以让查询结果更易读，尤其是表达式和函数结果。

3.2.5 去重查询 DISTINCT

select distinct 字段名 from 表名;

示例：

select distinct phone from users;

多个字段去重：

select distinct class_id, gender from student;

注意：

多个字段一起 distinct 时，判断的是这一组字段组合是否重复，不是只看某一个字段。

3.3 WHERE 条件查询

基本语法：

select 字段列表
from 表名
where 条件;

3.3.1 比较运算符

运算符	含义	示例
`=`	等于	`age = 18`
`<>` 或 `!=`	不等于	`age <> 18`
`>`	大于	`score > 90`
`>=`	大于等于	`score >= 60`
`<`	小于	`age < 30`
`<=`	小于等于	`age <= 30`
`between ... and ...`	在范围内，包含两端	`age between 18 and 25`
`in (...)`	在列表中	`age in (18,20,22)`
`like`	模糊匹配	`name like '张%'`
`is null`	是空值	`phone is null`
`is not null`	不是空值	`phone is not null`

3.3.2 逻辑运算符

运算符	含义
`and`	并且，多个条件都满足
`or`	或者，满足任意一个条件
`not`	取反

示例：

select * from student
where age >= 18 and gender = 1;

select * from student
where age = 18 or age = 20;

推荐改成：

select * from student
where age in (18, 20);

3.3.3 BETWEEN 范围查询

select * from student
where age between 18 and 25;

等价于：

select * from student
where age >= 18 and age <= 25;

注意：

between 小值 and 大值 包含两端。

3.3.4 IN 多选一

select * from student
where age in (18, 20, 40);

原因：

比多个 or 更简洁。

3.3.5 LIKE 模糊查询

通配符	含义
`%`	匹配任意个字符，包括 0 个
`_`	匹配单个字符

示例：

查询姓张的人：

select * from student
where name like '张%';

查询名字只有两个字的人：

select * from student
where name like '__';

查询身份证号最后一位是 X：

select * from student
where id_card like '%X';

注意：

like '%关键字%' 前面有 % 时，普通 B+Tree 索引通常很难有效使用。

3.3.6 NULL 查询

查询手机号为空：

select * from users where phone is null;

查询手机号不为空：

select * from users where phone is not null;

错误写法：

select * from users where phone = null;

3.4 ORDER BY 排序查询

基本语法：

select 字段列表
from 表名
order by 字段1 排序方式, 字段2 排序方式;

排序方式：

写法	含义
`asc`	升序，默认
`desc`	降序

示例：

select * from student
order by age asc;

select * from exam
order by math desc, english desc;

原因：

当第一个排序字段相同时，再按第二个排序字段排序。

3.5 LIMIT 分页查询

3.5.1 基本语法

select 字段列表
from 表名
limit 起始下标, 查询条数;

示例：

select * from student limit 0, 10;

表示从第 0 条开始，查询 10 条。

3.5.2 第 n 页公式

起始下标 = (页码 - 1) * 每页条数

第 1 页，每页 10 条：

limit 0, 10;

第 2 页，每页 10 条：

limit 10, 10;

第 3 页，每页 10 条：

limit 20, 10;

3.5.3 另一种写法

select * from student
limit 10 offset 20;

等价于：

select * from student
limit 20, 10;

3.6 聚合函数

聚合函数用于对多行（即某一整列）数据进行统计，最后通常返回一行结果。

函数	作用
`count()`	统计数量
`sum()`	求和
`avg()`	求平均值
`max()`	求最大值
`min()`	求最小值

3.6.1 COUNT

统计总行数：

select count(*) from student;

统计某列非 NULL 的数量：

select count(phone) from users;

区别：

写法	含义
`count(*)`	统计行数，包括字段为 NULL 的行
`count(字段)`	统计该字段不为 NULL 的行数

3.6.2 SUM

select sum(math) from exam;

3.6.3 AVG

select avg(math) from exam;

保留两位小数：

select round(avg(math), 2) as avg_math
from exam;

3.6.4 MAX / MIN

select max(math) from exam;
select min(math) from exam;

3.6.5 聚合函数注意事项

不带普通字段时，不需要 group by：

select avg(math) from exam;

聚合函数和普通字段一起出现时，普通字段通常必须配合 group by：

select class_name, avg(math)
from exam
group by class_name;

3.7 GROUP BY 分组查询

3.7.1 基本语法

select 分组字段, 聚合函数(字段)
from 表名
where 分组前条件
group by 分组字段
having 分组后条件;

3.7.2 按班级统计平均成绩

select
    class_name,
    round(avg(chinese), 2) as avg_chinese,
    round(avg(math), 2) as avg_math,
    round(avg(english), 2) as avg_english
from exam
group by class_name;

执行逻辑：

先从 exam 表取数据；
按 class_name 分组；
每组分别计算语文、数学、英语平均分；
返回每组统计结果。

3.7.3 WHERE 与 HAVING 区别

对比	`where`	`having`
执行时间	分组前	分组后
过滤对象	原始数据行	分组后的结果
能否使用聚合函数	不能	能
常见用途	先筛选有效数据	筛选统计结果

3.7.4 WHERE 例子：先过滤学生，再分组

查询数学成绩 >= 80 的学生，再按班级统计人数：

select
    class_name,
    count(*) as student_count
from exam
where math >= 80
group by class_name;

逻辑：

先筛选 math >= 80 的学生；
再按照 class_name 分组；
最后统计每个班剩下多少人。

3.7.5 HAVING 例子：先分组统计，再过滤结果

查询平均数学成绩 >= 80 的班级：

select
    class_name,
    round(avg(math), 2) as avg_math
from exam
group by class_name
having avg(math) >= 80;

逻辑：

先按班级分组；
计算每个班平均数学成绩；
保留平均数学成绩 >= 80 的班级。

3.8 内置函数

3.8.1 日期函数

函数	作用	示例
`curdate()`	当前日期	`select curdate();`
`curtime()`	当前时间	`select curtime();`
`now()`	当前日期和时间	`select now();`
`date()`	提取日期部分	`select date('2026-05-08 14:30:25');`
`adddate()`	日期增加	`select adddate('2026-05-08', interval 7 day);`
`subdate()`	日期减少	`select subdate('2026-05-08', interval 7 day);`
`datediff()`	两个日期相差天数	`select datediff('2026-05-08','2026-05-01');`

示例：查询最近 7 天注册的用户：

select * from users
where created_at >= subdate(now(), interval 7 day);

3.8.2 字符串函数

函数	作用
`concat()`	拼接字符串
`char_length()`	统计字符个数
`length()`	统计字节数
`lower()`	转小写
`upper()`	转大写
`substring()`	截取字符串
`replace()`	替换字符串
`trim()`	去掉首尾空格

示例：

select concat(username, '的手机号是：', phone) as info
from users;

select char_length('你好MySQL');

注意：

char_length('你好')

返回字符数；

length('你好')

返回字节数，和字符集有关。

3.8.3 数学函数

函数	作用
`abs()`	绝对值
`ceil()`	向上取整
`floor()`	向下取整
`round()`	四舍五入
`rand()`	随机数
`mod()`	取余
`pow()`	幂运算

示例：

select round(avg(math), 2) from exam;

生成随机数：

select rand();

生成 6 位随机数思路：

select floor(rand() * 1000000);

4. 数据库约束

约束是对表中数据的规则限制，用来保证数据准确、完整、可靠。

常见约束：

约束	作用
`not null`	非空，不能存 `NULL`
`default`	默认值
`unique`	唯一，不能重复
`primary key`	主键，非空且唯一
`foreign key`	外键，保证表之间关系正确
`check`	检查值是否满足条件

4.1 NOT NULL 非空约束

示例：

create table student (
    id bigint,
    name varchar(20) not null
);

插入失败：

insert into student values(1, null);

原因：

学生姓名如果为 NULL，这条学生记录没有实际意义，所以要限制不能为空。

4.2 DEFAULT 默认值约束

示例：

create table student (
    id bigint,
    name varchar(20) not null,
    age int default 18
);

插入时不指定年龄：

insert into student(id, name) values(1, '张三');

查询结果中 age 自动为 18。

原因：

当某些字段大多数情况下都有相同初始值时，可以用默认值减少插入语句复杂度。

4.3 UNIQUE 唯一约束

示例：

create table users (
    id bigint primary key auto_increment,
    username varchar(30) not null unique,
    phone char(11) unique
);

原因：

用户名、手机号通常不能重复，否则登录、找回密码等业务会出现混乱。

注意：

唯一约束允许多个 NULL 的情况和数据库实现有关。实际设计时，如果字段必须唯一且必须存在，建议同时写：

phone char(11) not null unique

4.4 PRIMARY KEY 主键约束

主键特点：

唯一；
非空；
一张表通常只有一个主键；
可以由一个字段组成，也可以由多个字段组成。

4.4.1 单字段主键

create table student (
    id bigint primary key auto_increment,
    name varchar(20) not null
);

为什么要主键？

主键是每行数据的唯一身份。没有主键时，修改或删除某一行数据可能不精准。

4.4.2 联合主键

create table score (
    student_id bigint,
    course_id bigint,
    score decimal(5,2),
    primary key(student_id, course_id)
);

原因：

一个学生在一门课程中只能有一条成绩记录，所以 (student_id, course_id) 组合不能重复。

4.5 AUTO_INCREMENT 自增

示例：

create table student (
    id bigint primary key auto_increment,
    name varchar(20) not null
);

插入数据：

insert into student(name) values('张三');
insert into student(name) values('李四');

id 会自动生成 1、2、3...

注意：

自增字段必须是索引，通常是主键；
一张表只能有一个自增字段；
删除数据后，自增值通常不会自动回退；
truncate 通常会重置自增计数。

4.6 FOREIGN KEY 外键约束

外键用于维护两张表之间的关系。

示例：班级表和学生表。

constraint_user

原因：

student.class_id 引用 class.id。有外键后，学生不能随便填一个不存在的班级编号。

4.6.1 外键带来的限制

如果 class 中没有 id = 100 的班级，下面插入会失败：

insert into student(name, class_id) values('张三', 100);

如果某个班级已经被学生引用，直接删除班级可能失败：

delete from class where id = 1;

原因：

数据库要防止学生表中出现“找不到班级”的脏数据。

4.6.2 外键动作

常见动作：

动作	说明
`restrict`	默认限制，不允许破坏关系
`cascade`	级联操作，父表更新/删除时子表跟着更新/删除
`set null`	父表删除后，子表外键设为 NULL

示例：

constraint fk_student_class
foreign key(class_id) references class(id)
on delete set null
on update cascade

注意：

真实项目中很多团队不使用数据库物理外键，而是在业务代码中维护关系。初学阶段仍然要理解外键原理。

4.7 CHECK 检查约束

示例：

create table student (
    id bigint primary key auto_increment,
    name varchar(20) not null,
    age int check(age >= 0 and age <= 150),
    gender tinyint check(gender in (0, 1, 2))
);

原因：

限制字段值必须在合理范围内，比如年龄不能是负数。

数据库系统概论期末复习：数据模型、关系理论与 SQL

Sat, 06 Jun 2026 00:00:00 GMT

Note 01 绪论

1.1 数据库系统概述

数据库的 4 个基本概念

数据data：数据是数据库中存储的基本对象。描述事物的符号记录称为数据。需经数字化处理。

数据库DataBase，DB：数据库是长期储存在计算机内、有组织的、可共享的大量数据的集合。

库中的数据按一定的数据模型组织、描述和储存，具有较小的冗余度redundancy、高的数据独立性data independency 和易扩展性scalability，并可各种用户共享。

数据库数据具有永久存储、有组织和可共享三个基本特点。

数据库管理系统 DataBase Management System, DBMS：位于用户与操作系统之间的一层数据管理软件（计算机基础软件）

主要功能包括：

数据定义功能

数据库管理系统提供 数据定义语言 Data Definition Language， DDL用户通过它可以方便地对数据库中的数据对象进行定义。

数据组织、存储和管理

数据库管理系统要分类组织、存储和管理各种数据，包括数据字典、用户数据、数据的存取路径等。

数据操纵功能

数据库管理系统还提供 数据操纵语言 Data Manipulation Language, DML，用户可以使用它操纵数据，实现对数据库的基本操作，如查询、插入、删除和修改等。

数据库的事务管理和运行管理
数据库的建立和维护功能
其他功能

数据库系统 DataBase System, DBS：数据库系统是由数据库、数据库管理系统（及其应用开发工具）、应用程序和数据库管理员 DataBase Administrator, DBA 组成的存储、管理、处理和维护数据的系统。

数据管理技术的产生和发展

数据管理技术经历了⼈工管理、文件系统、数据库系统 3 个阶段。

人工管理阶段

特点：数据不保存：应用程序管理数据；数据不共享；数据不具有独立性。

缺点：数据的逻辑结构或物理结构发生变化后，必须对应用程序做相应的修改，这就加重了程序员的负担。

文件系统阶段

特点：数据可以长期保存；由文件系统管理数据。

缺点：数据共享性差，冗余度大；数据独立性差。

数据库系统阶段

特点：数据结构化；数据的共享性高，冗余度低，易扩充；数据独立性高；数据由 DBMS 统一管理和控制。

1.2 数据模型

数据模型 data model 是一种模型，是对现实世界数据特征的抽象。是对现实世界的模拟。

用来描述数据、组织数据和对数据进行操作的。

两类数据模型

数据模型应满足三方面要求：能比较真实地模拟现实世界；容易为人所理解；便于在计算机上实现。

根据模型应用的不同目的，可以将这些模型划分为两大类，它们分别属于两个不同的层次。

第一类是概念模型，第二类是逻辑模型和物理模型。

概念模型 / 信息模型 conceptual model

按用户的观点来对数据和信息建模，主要用于数据库设计。

逻辑模型 logical model

包括层次模型 hierarchical model、⽹状模型 network model、关系模型 relational model 面向对象数据模型 object oriented data model 和对象关系数据模型 object relational data model 半结构化数据模型 semistructured data model 等。

它是按计算机系统的观点对数据建模，主要用于数据库管理系统的实现。

物理模型 logical model

对数据最底层的抽象，它描述数据在系统内部的表示方式和存取方法，或在磁盘或磁带上的存储方式和存取方法，是面向计算机系统的。

概念模型

概念模型是现实世界到机器世界的一个中间层次，表现为：

概念模型用于信息世界的建模；现实世界到信息世界的第一层抽象；

数据库设计⼈员进行数据库设计的有⼒工具；数据库设计⼈员和用户之间进行交流的语言。

概念模型要求：

具有较强的语义表达能⼒；能够方便、直接地表达应用中的各种语义知识；简单、清晰、易于用户理解。

信息世界中的基本概念

实体 entity：客观存在并可相互区别的事物称为实体。

属性 attribute：实体所具有的某一特性称为属性。一个实体可以由若干个属性来刻画。

码 key：唯一标识实体的属性集称为码。

域 domain：域是一组具有相同数据类型的值的集合。属性的取指范围来自某个域。

实体型 entity type：用实体名及其属性名集合来抽象和刻画同类实体，称为实体型。

实体集 entity set：同一类型实体的集合称为实体集。

联系 relationship：实体之间的联系通常是指不同实体集之间的联系。

实体型之间的联系：实体之间的联系有一对一1:1、一对多1:n 和多对多m:n 等多种类型。

概念模型的一种表示方法：实体-联系方法 / E-R 图

E-R图提供了表示实体型、属性和联系的方法。

实体型：用矩形表示，框内写明实体名。

属性：用椭圆形表示，并用无向边将其与相应的实体型连接起来。

联系：用菱形表示，框内写明联系名，并用无向边分别与有关实体型连接起来，同时在无向边旁标上联系的类型。

数据模型的组成要素

数据模型通常由数据结构、数据操作和完整性约束三部分组成。 数据结构：描述数据库的组成对象以及对象之间的联系。

数据结构：描述数据库的组成对象以及对象之间的联系。

数据结构是所描述的对象类型的集合，是对系统静态特性的描述。

数据操作：数据操作是指对数据库中各种对象的实例允许执行的操作的集合，包括操作及有关的操作规则。

数据库主要有查询和更新（包括插入，删除、修改）两大类操作。是对系统动态特性的描述。

数据的完整性约束条件：数据的完整性约束条件是一组完整性规则。

常用的数据模型

层次模型 hierarchical model、⽹状模型 network model、关系模型 relational model 面向对象数据模型 object oriented data model 和对象关系数据模型 object relational data model

层次模型

待补充

⽹状模型

待补充

关系模型

关系模型的数据结构

关系 relation：一个关系对应通常说的一张表。

元组 tuple：表中的一行即为一个元组。

属性 attribute：表中的一列即为一个属性，给每一个属性起一个名称即属性名。

码 key：也称为码键。表中的某个属性组，它可以唯一确定一个元组。

域 domain：域是一组具有相同数据类型的值的集合。属性的取值范围来自某个域。

分量：元组中的一个属性值。

关系模式：对关系的描述，一般表示为 [ 关系名（属性 1，属性 2，⋯，属性）]

关系模型的数据操纵与完整性约束

关系模型的数据操纵主要包括查询、插入、删除和更新数据。这些操作必须满足关系的完整性约束条件。

关系的完整性约束条件包括三大类：实体完整性、参照完整性和用户定义的完整性。

关系模型的优缺点

特点：

关系模型与格式化模型不同，它是建立在严格的数学概念的基础上的。
关系模型的概念单一。
存取路径对用户透明，具有更高数据独立性、更好安全保密性，简化程序员和数据库开发建立的工作。

缺点：

存取路径对用户是隐蔽的，查询效率往往不如格式化数据模型。
为提高性能须对用户的查询请求进行优化，增加了开发数据库管理系统的难度。

1.3 数据库系统的结构

数据库系统模式的概念

模式 schema：数据库中全体数据的逻辑结构和特征的描述，它仅仅涉及型的描述，不涉及具体的值。

模式的一个具体值称模式的一个实例 instance。同一个模式可以有很多实例。

模式是相对稳定的，而实例是相对变动的。

数据库系统的三级模式结构

数据库系统的三级模式结构是指数据库系统是由 外模式、模式和内模式 三级构成。

模式 / 逻辑模式 schema

数据库中全体数据的逻辑结构和特征的描述，是所有用户的公共数据视图。

是数据库系统模式结构的中间层。

外模式 / 子模式 / 用户模式 external schema / subschema 是数据库用户（包括应用程序员和最终用户）能够看⻅和使用的局部数据的逻辑结构和特征的描述，是数据库用户的数据视图，是与某一应用有关的数据的逻辑表示。

内模式 / 存储模式 / 物理模式 internal schema / storage schema 一个数据库只有一个内模式。它是数据物理结构和存储方式的描述，是数据在数据库内部的组织方式。

数据库的二级映像功能与数据独立性

外模式 / 模式映像

定义了该外模式与模式之间的对应关系。这些映像定义通常包含在各自外模式的描述中。

当模式改变时（例如增加新的关系、新的属性、改变属性的数据类型等），由数据库管理员对各个外模式 / 模式的映像作相应改变，可以使外模式保持不变。应用程序是依据数据的外模式编写的，从而应用程序不必修改，保证了数据与程序的逻辑独立性，简称数据的 逻辑独立性。

模式 / 内模式映像

定义了数据全局逻辑结构与存储结构之间的对应关系。

当数据库的存储结构改变时（例如选用了另一种存储结构），由数据库管理员对模式 / 内模式映像作相应改变，可以使模式保持不变，从而应用程序也不必改变。保证了数据与程序的物理独立性，简称数据的 物理独立性。

数据与程序之间的独立性使得数据的定义和描述可以从应用程序中分离出去。

由于数据的存取由数据库管理系统管理，从而简化了应用程序的编制，大大减少了应用程序的维护和修改。

1.4 数据库系统的组成

硬件平台及数据库

硬件资源要求：

足够大的内存，用于存放操作系统、数据库管理系统的核心模块、数据缓冲区和应用程序。
足够大的磁盘或磁盘阵列等设备，用于存放数据库，有足够大的磁带（或光盘）作数据备份。
系统有较高的通道能⼒，以提高数据传送率。

软件

数据库系统的软件主要包括：

数据库管理系统。数据库管理系统是为数据库的建立、使用和维护配置的系统软件。
支持数据库管理系统运行的操作系统。
具有与数据库接口的高级语言及其编译系统，便于开发应用程序。
以数据库管理系统为核心的应用开发工具。
为特定应用环境开发的数据库应用系统。

⼈员

开发、管理和使用数据库系统的⼈员主要包括：

数据库管理员 DataBase Administrator, DBA、系统分析员和数据库设计⼈员、应用程序员和最终用户。

不同的⼈员涉及不同的数据抽象级别，具有不同的数据视图。

Note 02 关系数据库

2.1 关系数据结构及形式化定义

关系

单一的数据结构 关系：现实世界的实体以及实体间的各种联系均用关系来表示。

逻辑结构 ⼆维表：从用户⻆度，关系模型中数据的逻辑结构是一张⼆维表。

关系模型是建立在集合代数的基础上。

域 domain：域是一组具有相同数据类型的值的集合。

笛卡⼉积 cartesian product：笛卡⼉积是域上的一种集合运算。

给定一组域 D1, D2, ..., Dn，允许其中某些域是相同的，D1, D2, ..., Dn 的笛卡尔积为：

D1 × D2 × ... × Dn = {(d1, d2, ..., dn) | di ∈ Di, i = 1, 2, ..., n}

元组 / n 元组 tuple / n-tuple：笛卡尔积中的每一个元素 (d₁, d₂, ..., dₙ)。

分量 component：元素中的每一个值dᵢ。

基数 cardinal number：一个域允许的不同取值个数。

关系 relation： D₁ × D₂ × ... × Dₙ 的子集叫做在域 D₁, D₂, ..., Dₙ 上的关系，表示为 R(D₁, D₂, ..., Dₙ)。

R表示关系名， n表示关系的 目或度 Degree。关系中的每个元素是关系中的元组，通常用t表示。

当n=1时，称该关系为 单元关系 / 一元关系 unary relation，

当n=2时，称该关系为 ⼆元关系 binary relation。

关系也是一个⼆维表，表的每行对应一个元组，表的每列对应一个域。

每列的名字称为 属性 attribute，n目关系必有n个属性。

候选码 candidate key：关系中的某一属性组的值能唯一地标识一个元组，其子集不能，则该属性组为候选码。

全码 all key：在最极端的情况下，关系模式的所有属性都是这个关系模式的候选码。

主码 primary key：若一个关系有多个候选码，则选定其中一个为主码。

主属性 prime attribute：候选码的诸属性称为主属性。

非主属性 / 非码属性 non-prime attribute / non-key attribute：不包含在任何候选码中的属性。

关系的三种类型：

基本关系 / 基本表 / 基表：实际存在的表，是实际存储数据的逻辑表示。
查询表：查询结果对应的表。
视图表：由基本表或其他视图表导出的表，是虚表，不对应实际存储的数据。

基本关系的性质：

列是同质的 Homogeneous：每一列中的分量是同一类型的数据，来自同一个域（如同 int）。
不同的列可出自同一个域，称其中的每一列为一个属性，不同的属性要给予不同的属性名。
列的顺序无所谓，即列的次序可以任意交换。
任意两个元组的候选码不能取相同的值。
行的顺序无所谓，即行的次序可以任意交换。
分量必须取原子值，即每一个分量都必须是不可分的数据项。

关系模式

关系模式 relation schema：关系模式是对关系的描述，关系模式是型，关系是值。

元组集合的结构：属性构成、属性来自的域属性与域之间的映象关系
一个关系通常由赋予它的元组语义确定。
现实的世界中还存在着完整性约束，

关系模式可以形式化地表示为 R(U, D, DOM, F)。

R：关系名，用于标识该关系的名称。

U：组成该关系的属性名集合，即关系中所有字段的名称列表。

D：属性组 U 中各个属性所来自的域，即每个属性取值的数据范围或类型集合。

DOM：属性向域的映射集合，描述每个属性具体对应哪一个域。

F：属性间的数据依赖关系集合，通常指函数依赖、多值依赖等约束条件，用于刻画属性之间的逻辑关联。

关系模式与关系

关系模式是静态的、稳定的。

关系是动态的、随时间不断变化的。

关系是关系模式在某一时刻的状态或内容。

关系数据库

关系数据库：在一个给定的应用领域中，所有关系的集合构成一个关系数据库。

关系数据库的型与值

关系数据库的型：关系数据库模式，对关系数据库的描述。
关系数据库模式：若干域的定义，在这些域上定义的若干关系模式。
关系数据库的值：关系模式在某一时刻对应的关系的集合，简称为关系数据库。

关系模型的存储结构

在关系数据库的物理组织中

有的 DBMS 中一个表对应一个操作系统⽂件，将物理数据组织交给操作系统完成；

有的 DBMS 从操作系统那⾥申请若干个大的文件，自己划分文件空间，组织表、索引等存储结构，并进行存储管理。

2.2 关系操作

基本的关系操作

基本的关系操作

包括 查询 和 数据更新 两大部分查询：可分为选择select、投影project、连接join、除divide、并union、差except、交 intersection、 笛卡⼉积等。

其中，选择、投影、并、差、笛卡尔积是 5 种基本操作。

数据更新：插入insert、删除 delete、修改update。

查询的表达能⼒是其中最主要的部分。

关系操作的特点是集合操作方式，即：操作的对象和结果都是集合。

这种操作方式也称为 一次一集合set-at-a-time 的方式。

相应地，非关系数据模型的数据操作方式则为 一次一记录record-at-a-time 的方式。

关系数据语言的分类

关系代数语言：

用对关系的运算来表达查询要求。代表：ISBL。

关系演算语言：

用谓词来表达查询要求。

元组关系演算语言：谓词变元的基本对象是元组变量，代表：APLHA，QUEL。
域关系演算语言：谓词变元的基本对象是域变量，代表：QBE。

具有关系代数和关系演算双重特点的语言：

代表: SQL Structured Query Language

2.3 关系的完整性

关系模型中有三类完整性约束：

实体完整性 entity integrity
参照完整性 referential integrity
用户定义的完整性user-defined integrity

关系的两个不变性：实体完整性和参照完整性是关系模型必须满足的完整性约束条件。应该由关系系统自动支持。

用户定义的完整性是应用领域需要遵循的约束条件，体现了具体领域中的语义约束。

实体完整性

规则：若属性（指一个或一组属性） 是基本关系 的主属性， 则 不能取空值null value。

实体完整性规则是针对基本关系而言的。一个基本表通常对应现实世界的一个实体集。
现实世界中的实体是可区分的，即它们具具有某种唯一性标识。
关系模型中以主码作为唯一性标识。
主码中的属性即主属性不能取空值。

参照完整性

现实世界中的实体之间往往存在某种联系，在关系模型中实体及实体间的联系都是用关系来描述的，这样就自然存在着关系与关系间的引用。

主码用下划线标识。

外码：设是基本关系的一个或一组属性，但不是关系的码，是基本关系的主码。如果与相对应，则称是的外码 foreign key。

并称基本关系为 参照关系 referencing relation，基本关系为被 参照关系 / 目标关系referenced relation / target relation。关系 R 和 S 不一定是不同的关系。

规则：若属性（或属性组） 是基本关系 的外码，它与基本关系 的主码 相对应（基本关系 和不一 定是不同的关系），则对于 中每个元组在 上的值必须：

或者取空值（ F 的每个属性值均为空值）；
或者等于 S 中某个元组的主码值。

用户定义的完整性

规则：针对某一具体关系数据库的约束条件，它反映某一具体应用所涉及的数据必须满足的语义要求。 关系模型应提供定义和检验这类完整性的机制，以便用统一的系统的方法处理它们，而不需由应用程序承担这一功能。

2.4 关系代数

关系代数是一种抽象的查询语言，用对关系的运算来表达查询。 关系代数的运算对象是关系，运算结果也是关系。

关系代数按运算符的不同可分为门传统的集合运算 和 专⻔的关系运算 两类。

集合运算是从关系的⽔平方向即行的⻆度进行，专门的关系运算不仅涉及行而且涉及列。

传统的集合运算

传统的集合运算是⼆目运算，包括并、差、交、笛卡⼉积 4 种运算。

设关系 R 和关系 S 具有相同的目 n（即两个关系都有 n 个属性），且相应的属性取自同一个域，t 是元组变量，t ∈ R 表示 t 是 R 的一个元组。

并 union：R ∪ S = { t | t ∈ R ∨ t ∈ S }
其结果仍为 n 目关系，由属于 R 或属于 S 的元组组成。

差 except：R - S = { t | t ∈ R ∧ t ∉ S }
其结果关系仍为 n 目关系，由属于 R 而不属于 S 的所有元组组成。

交 intersection：R ∩ S = { t | t ∈ R ∧ t ∈ S } ， R ∩ S = R - (R - S)
其结果关系仍为 n 目关系，由既属于 R 又属于 S 的所有元组组成。

笛卡尔积 cartesian product：R × S = { trts | tr ∈ R ∧ ts ∈ S }
R：n 目关系，k1 个元组，S：m 目关系，k2 个元组。
运算结果为：行为 k1 × k2 个元组，列为 (n + m) 列元组的集合。
其中元组的前 n 列是关系 R 的一个元组，后 m 列是关系 S 的一个元组。

专门的关系运算

关系运算包括：选择、投影、连接、除运算。

Note 03 关系数据库标准语言 SQL

3.1 SQL 概述

SQL Structured Query Language 结构化查询语言，是关系数据库的标准语言。

SQL 是一个通用的、功能极强的关系数据库语言。

SQL 的产生与发展

SQL 的特点

综合统一

集数据定义语言DDL，数据操纵语言DML，数据控制语言DCL 功能于一体。
可以独立完成数据库生命周期中的全部活动：定义关系模式，插入数据，建立数据库；对数据库中数据进行

行查询和更新；数据库重构和维护；数据库安全性、完整性控制等。

用户数据库投入运行后，可根据需要随时逐步修改模式，不影响数据的运行。
数据操作符统一。

高度非过程化

用 SQL 进行数据操作时，只要提出 “做什么”，无须指明 “怎么做”，因此无须了解存取路径。

存取路径的选择以及 SQL 的操作过程由系统自动完成。

面向集合的操作方式

SQL 采用集合操作方式不仅操作对象、查找结果可以是元组的集合；而且一次插入、删除、更新操作的对象也可以是元组的集合。

以同一种语法结构提供多种使用方式

SQL 是独立的语言：能够独立地用于联机交互的使用方式。

SQL ⼜是嵌入式语言：SQL 能够嵌入到高级语言（例如C，C++，Java）程序中，供程序员设计程序时使用。

语言简洁，易学易用

SQL 功能极强，完成核心功能只用了 9 个动词。

SQL 功能	动词
数据查询	SELECT
数据定义	CREATE, DROP, ALTER
数据操纵	INSERT, UPDATE, DELETE
数据控制	GRANT, REVOKE

缺点：SQL 只包含定义和操作命令，不包含控制流命令，如 IF...THEN、DO...WHILE。

SQL 的基本概念

SQL 支持关系数据库三级模式结构。

其中外模式包括若干 视图 view 和部分 基本表 base table，数据库模式包括若干基本表，内模式包括若干 存储文件 stored file。

基本表

本身独立存在的表，关系数据库管理系统中一个关系就对应一个基本表。

一个或多个基本表对应一个存储文件，一个表可以带若干索引，索引也存放在存储文件中。

存储文件

逻辑结构组成了关系数据库的内模式。存储文件的物理结构对最终用户是隐蔽的。

视图

从一个或几个基本表导出的表。

本身不独立存储在数据库中，即数据库中只存放视图的定义而不存放视图对应的数据。

数据存放在导出视图的基本表中，因此视图是一个虚表。

视图在概念上与基本表等同，用户可以在视图上再定义视图。

3.2 学生-课程数据库

学生-课程模式S-T ，学生-课程数据库中包括以下三个表：：

学生表：Student(Sno,Sname,Ssex,Sage, Sdept)

课程表：Course(Cno, Cname, Cpno, Ccredit)

学生选课表：SC(Sno.Cno,Grade)

3.3 数据定义

SQL 的数据定义功能包括模式定义、表定义、视图和索引的定义。

一个关系数据库管理系统的实例 instance 中可以建立多个数据库，一个数据库中可以建立多个模式，一个模式下通常包括多个表、视图和索引等数据库对象。

模式的定义与删除

定义模式

语句格式：【CREATE SCHEMA < 模式名 > AUTHORIZATION < 用户名 > ;】

/*为用户 WANG 定义一个学生-课程模式 S-T*/
CREATE SCHEMA "S-T" AUTHORIZATION WANG;

若没有指定模式名，那么 < 模式名 > 隐含为 < 用户名 >。

/*为用户 WANG 定义一个模式，模式名隐含为 WANG*/
CREATE SCHEMA AUTHORIZATION WANG;

在 CREATE SCHEMA 中可以接受 CREATE TABLE， CREATE VIEW 和 GRANT 子句。也就是说用户可以在创建模式的同时在这个模式定义中进一步创建基本表、视图，定义授权。

语句格式：【CREATE SCHEMA < 模式名 > AUTHORIZATION < 用户名 >

[ < 表定义子句> | < 视图定义子句> | <授权定义子句> ] ;】

/*为用户 ZHANG 创建一个模式 TEST，并且在其中定义一个表 TAB1*/
CREATE SCHEMA TEST AUTHORIZATION ZHANG 
CREATE TABLE TAB1(COL1 SMALLINT, //短整数（2字节）
                  COL2 INT, //长整数（4字节）
                  COL3 CHAR(20), //长度为20的定长字符串
                  COL4 NUMERIC(10,3), //定点数，由10位数字（不包括符号、⼩数点）组成，⼩数点后面有3位数
字
                  COL5 DECIMAL(5,2) //同 NUMERIC，定点数，由5位数字组成，⼩数点后面有2位数字
                  );

执行创建模式语句必须拥有 DBA 权限，或者 DBA 授予在 CREATE SCHEMA 的权限。

删除模式

语句格式：【DROP SCHEMA < 模式名 > < CASCADE | RESTRICT > ;】

/*删除了模式 ZHANG，同时删除模式为 CASCADE ，该模式中已经定义的表 TAB1 也删除*/
DROP SCHEMA ZHANG CASCADE;

说明：CASCADE 和 RESTRICT 必须⼆选一。

级联 CASCADE：删除模式的同时把该模式中所有的数据库对象全部删除。

限制 RESTRICT：如果该模式中定义了下属的数据库对象（如表、视图等），则拒绝该删除语句的执行。当该模式中没有任何下属的对象时才能执行。

基本表的定义、删除与修改

定义基本表

语句格式：【CREATE TABLE < 表名 > ( < 列名 >< 数据类型 >［列级完整性约束条件］ [, < 列名 > < 数据类型 > [ 列级完整性约束条件 ] ]

[, < 表级完整性约東条件 > ] ) ;】

/*建立一个“学生”表 Student*/
CREATE TABLE Student (Sno CHAR(9) PRIMARY KEY,  /*列级完整性约束条件，Sno 是主码*/
                      Sname CHAR(20) UNIQUE,    /* Sname 取唯一值*/
                      Ssex CHAR(2),
                      Sage SMALLINT,
                      Sdept CHAR(20)

/*建立一个“课程”表 Course*/
CREATE TABLE Course (Cno CHAR(4) PRIMARY KEY,   /*列级完整性约東条件，Cno 是主码*/
                     Cname CHAR(40) NOT NULL,   /*列级完整性约束条件，Cname 不能取空值*/
                     Cpno CHAR(4),              /* Cpno 的含义是先修课*/
                     Ccredit SMALLINT,
                     FOREIGN KEY (Cpno) REFERENCES Course(Cno)
                                   /*表级完整性约束条件，Cpno是外码，被参照表是 Course，被参照列是Cno*/
                    );                          /*参照表和被参照表可以是同一个表*/
/*建立学生选课表 SC*/
CREATE TABLE SC(Sno CHAR(9)，
                Cno CHAR(4)，
                Grade SMALLINT，
                PRIMARY KEY （Sno，Cno），/*主码由两个属性构成，必须作为表级完整性进行定义*/
                FOREIGN KEY (Sno) REFERENCES Student(Sno)，
                                         /*表级完整性约束条件，Sno 是外码，被参照表是 Student */
                FOREIGN KEY (Cno) REFERENCES Course(Cno)
                                         /*表级完整性约束条件，Cno 是外码，被参照表是 Course */
               )；

数据类型

模式与表

每一个基本表都属于某一个模式，一个模式包含多个基本表。

当定义基本表时一般可以有三种方法定义它所属的模式。

方法一，在表名中明显地给出模式名。

CREATE TABLE "S-T".Student (***);     /* Student 所属的模式是S-T*/
CREATE TABLE "S-T".Course(***);       /* Course 所属的模式是S-T*/
CREATE TABLE "S-T".SC(***);           /* SC 所属的模式是S-T*/

方法⼆，在创建模式语句中同时创建表。

方法三，设置所属的模式，这样在创建表时表名中不必给出模式名。

当用户创建基本表 / 数据库对象时若没有指定模式，系统根据搜索路径 search path 来确定该对象所属的模式。

/*显示当前的搜索路径*/
SHOW search_path;

/*搜索路径的当前默认值*/
$ user, PUBLIC;

/*数据库管理员可以设置搜索路径*/
SET search_path TO "S-T", PUBLIC;

/*然后，定义基本表时 DBMS 发现搜索路径中【第一个】模式名作为基本表所属模式(上述 SET 中第一个是"S-T")*/
CREATE TABLE Student (***);

修改基本表

随着应用环境和应用需求的变化，有时需要修改已建立好的基本表。SQL 语言用 AITER TABLE 语句修改基本表。

语句格式：【ALTER TABLE < 表名 > [ ADD [ COLUMN ] < 新列名 > < 数据类型 > [ 完整性约束 ] ]

[ ADD < 表级完整性约束 > ]

[ DROP [ COLUMN ] < 列名 > [ CASCADE | RESTRICT ] ]

[ DROP CONSTRAINT < 完整性约束名 > [ CASCADE | RESTRICT ] ]

[ ALTER COLUMN < 列名 > < 数据类型 > ] ;】

说明：语句中 < 表名 > 是要修改的基本表。

ADD 子句用于增加新列、新的列级完整性约束条件和新的表级完整性约束条件。

DROP COLUMN 子句用于删除表中的列。

DROP CONSTRAINT 子句用于删除指定的完整性约束条件。

ALTER COLUMN 子句用于修改原有的列定义，包括修改列名和数据类型。

两个 DROP 语句中的删除模式不要求强制指定：在 MySQL 中，默认使用RESTRICT。

/*向 Student 表增加“入学时间”列，其数据类型为日期型。*/
ALTER TABLE Student ADD S_entrance DATE;

/*将年龄的数据类型由字符型（假设原来的数据类型是字符型）改为整数。*/
ALTER TABLE Student ALTER COLUMN Sage INT;

/*增加课程名称必须取唯一值的约束条件。*/
ALTER TABLE Course ADD UNIQUE(Cname);

删除基本表

当某个基本表不再需要时，可以使用 DROP TABLE 语句删除它。

语句格式：【DROP TABLE < 表名 > [ RESTRICT | CASCADE ] ;】

说明：默认使用RESTRICT。

/*删除 Student 表*/
DROP TABLE Student CASCADE;

索引的建立与删除

建立索引的目的：加快查询速度。

谁可以建立索引：DBA 或表的属主（即建立表的⼈）。

DBMS 一般会自动建立以下列上的索引：PRIMARY KEY；UNIQUE；

谁维护索引：DBMS 自动完成。

使用索引：DBMS 自动选择是否使用索引及使用哪些索引。

建立索引

在 SQL 语言中，建立索引使用 CREATE INDEX 语句。

语句格式：

【CREATE [ UNIQUE ] [ CLUSTER ] INDEX < 索引名 > ON < 表名 > ( < 列名 > [ 次序 ] [ < 列名 > [ 次序 ] ] ...) ;】

说明：语句中 < 表名 > 是要建索引的基本表的名字。

索引可以建立在该表的一列或多列上，各列名之间用逗号分隔。

每个 < 列名 > 后面还可以用 < 次序 > 指定索引值的排列次序，可选 ASC 升序或 DESC 降序，默认 ASC。

UNIQUE 表明此索引的每一个索引值只对应唯一的数据记录。

CLUSTER 表示要建立的索引是聚簇索引。聚簇索引是指索引顺序与表中记录的物理顺序一致的索引组织。

在最经常查询的列上建立聚簇索引以提高查询效率；
一个基本表上最多只能建立一个聚簇索引；
经常更新的列不宜建立聚簇索引。

/*为 Student 表按学号升序建唯一索引*/
CREATE UNIQUE INDEX Stusno ON Student(Sno);

/*为 Course 表按课程号升序建唯一索引*/
CREATE UNIQUE INDEX Coucno ON Course(Cno);

/*为 SC 表按学号升序和课程号降序建唯一索引*/
CREATE UNIQUE INDEX SCno ON SC(Sno ASC,Cno DESC);

/*为 Student 表的 Sname 列建立一个聚簇索引*/
CREATE CLUSTER INDEX Stusname ON Student (Sname) ;

修改索引

对于已经建立的索引，如果需要对其重新命名，可以使用 ALTER INDEX 语句。

语句格式：【ALTER INDEX < 旧索引名 > RENAME TO < 新索引名 >；】

/*将 SC 表的 SCno 索引名改为 SCSno */
ALTER INDEX SCno RENAME TO SCSno;

删除索引

在 SQL 中，删除索引使用 DROP INDEX 语句。

语句格式：【DROP INDEX < 索引名 > ;】

说明：删除索引时，系统会同时从数据字典中删去有关该索引的描述。

/*删除 Student 表的 Stusname 索引*/
DROP INDEX Stusname;

数据字典

数据字典是关系数据库管理系统内部的一组系统表。

数据字典记录了数据库中所有的定义信息，包括模式定义、视图定义、索引定义、完整性约束定义、各类用户对数据库的操作权限、统计信息等。

RDBMS 执行 SQL 数据定义时，实际就是更新数据字典。

3.4 数据查询

数据查询是数据库的核心操作。SQL 提供了 SELECT 语句进行数据查询。

语句格式：【 SELECT [ ALL | DISTINCT ] < 目标列表达式 > [ , < 目标列表达式 > ] ...

FROM < 表名或视图名 > [ , < 表名或视图名 > ] ... | ( < SELECT 语句 > ) [ AS ] < 别名 >

[ WHERE < 条件表达式 > ]

[ GROUP BY < 列名1 > [ HAVING < 条件表达式 > ] ]

[ ORDER BY < 列名2 > [ ASC | DESC ] ] ; 】

说明：根根据 WHERE 子句的条件表达式从 FROM 子句指定的基本表、视图或派生表中找出满足条件的元组，再按 SELECT 子句中的目标列表达式选出元组中的属性值形成结果表。

如果有 GROUP BY 子句，则将结果按 < 列名1 > 的值进行分组，该属性列值相等的元组为一个组。

通常会在每组中作用聚集函数。如果 GROUP BY 子句带 HAVING 短语，则只有满足指定条件的组才予以输出。

如果有 ORDER BY 子句，则结果表还要按 < 列名2 > 的值的升序或降序排序。

单表查询

指仅涉及一个表的查询。

选择表中的若⼲列

查询指定列

语句格式：【 SELECT < 目标列表达式 > [ , < 目标列表达式 > ] ... FROM < 表名或视图名 > ; 】

/*查询全体学生的学号与姓名*/
SELECT Sno,Sname FROM Student；
/*查询全体学生的姓名、学号、所在系*/
SELECT Sname,Sno,Sdept FROM Student；

查询指定列

语句格式：【 SELECT * FROM < 表名或视图名 > ; 】

/*查询全体学生的详细记录*/
SELECT * FROM Student；

查询经过计算的值

说明：< 目标列表达式 > 可以为算术表达式、字符串常量、函数、列别名

/*算术表达式：查询全体学⽣的姓名及其出⽣年份 出⽣年份 = 2004 - Sage */ 
SELECT Sname,2014-Sage FROM Student； 

/*字符串常量、函数：查询全体学⽣的姓名、出⽣年份和所在的院系，要求用⼩写字⺟表示系名。 
出⽣年份前使用字符串'Year of Birth:'标注，⼩写字⺟表示系名使用函数 LOWER() */ 
SELECT Sname,'Year of Birth:',2014-Sage,LOWER(Sdept) FROM Student； 

/*别名：查询全体学⽣的姓名、出⽣年份和所在的院系，要求用⼩写字⺟表示系名。通过指定别名来改变查询结果的列标题， 
别名可在原列名、算术表达式、字符串常量及函数后添加空格、在","前标注 */ 
SELECT Sname NAME,'Year of Birth:' BIRTH,2014-Sage BIRTHDAY,LOWER(Sdept) DEPARTMENT 
FROM Student;

选择表中的若干元组

消除取值重复的行

语句格式：

【 SELECT DISTINCT < 目标列表达式 > [ , < 目标列表达式 > ] ... FROM < 表名或视图名 > ; 】

说明：如果没有指定 DISTINCT 关键词，则默认为 ALL 。

/*查询选修了课程的学生学号，查询结果不重复*/
SELECT DISTINCT Sno FROM SC；

查询满足条件的元组

语句格式：【 SELECT [ ALL | DISTINCT ] < 目标列表达式 > [ , < 目标列表达式 > ] ...

WHERE < 条件表达式 > ; 】

说明：WHERE 子句查询满足指定条件的元组，查询条件谓词如下表，

比较中， <> 等同于 != ；

确定范围中， BETWEEN 后是范围的下限（即低值）， AND 后是范围的上限（即高值）。

字符匹配中，字符串的匹配 语法格式：【 [ NOT ] LIKE '< 匹配串 >' [ ESCAPE ' < 换码字符 > ' ]】

< 匹配串 > 可以是一个完整的字符串，也可以含有通配符 % 和 _ 。
% ：任意长度（长度可以为 0 ）的字符串。
_ ：任意单个字符
如果 LIKE 后面的匹配串中不含通配符，则可以用 = 运算符取代 LIKE 谓词，用 <> 或 != 运算符取代 NOT LIKE 谓词。
数据库字符集为 ASCII 时一个汉字需要两个 ，当字符集为 GBK（国家标准扩展编码）时只需要一个 。
如果用户要查询的字符串本身就含有通配符，则使用 ESCAPE ' < 换码字符 > ' 短语对通配符进行转义。 e.g. ESCAPE '' 表示 \ 为换码字符。匹配串中在 \ 后面的字符不再具有通配符含义，转义为普通字符。

空值中， IS 、 IS NOT 不能使用 = 、 <> 或 != 代替。

多重条件中，逻辑运算符 AND 和 OR 可用来连接多个查询条件。 AND 优先级高于 OR ，但可用括号改变。

/*比较：查询考试成绩不及格的学⽣的学号*/ 
SELECT DISTINCT Sno FROM SC WHERE Grade<60;  
WHERE Grade<60; 
/*确定范围：查询年龄不在20～23岁之间的学⽣姓名、系别和年龄*/ 
SELECT Sname,Sdept,Sage FROM Student 
WHERE Sage NOT BETWEEN 20 AND 23; 

/*确定集合：查询计算机科学系[CS]、数学系[MA]和信息系[IS]学⽣的姓名和性别*/ 
SELECT Sname, Ssex FROM Student 
WHERE Sdept IN ('CS','MA','IS'); 

/*字符匹配.1：查询学号为 201215121 的学⽣的详细情况*/ 
SELECT * FROM Student 
WHERE Sno LIKE '201215121'; 

/*字符匹配.2：查询所有姓刘的学⽣的姓名、学号和性别*/ 
SELECT Sname,Sno,Ssex FROM Student 
WHERE Sname LIKE '刘%'; 

/*字符匹配.3：查询学号为 201215121 的学⽣的详细情况*/ 
SELECT * FROM Student 
WHERE Sno = '201215121'; 

/*字符匹配.4：查询姓“欧阳”且全名为三个汉字的学⽣的姓名*/ 
SELECT Sname FROM Student 
WHERE Sname LIKE '欧阳_'; /*ASCII*/ 
SELECT Sname FROM Student 
WHERE Sname LIKE '欧阳__'; /*GBK*/ 

/*字符匹配.5：查询以“DB_”开头，且倒数第三个字符为 i 的课程的详细情况，此处换码字符为'/' */ 
SELECT * FROM Course
          WHERE Cname LIKE 'DB/_%i__' ESCAPE '/'; 

/*空值：查询缺少成绩的学⽣的学号和相应的课程号*/ 
SELECT Sno,Cno FROM SC 
WHERE Grade IS NULL; 

/*多重条件：查询计算机科学系年龄在20岁以下的学⽣姓名*/ 
SELECT Sname FROM Student 
WHERE Sdept='CS' AND Sage<20;

ORDER BY 子句

语句格式：

【 SELECT [ ALL | DISTINCT ] < 目标列表达式 > [ , < 目标列表达式 > ] ...

FROM < 表名或视图名 > [ , < 表名或视图名 > ] ... | ( < SELECT 语句 > ) [ AS ] < 别名 >

[ WHERE < 条件表达式 > ]

ORDER BY < 列名2 > [ ASC | DESC ] ; 】

说明：ORDER BY 子句对查询结果按照一个或多个属性列的升序 ASC 或降序 DESC 排列，默认值为升序。

当排序列含空值时：空值默认为最⼤值。 ASC 空值的元组最后显示。 DESC 空值的元组最先显示。

聚集函数

语句格式：

【 SELECT [ 聚集函数 ]

[ WHERE < 条件表达式 > ]

[ ORDER BY < 列名2 > [ ASC | DESC ] ] ; 】

说明：SQL 提供的聚集函数主要如下，限制条件默认 ALL ：

聚集函数	意义
【COUNT(*)】	统计元组个数
【COUNT([ALL \| DISTINCT] <列名>)】	统计一列中值的个数
【SUM([ALL \| DISTINCT] <列名>)】	计算一列值的总和（此列必须是数值型）
【AVG([ALL \| DISTINCT] <列名>)】	计算一列值的平均值（此列必须是数值型）
【MAX([ALL \| DISTINCT] <列名>)】	求一列值中的最大值
【MIN([ALL \| DISTINCT] <列名>)】	求一列值中的最小值

/*查询学⽣总⼈数*/ 
SELECT COUNT(*) FROM Student; 

/*查询选修了课程的学⽣⼈数*/ 
SELECT COUNT(DISTINCT Sno) FROM SC; 

/*计算选修 1 号课程的学⽣平均成绩*/ 
SELECT AVG(Grade) FROM SC WHERE Cno='1'; 

/*查询选修 1 号课程的学⽣最高分数*/ 
SELECT MAX(Grade) FROM SC WHERE Cno='1'; 

/*查询学⽣ 201215012 选修课程的总学分数*/ 
SELECT SUM(Ccredit) FROM SC, Course 
WHERE Sno='201215012' AND SC.Cno=Course.Cno;

GROUP BY 子句

语句格式：

FROM < 表名或视图名 > [ , < 表名或视图名 > ] ... | ( < SELECT 语句 > ) [ AS ] < 别名 >

[ WHERE < 条件表达式 > ]

GROUP BY < 列名1 > [ HAVING < 条件表达式 > ]

[ ORDER BY < 列名2 > [ ASC | DESC ] ] ; 】

说明：GROUP BY 子句将查询结果按某一列或多列的值分组，值相等的为一组。

未分组时，聚集函数将作用于整个查询结果，分组后聚集函数将作用于每一个组，即每一组都有一个函数值。

HAVING 短语指定筛选条件，对组进行筛选，最终只输出满足指定条件的组。

WHERE 子句作用于基本表或视图，从中选择满足条件的元组。 HAVING 短语作用于组，从中选择满足条件的组。

WHERE 子句与 HAVING 短语的作用对象不同， WHERE 子句中不能用聚集函数作为条件表达式。

/*求各个课程号及相应的选课⼈数*/ 
SELECT Cno, COUNT(Sno) FROM SC 
       GROUP BY Cno; 
       
/*查询选修了三⻔以上课程的学⽣学号*/ 
SELECT Sno FROM SC 
       GROUP BY Sno 
       HAVING COUNT(*) >3; 
       
/*查询平均成绩⼤于等于 90 分的学⽣学号和平均成绩*/ 
SELECT Sno, AVG(Grade) FROM SC 
        GROUP BY Sno 
        HAVING AVG(Grade)>=90;

连接查询

查询同时涉及两个以上的表。

等值与⾮等值连接查询

连接查询的 WHERE 子句中用来连接两个表的条件称为 连接条件 或 连接谓词。

连接格式：【 [ < 表名1 > .] < 列名1 > < 比较运算符 > [ < 表名2 > .] < 列名2 > 】

【 [ < 表名1 > .] < 列名1 > BETWEEN [ < 表名2 > .] < 列名2 > AND [ < 表名3 > .] < 列名3 > 】

当连接运算符为 = 时，称为 等值连接。使用其他运算符称为 ⾮等值连接。

连接谓词中的列名称为 连接字段。连接条件中的各连接字段类型必须是可比的，但名字不必相同。

连接操作的一种执行⽅法：嵌套循环法 NESTED-LOOP 。

/*查询每个学⽣及其选修课程的情况*/ 
SELECT Student.*,SC.* /* '表名.*' 表示表中所有信息 */ 
        FROM Student,SC 
        WHERE Student.Sno=SC.Sno;

自然连接：在等值连接中把目标列中重复的属性列去掉。

若属性名唯一，引用时可以去掉表名前缀；若一个属性在两个表中均出现，则引用时必须加上表名前缀。

一条 SQL 语句可以同时完成选择和连接查询，这时 WHERE 子句是由连接谓词和选择谓词组成的复合条件。

/*查询选修 2 号课程且成绩在 90 分以上的所有学⽣的学号和姓名*/ 
SELECT Student.Sno,Sname,Ssex,Sage, Sdept, Cno, Grade 
        FROM Student,SC 
        WHERE Student.Sno=SC.Sno AND 
                    SC.Cno='2' AND SC.Grade>90;

⾃身连接

一个表与其⾃⼰进行连接。通过为其取两个别名加以区别，且必须使用别名前缀。

连接格式：【 FROM < 表名 > < 别名1 > , < 表名 > < 别名2 > WHERE [ 连接条件 ] 】

若只取一个别名，另一个用原名，则 SQL 引擎将无法区分表中的不同实例。

/*查询每一⻔课的间接先修课（即先修课的先修课）*/ 
SELECT FIRSTC.Cno,SECONDC.Cpno 
        FROM Course FIRSTC,Course SECONDC /*MySQL 中 'FIRST' 是关键字，此处教材取别名为'FIRST'不合适*/ 
        WHERE FIRSTC.Cpno=SECONDC.Cno;

外连接

MySQL 支持左外连接与右外连接。

但不直接支持全外连接。如需实现全外连接，可通过将左外连接和右外连接的结果集进行 UNION 操作实现。

连接格式：左外连接：【 FROM < 表名1 > LEFT OUTER JOIN < 表名2 > ON [ 连接条件 ] 】

右外连接：【 FROM < 表名1 > RIGHT OUTER JOIN < 表名2 > ON [ 连接条件 ] 】

全外连接：【 FROM < 表名1 > LEFT OUTER JOIN < 表名2 > ON [ 连接条件 ]

UNION < 表名1 > RIGHT OUTER JOIN < 表名2 > ON [ 连接条件 ] 】

/*查询每个学⽣及其选修课程的情况,左外连接实现*/ 
SELECT Student.Sno,Sname, Ssex,Sage,Sdept,Cno,Grade 
        FROM Student LEFT OUTER JOIN SC ON (Student.Sno=SC.Sno);

多表连接

两个以上的表进行连接。

/*查询每个学⽣的学号、姓名、选修的课程名及成绩*/ 
SELECT Student.Sno,Sname,Cname,Grade 
        FROM Student,SC,Course 
        WHERE Student.Sno=SC.Sno AND SC.Cno=Course.Cno;

嵌套查询

在 SQL 语言中，一个 SELECT—FROM—WHERE 语句称为一个 查询块。

嵌套查询 nested query ：将一个查询块嵌套在另一个查询块的 WHERE 子句或 HAVING 短语的条件中的查询。

上层的查询块称为 外层查询 / ⽗查询，下层查询块称为 内层查询 / 子查询。

子查询中不能使用 ORDER BY 子句（ ORDER BY 子句只能对最终查询结果排序）。

层层嵌套⽅式反映了 SQL 语言的结构化。

有些嵌套查询可以用连接运算替代，有些是不能替代的。

带有 IN 谓词的子查询

在嵌套查询中，子查询的结果往往是个集合，用 IN 谓词表示⽗查询的条件在子查询结果的集合中。

WHERE < 目标列表达式 > IN ( [ 子查询 ] ) ; 】

/*查询选修了课程名为“信息系统”的学⽣学号和姓名。⽅法一：嵌套查询*/ 
SELECT Sno,Sname 
        FROM Student 
        WHERE Sno IN 
                 (SELECT Sno 
                        FROM SC 
                        WHERE Cno IN 
                                 (SELECT Cno 
                                        FROM Course 
                                        WHERE Cname='信息系统' 
                                   ) 
                 ); 
/*查询选修了课程名为“信息系统”的学⽣学号和姓名。⽅法⼆：连接查询*/ 
SELECT Student. Sno,Sname 
        FROM Student,SC,Course 
        WHERE Student.Sno=SC.Sno AND 
                 SC.Cno=Course.Cno AND 
                 Course.Cname='信息系统';

如果子查询的查询条件不依赖于⽗查询，称为 不相关子查询。

如果子查询的查询条件依赖于⽗查询，称为 相关子查询 correlated subquery ，

整个查询语句称为 相关嵌套查询 correlated nested query 语句。

带有比较运算符的子查询

确切知道内层查询返回的是单个值时，可以用比较运算符与子查询结果进行比较。

FROM < 表名或视图名 > [ AS ] < 别名 >

WHERE < 目标列表达式 > < 比较运算符 > ( [ 单返回值子查询 ] ) ; 】

/*找出每个学⽣超过他⾃⼰选修课程平均成绩的课程号*/ 
SELECT Sno,Cno 
        FROM SC x 
        WHERE Grade >=(SELECT AVG(Grade) 
                                        FROM SC y 
                                        WHERE y.Sno=x. Sno);

带有 ANY / SOME 或 ALL 谓词的子查询

子查询返回多值时要用 ANY / SOME 或 ALL 谓词修饰符。使用 ANY 或 ALL 谓词时则必须同时使用比较运算符。

FROM < 表名或视图名 > [ AS ] < 别名 >

WHERE < 目标列表达式 > < 比较运算符 > [ ALL | ANY ] ( [ 多返回值子查询 ] ) ; 】

/*查询⾮计算机科学系中比计算机科学系所有学⽣年龄都⼩的学⽣姓名及年龄。⽅法一：多返回值子查询*/ 
SELECT Sname,Sage 
        FROM Student 
        WHERE Sage < ALL 
                 (SELECT Sage FROM Student 
                           WHERE Sdept='CS') 
                           AND Sdept<>'CS': 
/*查询⾮计算机科学系中比计算机科学系所有学⽣年龄都⼩的学⽣姓名及年龄。⽅法⼆：聚集函数*/ 
SELECT Sname,Sage 
        FROM Student 
        WHERE Sage < 
                 (SELECT MIN(Sage) 
                        FROM Student 
                        WHERE Sdept='CS') 
                        AND Sdept<>'CS';

用聚集函数实现子查询通常比直接用 ANY 或 ALL 查询效率要高。

带有 EXISTS 谓词的子查询

EXISTS 代表存在量词。带有 EXISTS 谓词的子查询不返回任何数据，只产生逻辑真值 “true” 或逻辑假值 “false”。

FROM < 表名或视图名 > [ AS ] < 别名 >

WHERE [ NOT ] EXIETS ( [ 子查询 ] ) ; 】

说明：由 EXISTS 引出的子查询目标列表都用 * ，因为带 EXISTS 子查询只返回真值或假值，给出列名无实际意义。

( * 待复习 ) 全称量词 for all 通过 (∀x)P≡¬(∃x)(¬P) 实现。

( * 待复习 ) 蕴涵 implication 通过p→q≡¬p∨qp→q≡¬p∨_q_实现。

/*查询所有选修了 1 号课程的学生姓名*/
SELECT Sname
    FROM Student
    WHERE EXISTS
        (SELECT *
            FROM SC
            WHERE Sno=Student.Sno AND Cno='1');
/*查询没有选修 1 号课程的学生姓名*/
SELECT Sname
    FROM Student
    WHERE NOT EXISTS
        (SELECT *
            FROM SC
            WHERE Sno=Student.Sno AND Cno='1');
/*查询选修了全部课程的学生姓名*/
SELECT Sname
    FROM Student
    WHERE NOT EXISTS
        (SELECT *
            FROM Course
            WHERE NOT EXISTS
                (SELECT *
                    FROM SC
                    WHERE Sno=Student.Sno
                    AND Cno=Course.Cno));
/*查询⾄少选修了学生 201215122 选修的全部课程的学生号码*/
SELECT DISTINCT Sno
    FROM SC SCX
    WHERE NOT EXISTS
    (SELECT *
        FROM SC SCY
        WHERE SCY.Sno=' 201215122 ' AND
           NOT EXISTS
           (SELECT *
                FROM SC SCZ
                WHERE SCZ.Sno=SCX.Sno AND
            SCZ.Cno=SCY.Cno));

集合查询

SELECT 语句的查询结果是元组的集合，所以多个 SELECT 语句的结果可进行集合操作。

集合操作主要包括并操作 UNION、交操作 INTERSECT 和差操作 EXCEPT。

参加集合操作的各查询结果的列数必须相同，对应项的数据类型也必须相同。

并操作 UNION | 交操作 INTERSECT | 差操作 EXCEPT

语句格式：

【[ SELECT 子句( 结尾无分号 ) ] [ UNION [ ALL ] | INTERSECT | EXCEPT ] [ SELECT 子句 ] ;】

UNION：将多个查询结果合并起来，自动去掉重复元组。

UNION ALL：将多个查询结果合并起来时，保留重复元组。

/*查询选修了课程1或者选修了课程2的学生*/
SELECT Sno
    FROM SC
    WHERE Cno='1'
UNION
SELECT Sno
    FROM SC
    WHERE Cno='2';
    
/*查询计算机科学系的学生与年龄不大于19岁的学生的交集*/
SELECT *
    FROM Student
    WHERE Sdept='CS'
INTERSECT
SELECT *
    FROM Student
    WHERE Sage<=19;
    
/*查询计算机科学系的学生与年龄不大于19岁的学生的差集*/
SELECT *
    FROM Student
    WHERE Sdept='CS'
EXCEPT
SELECT *
    FROM Student
    WHERE Sage<=19;

基于派生表的查询

子查询不仅可以出现在 WHERE 子句中，还可以出现在 FROM 子句中，这时子查询生成的临时 派生表 derived table 成为主查询的查询对象。

语句格式：【SELECT [ ALL | DISTINCT ] < 目标列表达式 > [ , < 目标列表达式 > ] ...

FROM < 表名或视图名 > [ , < 表名或视图名 > ] ... , < SELECT 语句 > [ AS ] < 别名 >

[ WHERE < 条件表达式 > ]

[ GROUP BY < 列名1 >

[ HAVING < 条件表达式 > ] ]

[ ORDER BY < 列名2 > [ ASC | DESC ] ] ;】

说明：通过 FROM 子句生成派生表时，AS 关键字可以省略，但必须为派生关系指定一个别名。

/*查询所有选修了1号课程的学生姓名*/
SELECT Sname
    FROM Student,(SELECT Sno FROM SC WHERE Cno='1') AS SC1
    WHERE Student.Sno=SC1.Sno;

SELECT 语句的一般格式

语句格式：【SELECT [ ALL | DISTINCT ] < 目标列表达式 > [ , < 目标列表达式 > ] ...

FROM < 表名或视图名 > [ , < 表名或视图名 > ] ... | ( < SELECT 语句 > ) [ AS ] < 别名 >

[ WHERE < 条件表达式 > ]

[ GROUP BY < 列名1 >

[ HAVING < 条件表达式 > ] ]

[ ORDER BY < 列名2 > [ ASC | DESC ] ] ;】

( * 待复习 )

3.5 数据更新

插入数据

插入元组

语句格式：【INSERT INTO < 表名 > [ ( < 属性列1 > [, < 属性列2 > ] … ) ]

VALUES ( < 常量1 > [, < 常量2 > ] … ) ;】

说明：功能是将新元组插入指定表中。INTO 子句中没有出现的属性列，新元组在这些列上将取空值。

若在 INTO 子句中只指出表名，没有指出属性名：

表示新元组要在表的所有属性列上都指定值，属性列的次序与 CREATE TABLE 中的次序相同。

/*将一个新学生元组（学号：201215128，姓名：陈冬，性别：男，所在系：IS，年龄：18岁）插入到 Student表中*/
INSERT INTO Student(Sno,Sname,Ssex,Sdept,Sage)
        VALUES ('201215128', 陈冬,'男','IS',18);

插入子查询结果

语句格式：【INSERT INTO < 表名 > [ ( < 属性列1 > [, < 属性列2 > ] … ) ]

[ 子查询 ] ;】

/*对每一个系，求学生的平均年龄，并把结果存入数据库*/
CREATE TABLE Dept_age (Sdept CHAR(15), Avg_age SMALLINT);  /*建立新表*/
INSERT INTO Dept_age(Sdept, Avg_age)  /*插入*/
       SELECT Sdept,AVG(Sage)
          FROM Student
          GROUP BY Sdept;

修改数据

语句格式：【UPDATE < 表名 >

SET < 列名 > = < 表达式 > [ , < 列名 > = < 表达式 > ] ...

[ WHERE < 条件 > ] ;】

说明：修改操作⼜称更新操作，其功能是修改指定表中满足 WHERE 子句条件的元组。

SET 子句给出 < 表达式 > 的值用于取代相应的属性列值。如果省略 WHERE 子句，则表示要修改表中的所有元组。

修改某一个元组的值

/*将学生 201215121 的年龄改 22 岁*/
UPDATE Student
    SET Sage=22
    WHERE Sno='201215121';

修改多个元组的值

/*将所有学生的年龄增加 1 岁*/
UPDATE Student
    SET Sage=Sage+1;

带子查询的修改语句

/*将计算机科学系全体学生的成绩置零*/
UPDATE SC
    SET Grade=0
    WHERE Sno IN
        (SELECT Sno
              FROM Student
              WHERE Sdept='CS');

删除数据

语句格式：【DELETE FROM < 表名 >

[ WHERE < 条件 > ] ;】

说明：功能是删除指定表中满足 WHERE 子句条件的元组。

如果省略 WHERE 子句则表示删除表中全部元组，但表的定义仍在字典中。

删除某一个元组的值

/*删除学号为 201215128 的学生记录*/
DELETE FROM Student
       WHERE Sno='201215128';

修改多个元组的值

/*删除所有的学生选课记录*/
DELETE FROM SC;

带子查询的修改语句

/*删除计算机科学系所有学生的选课记录*/
DELETE FROM SC
       WHERE Sno IN
          (SELECT Sno
                FROM Student
                WHERE Sdept='CS');

3.6 空值的处理

空值的存在是因为取值有不确定性，对关系运算带来特殊的问题，所以需要做特殊的处理。

SQL 语言中允许某些元组的某些属性取空值，一般有以下几种情况：

该属性有值，但当前不知道它的具体值。
该属性不应该有值。
由于某种原因不便于填写。

空值的产生

在插入时定义为空值，取空值；

插入语句中没有赋值的属性，其值为空值；

外连接也会产生空值，空值的关系运算也会产生空值。

空值的判断

判断一个属性的值是否为空值，用 IS NULL 或 IS NOT NULL 来表示。

空值的约束条件

属性定义（或者域定义）中有 NOT NULL 约束条件的不能取空值
加了 UNIQUE 限制的属性不能取空值
码属性不能取空值

空值的算术运算、比较运算和逻辑运算

算术运算：空值与另一个值（包括另一个空值）的算术运算的结果为空值；

比较运算：空值与另一个值（包括另一个空值）的比较运算结果为 UNKNOWN；

逻辑运算：扩展成三值逻辑，如下：

3.7 视图

视图是从一个或几个基本表（或视图）导出的表。它与基本表不同，是一个虚表。 数据库中只存放视图的定义，不存放视图对应的数据。

表中的数据发生变化，视图中查询出的数据也就随之改变。

定义视图

建立视图

语句格式：【CREATE VIEW < 视图名 > [ ( < 列名 > [ , < 列名 > ] ... ) ]

AS < 子查询 >

[ WITH CHECK OPTION ] ;】

说明：组成视图的属性列名：全部省略或全部指定。

子查询不允许含有 ORDER BY 子句和 DISTINCT 短语（教材：是否可以含有取决于具体系统的实现）。

RDBMS 执行 CREATE VIEW 语句时只是把视图定义存入当据字并不执行其中的 SELECT 语句。

在对视图查询时，按视图的定义从基本表中将数据查出。

WITH CHECK OPTION：对视图进行 UPDATE、INSERT 和 DELETE 操作时要保证操作后的行满足子查询条件表达式。

如果不满足，则拒绝更新操作。

行列子集视图：若一个视图是从单个基本表导出的，并且只是去掉了基本表的某些行和某些列，但保留了主码。视图可以建立在一个或多个基本表和视图上。

带虚拟列的视图 / 带表达式的视图：定义视图时可以根据应用的需要设置一些派生属性列，这些派生属性由于在基本表中并不实际存在，也称它们为 虚拟列。

分组视图：带有聚集函数和 GROUP BY 子句的查询来定义视图。

/*建立信息系学生的视图，并要求进行修改和插入操作时仍需保证该视图只有信息系的学生,此视图为：行列子集视图*/
CREATE VIEW IS_Student
       AS SELECT Sno,Sname,Sage
              FROM Student
              WHERE Sdept='IS'
              WITH CHECK OPTION;
/*定义一个反映学生出生年份的视图，此视图为：带虚拟列的视图 / 带表达式的视图*/
CREATE VIEW BT_S(Sno,Sname,Sbirth)
       AS SELECT Sno,Sname,2014-Sage FROM Student;
       
/*将学生的学号及平均成绩定义为一个视图，此视图为：分组视图*/
CREATE VIEW S_G(Sno,Gavg)
       AS SELECT Sno,AVG(Grade)
              FROM SC
              GROUP BY Sno;

删除视图

语句格式：【DROP VIEW < 视图名 > [ CASCADE ] ;】

删除基表时，由该基表导出的所有视图定义都必须显式地使用 DROP VIEW 语句删除。

/*删除视图 BT_S*/
DROP VIEW BT_S;

/*级联删除视图 IS_S1*/
DROP VIEW IS IS_S1 CASCADE;

查询视图

视图定义后，用户就可以像对基本表一样对视图进行查询了。

视图消解 view resolution：关系数据库管理系统执行对视图的查询时，⾸先进行有效性检查，检查查询中涉及的表、视图等是否存在。如果存在，则从数据字典中取出视图的定义，把定义中的子查询和用户的查询结合起来，转换成等价的对基本表的查询，然后再执行修正了的查询。

有些情况下，视图消解法不能生成正确查询，目前多数关系数据库系统对行列子集视图的查询均能进行正确转换。

更新视图

说明：更新视图是指通过视图来插入、删除和数据，因为视图不适宜存储数据，因此对视图的更新操作将通过视图消解，转为对实际表的更新操作。

为防止在更新视图时出错，定义视图时要加上 WITH CHECK OPTION 子句。

更新视图的限制：

一些视图是不可更新的，因为对这些视图的更新不能唯一地有意义地转换成对相应基本表的更新。

一般地，行列子集视图是可更新的。除行列子集视图外，有些视图理论上是可更新的，还有些视图是不可更新的。

视图的作用

视图能够简化用户的操作。
视图使用户能以多种⻆度看待同一数据。
视图对重构数据库提供了一定程度的逻辑独立性。
视图能够对机密数据提供安全保护。
适当的利用视图可以更清晰的表达查询。

Note 04 数据库安全性

4.1 数据库安全性概述

数据库的一大特点是数据可以共享，但共享必然带来数据库的安全性问题，因此不能是无条件的共享。

数据库的安全性：指保护数据库以防止不合法使用所造成的数据泄露、更改或破坏。

系统安全保护措施是否有效是数据库系统的主要技术指标之一。

数据库的不安全因素

非授权用户对数据库的恶意存取和破坏

一些黑客和犯罪分子在用户存取数据库时猎取用户名和用户口令，然后假冒合法用户偷取、修改或破坏用户数据。

因此，必须阻止有损数据库安全的非法操作，以保证数据免受未经授权的访问和破坏。

数据库管理系统提供的安全措施主要包括 用户身份鉴别、存取控制和视图 等技术。

数据库中重要或敏感的数据被泄露

黑客和敌对分子千方百计盗窃数据库中的重要数据，一些机密信息可能被暴露。

数据库管理系统提供的主要技术有 强制存取控制、数据加密存储和加密传输 等。

安全要求较高的系统提供 审计日志 分析。对潜在的威胁提前采取措施加以防范。

安全环境的脆弱性

数据库的安全性与计算机系统的安全性紧密联系，主要包括计算机硬件、操作系统、⽹络系统等的安全性。

在计算机安全方面需要建立一套可信 Trusted 计算机系统的概念和标准。

安全标准简介

安全标准的发展历史

TCSEC / TDI 将系统划分为 4 组division，共 7 个等级。（用于设计前？）

D 级：最低级别。实现操作系统基本功能，无安全性保障。[ DOS ]

C1 级：能够实现对用户和数据的分离，进行自主存取控制 DAC，给不同用户分配不同权限。

C2 级：安全产品的最低档，细化 DAC，以个⼈身份注册负责，并实施审计和资源隔离。[ Windows2000, Oracle7 ]

B1 级：标记安全保护。对标记主客体实施强制存取控制 MAC，给不同文件加密级标签。 [ SQL Server ]

B2 级：结构化保护。建立形式化的安全策略模型。对所有主客体实施 DAC 和 MAC。

B3 级：安全域。访问监控器负责所有访问请求的授权决定，审计更强，提供系统恢复过程（数据库备份）。

A 级：验证设计，给出系统的形式化设计说明和验证（确保每个部分的功能和行为都是明确的和可验证的）。

CC （用于设计后验证？）

4.2 数据库安全性控制

概述

非法使用数据库的情况

编写合法程序绕过数据库管理系统及其授权机制。
直接或编写应用程序执行非授权操作。
通过多次合法查询数据库，从中推导出一些保密数据。

计算机系统的安全模型：计算机系统中安全措施是一级一级层层设置的。

数据库管理系统安全性控制模型

数据库管理系统对提出 SQL 访问请求的数据库用户进行身份鉴别，防止不可信用户使用系统；
在 SQL 处理层进行自主存取控制和强制存取控制，进一步还可以进行推理控制。
为监控恶意访问，可根据具体安全需求配置审计规则，对用户访问行为和系统关键操作进行审计。
通过设置简单入侵检测规则，对异常用户行为进行检测和处理。
在数据存储层，数据库管理系统不仅存放用户数据，还存储安全数据，提供存储加密功能等。

用户身份鉴别

用户身份鉴别是数据库管理系统提供的最外层安全保护措施。每个用户在系统中都有个用户标识。

每个用户标识由 用户名user name 和唯一 用户标识号UID 两部分组成。

每次用户要求进入系统时，由系统进行核对，通过鉴定后才提供使用数据库管理系统的权限。

用户身份鉴别的方法

静态口令鉴别：静态口令一般由用户自己设定，这些口令是静态不变的。

动态口令鉴别，口令是动态变化的，每次鉴别时均需使用动态产生的新口令登录数据库管理系统，一次一密。

生物特征鉴别：通过生物特征进行认证的技术，生物特征如指纹、虹膜和掌纹等。

智能卡鉴别：智能卡是一种不可复制的硬件，内置集成电路的芯⽚，具有硬件加密功能。

存取控制

存取控制机制组成

存取控制机制主要包括定义用户权限和合法权限检查两部分。

定义用户权限，并将用户权限登记到数据字典中

DBMS 提供适当的语言来定义用户权限，存放在数据字典中，称做安全规则或授权规则。

合法权限检查

用户发出存取数据库操作请求。DBMS 查找数据字典，进行合法权限检查。

常用存取控制方法

自主存取控制 DAC, Discretionary Access Control

用户对于不同的数据库对象有不同的存取权限，不同的用户对同一对象也有不同的权限，用户可将其拥有的存取权限转授给其他用户。

自主存取控制非常灵活。

强制存取控制 MAC, Mandatory Access Control

每一个数据库对象被标以一定的密级，每一个用户也被授予某一个级别的许可证。

对于任意一个对象，只有具有合法许可证的用户才可以存取。

强制存取控制因此相对比较严格。

自主存取控制方法

用户权限是由两个要素组成的：数据库对象和操作类型。定义存取权限称为授权 authorization。

RDBMS 存取控制的对象不仅有数据本身还有数据库模式，关系数据库系统中存取控制对象如下：

在给用户授予列 INSERT 权限时，需要包含主码的 INSERT 权限，否则用户的插入动作会因为主码为空而被拒绝。

授权：授予与收回

SQL 中使用 GRANT 和 REVOKE 语句向用户授予或收回对数据的操作权限。

GRANT 语句向用户授予权限，REVOKE 语句收回己经授予用户的权限。

GRANT：权限授予

语句格式：【GRANT < 权限 > [ , < 权限 > ] ...

ON < 对象类型 > < 对象名 > [ , < 对象类型 > < 对象名 >] ...

TO < 用户 > [ , < 用户 > ] ...

[ WITH GRANT OPTION ] ;】

说明：接受权限的用户可以是一个或多个具体用户，也可以是 PUBLIC，即全体用户。

WITH GRANT OPTION：获得某种权限的用户还可以把这种权限再授予其他的用户。

SQL 标准不允许循环授权，即被授权者不能把权限再授回给授权者或其祖先。

/*把查询 Student 表的权限授给所有用户*/
GRANT SELECT ON TABLE Student TO PUBLIC;

/*把对 Student 表和 Course 表的全部操作权限授予用户 U2 和 U3 */
GRANT ALL PRIVILEGES ON TABLE Student, Course TO U2,U3;

/*把查询 Student 表和修改学生学号的权限受给用户 U4，并允许将此权限再授予其他用户。*/
GRANT UPDATE(Sno),SELECT
      ON TABLE Student TO U4
      WITH GRANT OPTION;

REVOKE：权限回收

语句格式：【ROVOKE < 权限 > [ , < 权限 > ] ...

ON < 对象类型 > < 对象名 > [ , < 对象类型 > < 对象名 >] ...

FROM < 用户 > [ , < 用户 > ] ...

[ CASCADE | RESTRICT ] ;】

说明：数据库管理员或其他授权者可以使用 REVOKE 语句将授予的权限收回。

/*把用户 U4 修改学生学号的权限收回*/
REVOKE UPDATE(Sno) ON TABLE Student FROM U4 CASCADE;

创建数据库模式的权限对创建数据库模式一类的数据库对象的授权由数据库管理员在创建用户时实现。

语句格式：【CREATE USER < 用户名 > [ WITH ] [ DBA | RESOURCE | CONNECT ] ;】

说明：新创建的数据库用户有三种权限：CONNECT、RESOURCE 和 DBA，默认 CONNECT。权限如下：

数据库角色

数据库角色是被命名的一组与数据库操作相关的权限，角色是权限的集合。

可以为一组具有相同权限的用户创建一个角色，简化授权。

角色的创建

语句格式：【CREATE ROLE < 角色名 > ;】

/*创建一个角色 R1*/
CREATE ROLE R1:

给角色授权

语句格式：【GRANT < 权限 > [ , < 权限 > ] ...

ON < 对象类型 > < 对象名 > [ , < 对象类型 > < 对象名 >] ...

TO < 角色 > [ , < 角色 > ] ... ;】

/*授予角色 RI Student 表的 SELECT、UPDATE、 INSERT 权限*/
GRANT SELECT,UPDATE,INSERT
      ON TABLE Student 
      TO R1;

将一个角色授予其他的角色或用户

语句格式：【GRANT < 角色1 > [ , < 角色2 > ] ...

TO < 角色3 > [ , < 用户1 > ] ...

[ WITH ADMIN OPTION ] ;】

说明：WITH ADMIN OPTION：获得某种权限的角色或用户还可以把这种权限再授予其他的角色或用户。

/*将角色 R1 授予WANG、ZHANG、ZHAO，使他们具有角色 R1 所包含的全部权限，且可授权子角色及用户*/
GRANT R1 TO WANG、ZHANG、ZHAO WITH ADMIN OPTION；

角色权限的收回

语句格式：【ROVOKE < 权限 > [ , < 权限 > ] ...

ON < 对象类型 > < 对象名 > [ , < 对象类型 > < 对象名 >] ...

FROM < 角色 > [ , < 角色 > ] ... ; 】

/*收回 R1 在 Student 表的 SELECT 权限*/
REVOKE SELECT ON TABLE Student FROM R1;

角色回收 【( * 待补充 ) 原书及课程并无说明，仅有一例回收角色，暂不清楚是否区分 CASCADE 和 RESTRICT。】

语句格式：【REVOKE < 角色1 > [ , < 角色2 > ] ...

FROM < 角色3 > [ , < 用户1 > ] ...

[ CASCADE | RESTRICT ] ;】

REVOKE R1 FROM WANG;

强制存取控制方法

自主存取控制可能存在数据 “无意泄露” 的风险

原因：DAC 仅仅通过对数据的存取权限来进行安全控制而数据本身并无安全性标记。

解决：对系统控制下的所有主客体实施强制存取控制策略 MAC。

强制存取控制 MAC

作用：保证更高程度的安全性、用户不能直接感知或进行控制。

适用于对数据有严格而固定密级分类的部门，如军事部门，政府部门。

在强制存取控制中实体分类

主体：系统中的活动实体，既包括数据库管理系统所管理的实际用户，也包括代表用户的各进程。

客体：系统中的被动实体，是受主体操纵的，包括文件、基本表、索引、视图等。

敏感度标记label

对于主体和客体，DBMS 为它们每个实例（值）指派一个敏感度标记。敏感度标记被分成若干级别。

如绝密 TS, Top Secret、机密 S, Secret、可信 C, Confidential、公开 P, Public 等。

密级的次序是 TS >= S >= C >= P。

主体的敏感度标记称为许可证级别clearance level，客体的敏感度标记称为密级 classification level。

强制存取控制机制就是通过对比主体的敏感度标记和客体的敏感度标记，最终确定主体是否能够存取客体。

强制存取控制规则

仅当主体的许可证级别大于或等于客体的密级时，该主体才能读取相应的客体。

仅当主体的许可证级别⼩于或等于客体的密级时，该主体才能写相应的客体。

注：如果高级主体写了低级客体，则低级主体可访问高级主体写的数据，造成数据泄露。

如果低级主体写高级客体，看似荒谬但低级主体无法访问自己写的客体数据，不会造成客体密级降低。

MAC 是对数据本身进行密级标记，标记与数据不可分，只有符合密级标记要求的用户才可以操纵数据。

实现 MAC 要⾸先实现 DAC，因为较高安全性级别提供的安全保护要包含较低级别的所有保护。

MAC 与 DAC 共同构成数据库管理系统的安全机制。

4.3 视图机制

视图对数据库安全的作用：

把要保密的数据对无权存取这些数据的用户隐藏起来，对数据提供一定程度的安全保护。
间接地实现支持存取谓词的用户权限定义。

/*建立计算机系学生的视图，把对该视图的 SELECT 权限授予王平，把该视图上的所有操作权限授予张明。*/
CREATE VIEW CS_Student
       AS SELECT *
              FROM Student
              WHERE Sdept=‘CS‘；            /*先建立视图 CS_ _Student*/
              
GRANT SELECT ON CS_Student TO 王平；         /*王平⽼师只能检索计算机系学生的信息*/

GRANT ALL PRIVILEGES ON CS_Student TO 张明； /*系主任具有检索和增删改计算机系学生信息的所有权限*/

4.4 审计

审计

审计日志 Audit Log：启用一个专用的审计日志户对数据库的所有操作记录在上面。

审计员：利用审计日志监控数据库中的各种行为，找出非法存取数据的⼈、时间和内容。

C2 以上安全级别的 DBMS 必须具有审计功能。

审计功能的可选性

审计很费时间和空间。

DBA 可以根据应用对安全性的要求，灵活地打开或关闭审计功能。主要用于安全性要求较高的部门。

审计事件

服务器事件：审计数据库服务器发生的事件，包含数据库服务器的启动、停止、数据库服务器配置文件的重新加载。
系统权限：对系统拥有的结构或模式对象进行操作的审计，要求该操作的权限是通过系统权限获得的。
语句事件：对 SQL 语句，如DDL、DML、DQL Data Query Language 数据查询语言及 DCL 语句的审计。
模式对象事件：对特定模式对象上进行的SELECT 或 DML 操作的审计。模式对象

审计功能

基本功能：提供多种审计查阅方式：基本的、可选的、有限的等。
提供多套审计规则：审计规则一般在数据库初始化时设定，以方便审计员管理。
提供审计分析和报表功能
审计日志管理功能
1. 为防止审计员误删审计记录，审计日志必须先转储后删除；
2. 对转储的审计记录文件提供完整性和保密性保护；
3. 只允许审计员查阅和转储审计记录，不允许任何用户新增和修改审计记录等。
系统提供查询审计设置及审计记录信息的专门视图

审计分类

用户级审计

任何用户可设置的审计，主要是用户针对自己创建的数据库表或视图进行审计。

系统级审计

只能由数据库管理员设置，用以监测成功或失败的登录要求、监测授权和收回操作及其他数据库级权限下的操作。

AUDIT 语句和 NOAUDIT 语句

AUDIT 语句用来设置审计功能

语句格式：【AUDIT < 权限1 > [ , < 权限2 >]...

ON < 对象类型 > < 对象名 > [ , < 对象类型 > < 对象名 >] ...

[ BY [ SESSION | ACCESS ] ]

[ WHENEVER [ SUCCESSFUL | NOT SUCCESSFUL | ANY ] ] ;】

BY 子句：指定审计粒度， SESSION 表示每个会话记录一次，ACCESS 表示每次访问都记录。默认 SESSION。

WHENEVER 子句：精准地监控和分析数据库活动，SUCCESSFUL 仅审计成功执行的操作，NOT SUCCESSFUL 仅审计执行失败的操作， ANY 同时审计成功和失败的操作。默认 ANY。

/*对修改 SC 表结构或修改 SC 表数据的操作进行审计*/
AUDIT ALTER, UPDATE ON SC:

NOAUDIT 语句则取消审计功能。

语句格式：【NOAUDIT < 权限1 > [ , < 权限2 >]...

ON < 对象类型 > < 对象名 > [ , < 对象类型 > < 对象名 >] ... ;】

/*取消对 SC 表的一切审计*/
NOAUDIT ALTER, UPDATE ON SC;

4.5 数据加密

数据加密是防止数据库中数据在存储和传输中失密的有效手段。

基本思想：根据一定的算法将原始数据 / 明文plain text变换为不可直接识别的格式 / 密文Cipher text。

数据加密包括存储加密和传输加密。

存储加密

一般提供透明和非透明两种存储加密方式。

透明存储加密是内核级加密保护方式，对用户完全透明；非透明存储加密则是通过多个加密函数实现的。

传输加密

常用的传输加密方式如链路加密和端到端加密。

链路加密 

对传输数据在链路层进行加密，它的传输信息由报头和报文两部分组成，前者是路由选择信息，而后者是传送的数据信息。这种方式对报文和报头均加密。

端到端加密

对传输数据在发送端加密，接收端解密。它只加密报文，不加密报头。

所需密码设备数量相对较少，容易被非法监听者发现并从中获取敏感信息。

基于基于安全套接层协议SSL, Security Socket Layer 的数据库管理系统可信传输方案：

4.6 其他安全性保护

推理控制 inference control

处理强制存取控制未解决的问题，避免用户利用能够访问的数据推知更高密级的数据。

常用方法：基于函数依赖的推理控制、基于敏感关联的推理控制。

隐蔽信道 covert channal

处理强制存取控制未解决的问题。

数据隐私保护

描述个⼈控制其不愿他⼈知道或他⼈不便知道的个⼈数据的能⼒。

主要用于数据收集存储处理和数据发布等各个阶段。

Note 05 数据库完整性

5.0 数据库完整性简介

数据库的完整性

数据库的 完整性 integrity 是指数据的 正确性 correctness 和相容性 compat- ability。

正确性：指数据是符合现实世界语义、反映当前实际状况的；

相容性：指数据库同一对象在不同关系表中的数据是符合逻辑的。

完整性与安全性的区别

数据的完整性：防止数据库中存在不符合语义的数据，也就是防止数据库中存在不正确的数据。

防范对象：不合语义的、不正确的数据。

数据的安全性：保护数据库防止恶意的破坏和非法的存取。

防范对象：非法用户和非法操作。

数据库在完整性方面应具备的功能

提供定义完整性约束条件的机制

完整性约束条件也称为完整性规则，是数据库中的数据必须满足的语义约束条件。

SQL 标准使用了一系列概念来描述完整性，包括关系模型的实体完整性、参照完整性和用户定义完整性。

提供完整性检查的方法

数据库管理系统中检查数据是否满足完整性约束条件的机制称为完整性检查。

一般在 INSERT、UPDATE、DELETE 语句执行后开始检查，也可以在事务提交时检查。

进行违约处理

数据库管理系统若发现用户的操作违背了完整性约束条件，就采取拒绝 NO ACTION 执行该操作或级连 CASCADE 执行其他操作或 设空值 等方式保证完整性。

5.1 实体完整性

实体完整性定义

关系模型的实体完整性在 CREATE TABLE 中用 PRIMARY KEY 定义。

对单属性构成的码有两种说明方法，一种是定义为列级约束条件，另一种是定义为表级约束条件。

对多个属性构成的码只有一种说明方法，即定义为表级约束条件。

/*单属性构成的码：将 Student 表中的 Sno 属性定义为码*/
CREATE TABLE Student
      (Sno CHAR(9) PRIMARY KEY,            /*在列级定义主码*/
       Sname CHAR(20) NOT NULL,
       Ssex CHAR(2),
       Sage SMALLINT,
       Sdept CHAR(20)
      );
CREATE TABLE Student
       (Sno CHAR(9),
       Sname CHAR(20) NOT NULL,
       Ssex CHAR(2),
       Sage SMALLINT,
       Sdept CHAR(20),
       PRIMARY KEY(Sno)                    /*在表级定义主码*/
      );
/*多属性构成的码：将 SC 表中的 Sno、Cno 属性组定义为码*/
CREATE TABLE SC
      (Sno CHAR(9) NOT NULL,
       Cno CHAR(4) NOT NULL,
       Grade SMALLINT,
       PRIMARY KEY (Sno,Cno)               /*只能在表级定义主码*/
      );

实体完整性检查和违约处理

完整性检查的内容

关系数据库管理系统按照实体完整性规则自动进行检查。检查内容主要包括：

检查主码值是否唯一，如果不唯一则拒绝插入或修改。
检查主码的各个属性是否为空，只要有一个为空就拒绝插入或修改。

检查主码值方法

检查记录中主码值是否唯一的一种方法是进行 全表扫描：

依次判断表中每一条记录的主码值与将插入记录的主码值（或者修改的新主码值）是否相同。

全表扫描十分耗时。

为避免对基本表进行全表扫描，RDBMS 核心一般都在主码上自动建立一个索引。如 B+ 树索引。

5.2 参照完整性

参照完整性定义

关系模型的参照完整性在 CREATE TABLE 中用 FOREIGN KEY 短语定义哪些列为外码，用 REFERENCES 短语指明这些外码参照哪些表的主码。

/*定义 SC 中的参照完整性*/
CREATE TABLE SC
      (Sno CHAR(9) NOT NULL，
       Cno CHAR(4) NOT NULL，
       Grade SMALLINT，
       PRIMARY KEY (Sno， Cno)，                       /*在表级定义实体完整性*/
       FOREIGN KEY (Sno) REFERENCES Student(Sno)，     /*在表级定义参照完整性*/
       FOREIGN KEY (Cno) REFERENCES Course(Cno)        /*在表级定义参照完整性*/
      )；

参照完整性检查和违约处理

参照完整性将两个表中的相应元组联系起来了。

对被参照表和参照表进行增、删、改操作时有可能破坏参照完整性，此时必须进行检查以保证这两个表的相容性。

当发生以上 4 种可能破坏参照完整性的情况时，系统可以采用以下 3 种策略加以处理。

拒绝 `NO ACTION`

不允许该操作执行。该策略一般设置默认策略。

级连 `CASCADE`

当删除或修改被参照表的一个元组导致与参照表的不一致时，删除或修改参照表中的所有导致不一致的元组。

设置为空值

当删除或修改被参照表的一个元组时造成了不一致，则将参照表中的所有造成不一致的元组对应属性设置为空值。

/*显式说明参照完整性的违约处理示例*/
CREATE TABLE SC
    (Sno CHAR(9)，
     Cno CHAR(4)，
     Grade SMALLINT，
     PRIMARY KEY (Sno，Cno)，             /*在表级定义实体完整性，Sno、Cno 都不能取空值*/ 
     FOREIGN KEY (Sno) REFERENCES Student(Sno)   /*在表级定义参照完整性*/
          ON DELETE CASCADE           /*当删除 Student 表中的元组时，级联删除SC表中相应的元组*/
          ON UPDATE CASCADE,          /*当更新 Student 表中的 sno 时，级联更新SC表中相应的元组*/
     FOREIGN KEY (Cno) REFERENCES Course(Cno)    /*在表级定义参照完整性*/ 
          ON DELETE NO ACTION        /*当删除 Course 表中的元组造成与SC表不一致时，拒绝删除*/
          ON UPDATE CASCADE          /*当更新 Course 表中的cno 时，级联更新SC 表中相应的元组*/
)；

5.3 用户定义的完整性

用户定义的完整性就是针对某一具体应用的数据必须满足的语义要求。

目前的关系数据库管理系统都提供了定义和检验这类完整性的机制，不必由应用程序承担这一功能。

属性上的约束条件

属性上约束条件的定义

在 CREATE TABLE 中定义属性的同时，可以根据应用要求定义属性上的约束条件，即属性值限制，包括：

列值非空： NOT NULL
列值唯一： UNIQUE
检查列值是否满足一个条件表达式： CHECK 短语

/*建⽴部⻔表 DEPT，要求部⻔名称 Dname 列取值唯一，城市只允许在北京或上海，部⻔编号 Deptno 列为主码*/
CREATE TABLE DEPT
      (Deptno NUMERIC(2),
       Dname CHAR(9) UNIQUE NOT NULL,        /*要求 Dname 列值唯一,且不能取空值*/
       Location CHAR(10) CHECK(Location IN ('Beijing','Shanghai')), /*城市只允许在北京或上海*/
       PRIMARY KEY (Deptno) 
      ):

属性上约束条件的检查和违约处理

当往表中插入元组或修改属性的值时，RDBMS 将检查属性上的约束条件是否被满足，不满足则操作被拒绝执行。

元组上的约束条件

元组上约束条件的定义

在 CREATE TABLE 时可以用 CHECK 短语定义元组上的约束条件，即元组级的限制。

元组级的限制可以设置不同属性之间的取值的相互约束条件。

/*当学生的性别是男时，其名字不能以 Ms.打头*/
CREATE TABLE Student
    (Sno CHAR(9),
     Sname CHAR(8) NOT NULL,
     Ssex CHAR(2),
     Sage SMALLINT,
     Sdept CHAR(20),
     PRIMARY KEY (Sno),
    CHECK (Ssex='½' OR Sname NOT LIKE 'Ms.%') /*定义了元组中 Sname和 Ssex两个属性值之间的约東条件
*/
    );

元组上约束条件的检查和违约处理

当往表中插入元组或修改属性的值时，RDBMS 将检查属性上的约束条件是否被满足，不满足则操作被拒绝执行。

5.4 完整性约束命名子句

完整性约束命名子句

语句格式：【CONSTRAINT < 完整性约束条件名 > < 完整性约束条件 >】

说明：< 完整性约束条件 > 包括 NOT NULL、UNIQUE、PRIMARY KEY、FOREIGN KEY、 CHECK 短语等。

/*建立学生登记表 Student，要求学号在90000～99999之间，姓名不能取空值，年龄⼩于30，性别只能是“男”或“⼥”*/
CREATE TABLE Student
      (Sno NUMERIC(6)
          CONSTRAINT CI CHECK (Sno BETWEEN 90000 AND 99999), /*C1 列级约束*/
       Sname CHAR(20)
          CONSTRAINT C2 NOT NULL,                            /*C2 列级约束*/
       Sage NUMERIC(3)
          CONSTRAINT C3 CHECK (Sage < 30),                   /*C3 列级约束*/
       Ssex CHAR(2)
          CONSTRAINT C4 CHECK (Ssex IN ('男'，'⼥')),         /*C4 列级约束*/
       CONSTRAINT StudentKey PRIMARY KEY(Sno)      /*名为StudentKey的主码约束：Sno设为主码*/
       );

修改表中的完整性限制

可以使用 ALTER TABLE 语句修改表中的完整性限制。

语句格式：

【ALTER TABLE < 表名 > ADD CONSTRAINT < 完整性约束名 > < 完整性约束条件 > ;】

【ALTER TABLE < 表名 > DROP CONSTRAINT < 完整性约束名 > [ CASCADE | RESTRICT ] ] ;】

说明：约束条件的修改通过可以先删除原来的约束条件，再增加新的约束条件完成。

/*修改表 Student 中的约束条件，要求学号改为在900000~999999之间， 年龄由⼩于30改为⼩于40*/
ALTER TABLE Student 
      DROP CONSTRAINT C1;
ALTER TABLE Student 
      ADD CONSTRAINT C1 CHECK (Sno BETWEEN 900000 AND 999999):
ALTER TABLE Student
      DROP CONSTRAINT C3;
ALTER TABLE Student
      ADD CONSTRAINT C3 CHECK (Sage < 40);

5.5 域中的完整性限制

域是一组具有相同数据类型的值的集合，即属性的取值范围。

SQL 可以用 CREATE DOMAIN 语句建立一个域以及域应该满足的完整性约束条件，然后用域定义属性。

语句格式：

【CREATE DOMAIN < 域名 > < 数据类型 > < 完整性约束条件 > ;】

【ALTER DOMAIN < 域名 > ADD CONSTRAINT < 完整性约束名 > < 完整性约束条件 > ;】

【ALTER DOMAIN < 域名 > DROP CONSTRAINT < 完整性约束名 > [ CASCADE | RESTRICT ] ] ;】

/*把性别的取值范围由（男，⼥）改为（1，0）*/

/*建立一个性别域，并声明性别域的取值范围*/
CREATE DOMAIN GenderDomain CHAR(2) 
       CHECK (VALUE IN ('男','⼥'));
       /*对 Ssex 的说明可以改写为 ·Ssex GenderDomain· */
       
/*建立一个性别域 GenderDomain，并对其中的限制命名*/
CREATE DOMAIN GenderDomain CHAR(2) 
       CONSTRAINT GD CHECK (VALUE IN ('男','⼥'));
/*删除域 GenderDomain 的限制条件GD*/
ALTER DOMAIN GenderDomain 
      DROP CONSTRAINT GD;
/*在域 GenderDomain 上增加性别的限制条件 GDD*/
ALTER DOMAIN GenderDomain
      ADD CONSTRAINT GDD 
          CHECK (VALUE IN ('1','0'));

5.6 断言

在 SQL 中通过 声明性断言 declarative assertions 来指定更具一般性的约束。

可以定义涉及多个表或聚集操作的比较复杂的完整性约束。断言创建以后，任何对断言中所涉及关系的操作都会触发关系数据库管理系统对断言的检查，任何使断言不为真值的操作都会被拒绝执行。

创建断言的语句格式

语句格式：【CREATE ASSERTION < 断言名 > < CHECK 子句 > ;】

/*限制数据库课程最多60名学⽣选修*/
CREATE ASSERTION ASSE_SC_DB_NUM
       CHECK(60 >= (SELECT count(*)
                            FROM Course,SC
                            WHERE SC.CNO=COURSE.CNO AND
                                  COURSE.CNAME = '数据库')    
            );

删除断言的语句格式

语句格式：【 CREATE ASSERTION < 断言名 > < CHECK 子句 > ; 】

5.7 触发器

触发器 trigger：用户定义在关系表上的一类由事件驱动的特殊过程。

触发器保存在数据库服务器中。
任何用户对表的增、删、改操作均由服务器自动激活相应的触发器。
触发器可以实施更为复杂的检查和操作，具有更精细和更强大的数据控制能⼒。

定义触发器

触发器⼜叫做事件—条件—动作 event-condition-action 规则。

语句格式：

【CREATE TRIGGER < 触发器名 >

{ BEFORE | AFTER } < 触发事件 > ON < 表名 >

REFERENCING NEW | OLD ROW AS < 变量 >

FOR EACH { ROW | STATEMENT }

[ WHEN < 触发条件 > ] < 触发动作体 > ;】

说明：表的拥有者才可以在表上创建触发器。

语法部分	说明
<font style="color:#ED740C;">触发器名</font>	可以包含模式名，也可以不包含模式名。
	同一模式下，触发器名必须是唯一的，并且触发器和表名必须在同一模式下。
<font style="color:#ED740C;">表名</font>	触发器只能定义在基本表上，不能定义在视图上。该表也称为触发器的目标表。
<font style="color:#ED740C;">触发事件</font>	触发事件可以是 `INSERT`、`DELETE`或 `UPDATE`，也可以是这几个事件的组合。
	【`UPDATE OF`触发列，...】：进一步指明修改哪些列时激活触发器。
	触发时机：<font style="color:#ED740C;">AFTER</font>触发事件操作执行之后激活；<font style="color:#ED740C;">BEFORE</font>触发事件操作执行之前激活。
<font style="color:#ED740C;">触发器类型</font>	可分为行级触发器 <font style="color:#ED740C;">FOR EACH ROW</font>和语句级触发器 <font style="color:#ED740C;">FOR EACH STATEMENT</font>。
	行级触发器：每当影响到表中的一行数据时，触发器就会被触发一次。
	语句级触发器：执行一个数据库操作语句时，触发器才会被触发一次。
<font style="color:#ED740C;">触发条件</font>	`WHEN`<br/> 触发条件：只有当触发条件为真时触发动作体才执行，否则触发动作体不执行。
	如果省略，则触发动作体在触发器激活后立即执行。
<font style="color:#ED740C;">触发动作体</font>	触发动作体既可以是一个匿名 PL/SQL 过程块，也可以是对已创建存储过程的调用。
	行级触发器：可以在过程中使用 <font style="color:#ED740C;">NEW</font>和 <font style="color:#ED740C;">OLD</font>引用事件之后的新值和事件之前的旧值。
	语句级触发器：不能在触发动作体中使用 <font style="color:#ED740C;">NEW</font>和 <font style="color:#ED740C;">OLD</font>进行引用，无法区分新旧。
	如果触发动作体执行失败，激活触发器的事件就会终止执行。
	触发器的目标表或触发器可能影响的其他对象不发生任何变化。

/*当对表 SC 的 Grade 属性进⾏修改时，若分数增加了 10% ，则将此次操作记录到另一个表
    SC_U(Sno,Cno,Oldgrade,Newgrade)中*/
CREATE TRIGGER SC_T                                 /*SC_T是触发器的名字*/
       AFTER UPDATE OF Grade ON SC                  /*当对SC的Grade属性更新完后触发下面的规则*/
       REFERENCING
            OLD ROW AS OldTuple，
            NEW ROW AS NewTuple
       FOR EACH ROW                                  /*⾏级触发器，即每执⾏一次更新，执⾏一次下述操作*/ 
       WHEN (NewTuple.Grade >= 1.1 * OldTuple.Grade) /*触发条件，只有该条件为真时才执⾏下面的操作*/
       INSERT INTO SC_U (Sno,Cno,OldGrade,NewGrade)  /*存储过程*/
            VALUES(OldTuple.Sno,OldTuple.Cno，OldTuple.Grade,NewTuple.Grade);
            
/*定义一个 BEFORE ⾏级触发器，为教师表 Teacher 定义完整性规则
      “教授的工资不得低于4000元，如果低于4000元，⾃动改为4000元”*/
CREATE TRIGGER Insert_Or_Update_Sal                 /*对教师表插⼊或更新时激活触发器*/ 
       BEFORE INSERT OR UPDATE ON Teacher           /*BEFORE 触发事件*/
       REFERENCING 
            NEW ROW AS newTuple
       FOR EACH ROW                                 /*⾏级触发器*/
BEGIN                                        
/*定义触发动作体，这是一个 PL/SQL 过程块*/
IF (newtuple.Job='教授') AND (newtuple.Sal < 4000) /*⾏级触发器，可在过程体中使用新值*/
THEN newtuple.Sal:=4000；      
/* ":=" 是赋值操作符，将右边的值或结果赋给左边变量。*/
END IF；
END；                                        
/*触发动作体结束*/

激活触发器

触发器的执行是由触发事件激活，并由数据库服务器自动执行的。

一个数据表上可能定义了多个触发器，如多个 BEFORE 触发器、多个 AFTER 触发器等，同一个表上的多个触发器激活时遵循如下的执行顺序：

执行该表上的 BEFORE 触发器。
激活触发器的 SQL 语句。
执行该表上的 AFTER 触发器。

对于同一个表上的多个 BEFORE / AFTER 触发器，遵循 “谁先创建谁先执行” 的原则（有些遵循字⺟顺序）。

删除触发器

语句格式：【DROP TRIGGER < 触发器名 > ON < 表名 > ;】

说明：触发器必须是一个已经创建的触发器，并且只能由具有相应权限的用户删除。

触发器功能强大，但使用时要慎重，每次访问一个表时都可能触发一个触发器，这样会影响系统的性能。

···

Twikoo 自托管部署：本地 MongoDB 与 Nginx 反向代理

Tue, 05 May 2026 00:00:00 GMT

一.必备环境下载

1.安装 Node.js 环境

更新系统包索引

sudo apt update

2.添加 NodeSource 仓库

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -

Ubuntu 默认源没有新版本 Node
NodeSource 提供官方维护的高版本 Node

3.安装 Node.js

sudo apt install -y nodejs

4.验证安装

node -v
npm -v

回显版本号即成功安装

2.npm 配置

设置国内镜像，因为默认 npm 源在国外

npm config set registry https://registry.npmmirror.com

3.MongoDB 数据库安装

安装 MongoDB

sudo apt update
sudo apt install -y mongodb-org

2.启动 MongDB

sudo systemctl start mongod
sudo systemctl enable mongod

3.进入 MongoDB Shell

mongosh

创建数据库和用户

use twikoo

db.createUser({
  user: "twikoo",
  pwd: "你的密码",
  roles: [
    { role: "readWrite", db: "twikoo" }
  ]
})

5.验证登录

mongosh -u twikoo -p --authenticationDatabase twikoo

根据提示内容输入密码即可

二、部署 tkserver（Twikoo 后端）

1.全局安装 tkserver（此处需要前面的 Node.js）

sudo npm install -g tkserver

2.启动 tkserver

MONGODB_URI="mongodb://twikoo:密码@127.0.0.1:27017/twikoo" HOST=127.0.0.1 PORT=8080 tkserver

MONGODB_URI：数据库连接字符串
HOST=127.0.0.1：只允许本机访问（安全）
PORT=8080：服务端口

名称	描述	默认值
`MONGODB_URI`	MongoDB 数据库连接字符串，不传则使用 lokijs	`null`
`MONGO_URL`	MongoDB 数据库连接字符串，不传则使用 lokijs	`null`
`TWIKOO_DATA`	lokijs 数据库存储路径	`./data`
`TWIKOO_PORT`	端口号	`8080`
`TWIKOO_THROTTLE`	IP 请求限流，当同一 IP 短时间内请求次数超过阈值将对该 IP 返回错误	`250`
`TWIKOO_LOCALHOST_ONLY`	为`true`时只监听本地请求，使得 nginx 等服务器反代之后不暴露原始端口	`null`
`TWIKOO_LOG_LEVEL`	日志级别，支持 `verbose`/ `info`/ `warn`/ `error`	`info`
`TWIKOO_IP_HEADERS`	在一些特殊情况下使用，如使用了 `CloudFlare CDN`它会将请求 IP 写到请求头的 `cf-connecting-ip`字段上，为了能够正确的获取请求 IP 你可以写成 `["headers.cf-connecting-ip"]`	`[]`

3.后台运行（即24 小时不间断运行）

方法一：nohup（官方推荐）

nohup env MONGODB_URI="mongodb://twikoo:密码@127.0.0.1:27017/twikoo" HOST=127.0.0.1 PORT=8080 tkserver > /var/log/tkserver.log 2>&1 &

方法二：systemctl（规范）

创建服务

sudo nano /etc/systemd/system/tkserver.service

内容：

[Unit]
Description=Twikoo Service
After=network.target

[Service]
Type=simple
Environment="MONGODB_URI=mongodb://twikoo:密码@127.0.0.1:27017/twikoo"
Environment="HOST=127.0.0.1"
Environment="PORT=8080"
ExecStart=/usr/bin/node /usr/lib/node_modules/tkserver/server.js
Restart=always
User=root

[Install]
WantedBy=multi-user.target

启动：

sudo systemctl daemon-reexec
sudo systemctl daemon-reload
sudo systemctl start tkserver
sudo systemctl enable tkserver

三、安装 Nginx

如果没有配置 Nginx，那么：

sudo apt install -y nginx

2.配置站点

sudo nano /etc/nginx/sites-available/twikoo

配置（以我的站点为例）：

注意：要将子域名申请 ssl 证书，如果你是阿里云用户可以申请个人测试证书，这样才能通过 https 访问，避免中间人攻击

如图：

# HTTP 强制跳 HTTPS
server {
    listen 80;
    server_name twikoo.sirens007.cn;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name twikoo.sirens007.cn;

    ssl_certificate /粘贴你的证书路径.crt;
    ssl_certificate_key /粘贴你的私钥路径.key;

    # TLS 安全增强
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    # 关键：允许评论内容上传
    client_max_body_size 10m;

    location / {
        proxy_pass http://127.0.0.1:8080;

# 基础代理头
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket 支持（Twikoo兼容）
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        # 超时优化
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }
}

4.启用配置：

sudo ln -s /etc/nginx/sites-available/twikoo /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

反向代理的目的是为了避免直接暴露 8080，并且浏览器会拦截

检验部署成功与否

如果运行出现什么问题，随时查看

1.检查 MongoDB

systemctl status mongod

2.检查 tkserver 是否运行

sudo systemctl status tkserver

4.检查 tkserver 是否监听 8080 端口

ss -tlnp | grep 8080

正常应该得到

5.检查 MongDB 是否监听端口

ss -tlnp | grep 27017

6.测试接口

浏览器访问：

https://你的站点

得到如图所示即表示 tkserver 没有问题，以上配置完后即可正常在博客主题中加入对应接口，类似以下：

twikoo: {
		envId: "https://twikoo.sirens007.cn",
		lang: SITE_LANG,
	},

至此，以上配置完后相应的评论数据可以通过各种可视化数据库查看，相应访问速度也会更快！

参考文章：

私有部署 - Twikoo 官方文档

Umami 自托管迁移：Docker 部署、Nginx 代理与数据导入

Tue, 05 May 2026 00:00:00 GMT

相信我，docker 会比直接裸装数据库要好，因为很大可能你的 Umami build 不动，除非本地构建再上传；就是那样的话本地还得装环境，况且 Umami 官方是支持 docker 部署的

一、安装 Docker 和 Docker Compose

1.添加 Docker 官方仓库(镜像)

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg

2.添加 Docker GPG key 下载，换为阿里云的镜像

Docker 官方要求把 GPG key 存在这个目录，属于新的安全规范（避免污染系统 key）。

sudo mkdir -p /etc/apt/keyrings

curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg \
| sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

https://download.docker.com -> https://mirrors.aliyun.com

3.添加 Docker apt 源

把 Docker 下载地址从官方改成镜像
以后 apt install docker-ce 就走国内源

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://mirrors.aliyun.com/docker-ce/linux/ubuntu \
$(lsb_release -cs) stable" \
| sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4.安装 Docker 和 Docker Compse

刚刚添加了新源，必须更新，否则 apt 不知道这个源存在

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

5.验证安装完成

docker -v
docker compose version

6.允许普通用户使用 Docker，避免每一步 sudo

sudo usermod -aG docker $USER
newgrp docker

Umami 推荐用 Docker Compose 部署，这样 Umami 应用和 PostgreSQL 数据库可以统一管理。

7.创建 Umami 部署目录

sudo mkdir -p /opt/umami
sudo chown -R $USER:$USER /opt/umami
cd /opt/umami

把 Umami 的配置文件和数据库挂载数据统一放在 /opt/umami，后期维护、备份、迁移更方便。

二、编写 docker-compose.yml

切换目录为：

cd /opt/umami
nano docker-compose.yml

写入内容如下（：APP_SECRET、POSTGRES_DB、POSTGRES_USER: umami

  `POSTGRES_PASSWORD`可自行更改

services:
  umami:
    image: ghcr.io/umami-software/umami:latest
    container_name: umami
    ports:
      - "127.0.0.1:3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:umami_password@db:5432/umami
      APP_SECRET: your_random_app_secret
    depends_on:
      db:
        condition: service_healthy
    restart: always

  db:
    image: postgres:15-alpine
    container_name: umami-db
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami_password
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U umami -d umami"]
      interval: 5s
      timeout: 5s
      retries: 5

生成 APP_SECRET：

openssl rand -base64 32

DATABASE_URL 是 Umami 连接 PostgreSQL 的地址。
APP_SECRET 用于加密会话，不能随便写固定弱字符串。
127.0.0.1:3000:3000 表示 Umami 只允许本机访问，外部访问交给 Nginx 反代，更安全。

三、启动 Umami

1. 以下命令是在/opt/umami 下执行，否则会找不到 docker-compose.yml

cd /opt/umami
sudo docker compose up -d

2. 查看容器：

sudo docker compose ps

3. 查看日志：

sudo docker compose logs -f umami

确认 Umami 和 PostgreSQL 是否正常运行，尤其是数据库，像图片中就是正常运行了

4.测试本地访问

curl -I https://127.0.0.1:3000

正常是可以得到 HTTP/1.1 200 OK此类回显；

我们的顺序是先确认 Umami 本身在服务器内部可访问，再配置域名和 HTTPS

四、配置 Nginx 反向代理

1.创建配置：

sudo nano /etc/nginx/sites-available/umami

写入：

以下内容要 注意更改证书路径

server {
    listen 80;
    server_name umami.sirens007.cn;

    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name umami.sirens007.cn;

    ssl_certificate /path/to/your.crt;
    ssl_certificate_key /path/to/your.key;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://127.0.0.1:3000;

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

启用：

sudo ln -s /etc/nginx/sites-available/umami /etc/nginx/sites-enabled/umami
sudo nginx -t
sudo systemctl reload nginx

是因为 Docker 里的 Umami 不直接暴露公网，而是通过 Nginx 提供 HTTPS 访问，后期方便配置证书、缓存...

注意，在访问并登录 Umami 前，先申请 SSL 证书以便支持 https 协议，如果是阿里云用户可

以在阿里云中申请个人测试证书，要记得三个月一换

申请后可以在阿里云的工作台一键上传证书和私钥，记得上传

随后便可以登录 Umami：

直接在浏览器访问https://umami.sirens007.cn，改为你的域名即可

默认账号密码为：

用户名：admin

密码：umami

登录后立刻修改密码，否则你的账号可能被别人登录并改密

五、导入 Umami 访问数据

1. 在 Umami 后台添加你的网站，比如blog.sirens007.cn

创建一条 website，随后就可以得到 shareId，并且获取统计脚本，例如

<script
  defer
  src="https://umami.sirens007.cn/script.js"
  data-website-id="新的 website_id">
</script>

为什么导入放在后面，因为可以让你的网站能拿到最新的访问数据...

开个玩笑，其实就是为了在能够拿到 website_id 后，才需要对导出的数据文件操作

2.访问 Umami Cloud Data | Settings ，选择导出数据

随后会在你注册的邮箱中收到一个 zip 压缩包，其中只有 website_event.csv 这个文件有数据，其他两个只有表头

不知道你是一位喜欢 CLI 界面还是 GUI 界面的爱好者，如果是喜欢命令行的话在服务器用查询语句就可以查到 umami 这个仓库下的所有字段；如果喜欢图形化，那么 Navicat 可能是你需要的，或者 pgAdmin - PostgreSQL Tools。类似下图中可以看到各个字段的顺序，同时也可以修改

此时你可能还需要一个能够修改 csv 文件的一个软件，不推荐 wps 和 excel，首先 excel 可能是 CRLF 文件类型问题，wps 在你编辑后需要转为 xlsx 文件，所以还是奉劝下一个CSV编辑软件： SmoothCSV - The ultimate CSV editor for macOS & Windows

在我在的版本 Umami3.1 中，website_event.csv 文件中有 41 行数据，而 PostgreSQL 数据库中的 website_event 这个表中只有 31 条，因此如果要导入该文件需要删除 10 条数据库中不存在的字段的数据，但是要先备份该文件，因为后 10 条数据实际上是放在数据库中的 session 这个表中的，因此将备份的文件删掉 event 表中的 31 列数据后并排好序就可导入

website_event.csv 该文件中的 event_id 需要修改为服务器部署的 Umami 增设的 website 新获得的 websiteId，只有此处有修改，剩下的只需要排序即可

3. 随后使用 scp 命令上传至服务器即可

scp website_event.csv session.csv root@服务器IP:/home/sirens/

4. 然后复制进 PostgreSQL 容器：

sudo docker cp /home/root/website_event.csv umami-db:/tmp/website_event.csv
sudo docker cp /home/root/session.csv umami-db:/tmp/session.csv

主要是因为psql \copy 在容器里执行时，读取的是容器内部路径，所以要先把 CSV 放进容器的 /tmp

5. 随后进入 PostgreSQL：

sudo docker compose exec db psql -U umami -d umami

-U 代表用户 Users，-d 代表 database

数据导入、查看表结构、删除约束、恢复约束都要在 PostgreSQL 里完成或者在 Navicat 中完成；在导入前，最后检查一遍是否与数据库中的字段顺序对应上

6. 查看 website_event：

SELECT ordinal_position, column_name, data_type
FROM information_schema.columns
WHERE table_name = 'website_event'
ORDER BY ordinal_position;

6. 查看 session：

SELECT ordinal_position, column_name, data_type
FROM information_schema.columns
WHERE table_name = 'session'
ORDER BY ordinal_position;

注意可能输出的字段按页折叠，记得检查完全

重要步骤！！！

7. 迁移前先备份数据库

sudo docker compose exec db pg_dump -U umami -d umami > /opt/umami/backup_before_import.sql

8.再检查一下本地 session 和 website_event 字段顺序

检查 website_event：

SELECT ordinal_position, column_name, data_type
FROM information_schema.columns
WHERE table_name = 'website_event'
ORDER BY ordinal_position;

然后根据实际字段写导入语句，例如常见结构可能类似：

\copy website_event (
  event_id,
  website_id,
  session_id,
  created_at,
  url_path,
  url_query,
  referrer_path,
  referrer_query,
  referrer_domain,
  page_title,
  event_type,
  event_name,
  visit_id
)
FROM '/tmp/website_event.csv'
WITH (FORMAT csv, HEADER true, NULL '\N', QUOTE '"');

# 建议执行单条命令，如上条报错
sudo docker compose exec db psql -U umami -d umami -c "\copy session (session_id, website_id, browser, os, device, screen, language, country, region, city, created_at, distinct_id) FROM '/tmp/session.csv' WITH (FORMAT csv, HEADER true, NULL '\N', QUOTE '\"');"

注意：
这条不能直接照抄，必须以你本地 information_schema.columns 查到的字段为准；

原因：
Umami Cloud 导出的 CSV 字段和本地 v3.x 表结构可能不同。多字段、少字段、顺序不一致都会导入失败；

检查 session 本地字段：

SELECT column_name
FROM information_schema.columns
WHERE table_name = 'session'
ORDER BY ordinal_position;

然后导入时必须这样写成一整条命令，不要在 psql 交互里分开敲：

\copy session (
  session_id,
  website_id,
  browser,
  os,
  device,
  screen,
  language,
  country,
  region,
  city,
  created_at,
  distinct_id
)
FROM '/tmp/session.csv'
WITH (FORMAT csv, HEADER true, NULL '\N', QUOTE '"');

如果你是在 shell 里执行，推荐：

sudo docker compose exec db psql -U umami -d umami -c "\copy session (session_id, website_id, browser, os, device, screen, language, country, region, city, created_at, distinct_id) FROM '/tmp/session.csv' WITH (FORMAT csv, HEADER true, NULL '\N', QUOTE '\"');"

原因：

就是我之前有报错syntax error at or near "session_id"

9.重启 Umami

sudo docker compose restart umami

最后访问后台 umami.example.com 登录检查数据是否对应即可

总流程顺序：

1. 安装 Docker
2. 创建 /opt/umami
3. 写 docker-compose.yml
4. 启动 Umami + PostgreSQL
5. 配置 Nginx + HTTPS
6. 登录后台并修改密码
7. 创建网站
8. 导出 Umami Cloud 数据
9. 上传 CSV 到服务器
10. 备份本地数据库
11. 查看本地表结构
12. 修正 CSV 字段和 website_id
13. 导入 session
14. 导入 website_event
15. 检查数据关联
16. 恢复约束
17. 重启 Umami
18. 修改博客统计脚本
19. 后台验证统计结果

参考文章：

Umami Cloud迁移到本地踩坑记录

Installation

Java 对象比较的三种方式：equals、Comparable 与 Comparator

Tue, 14 Apr 2026 00:00:00 GMT

我们就拿这个来举例：

public class Card{
    public String suit;
    public int rank;

    public Card(String suit,int rank) {
        this.suit = suit;
        this.rank = rank;
    }
    
    public static void main(String[] args) {
        Card card1 = new Card("hongtao", 5);
        Card card2 = new Card("heitao", 5);
}

1.覆写基类的 equals

当我们要判断两张牌是否相同时，需要比较的内容是 suit 以及 rank 两个属性。

因此在比较是否相同上，我们通常用==进行比较，而在两个实例化的 card 中，则使用 euqals方法。

public class Card {
    public String suit;
    public int rank;

    public Card(String suit,int rank) {
        this.suit = suit;
        this.rank = rank;
    }
    // 比较牌面、花色是否相同
    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        Card card = (Card) o;
        return rank == card.rank && Objects.equals(suit, card.suit);
    }

    @Override
    public int hashCode() {
        return Objects.hash(suit, rank);
    }
}

重写 equals、hashCode 方法

在 IDEA 上，可以使用快捷键Alt+Ins，找到 equals 和 hashCode默认下一步即可

2.基于 Comparable 接口类的比较

对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现Comparable接口即可，然后在类中重写compareTo方法。

public class Card implements Comparable<Card> {
    public String suit;
    public int rank;

    public Card(String suit,int rank) {
        this.suit = suit;
        this.rank = rank;
    }
    // 大小比较
    @Override
    public int compareTo(Card o) {
        return this.rank - o.rank;
    }
}

因此我们在只比较牌面大小的时候，可以通过重写compareTo方法即可。

其 return 有两种写法

return this.rank - o.rank;
return Integer.compare(this.rank, o.rank);  //  更安全

该方法的返回值含义有以下：

public interface Comparable<E> {
// 返回值:
// < 0: 表示 this 指向的对象小于 o 指向的对象
// == 0: 表示 this 指向的对象等于 o 指向的对象
// > 0: 表示 this 指向的对象大于 o 指向的对象
int compareTo(E o);
}

3.基于比较器比较

当用户自定义比较器的时候，实现这个接口并重写 compare 方法

例如，在该例子中我想比较花色，我们可以在 Card 类之外再创建一个类去实现该接口。减少对类的嵌入

comapre 方法内如何比较可自定义

class SuitComparator implements Comparator<Card> {
    public int compare(Card o1,Card o2) {
        return o1.suit.compareTo(o2.suit);
    }
}

注意：Comparator 是 java.util 包中的泛型接口类，使用时必须导入对应的包。

该比较器的方法返回值如下：

public interface Comparator<T> {
// 返回值:
// < 0: 表示 o1 指向的对象小于 o2 指向的对象
// == 0: 表示 o1 指向的对象等于 o2 指向的对象
// > 0: 表示 o1 指向的对象等于 o2 指向的对象
int compare(T o1, T o2);
}

三种方式的对比

特性	Object.equals	Comparable	Comparator
比较目的	判断相等	定义默认顺序	定义多种/临时顺序
比较结果	boolean	int (负, 0, 正)	int (负, 0, 正)
修改位置	类内部	类内部（实现接口）	类外部（独立比较器）
灵活性	低	中（一种规则固定）	高（多种规则切换）
典型方法	`a.equals(b)`	`a.compareTo(b)`	`c.compare(a, b)`

七种经典排序算法：实现思路、复杂度与适用场景

Tue, 14 Apr 2026 00:00:00 GMT

1. 插入排序

插入排序过程：

定义 tmp 变量存储array[i]当前数值，定义j = i - 1变量
利用循环将当前array[i]去遍历数组前[0,j]元素比较大小。若tmp有比前[0,j]元素要小，则array[j]赋值给array[j+1]；若tmp大于[0,j]中某元素，则array[j+1] = tmp
随后 j- -，完成循环

1.1 插入排序实例

举例排序过程如下：

具体动图如下：

实现代码如下：

/**
* 直接插入排序
* 时间复杂度：O(n^2)
* 空间复杂度：O(1)
*/ 
public static void insertSort(int[] array) {
	for (int i = 1; i < array.length; i++) {
    	// 定义临时变量进行存储、为下方提供比较对象
        int tmp = array[i];
        int j = i - 1;
        // 边找位置边移动
        while (j >= 0 && array[j] > tmp) {
        	// 将当前值后移
            array[j + 1] = array[j];
            j--;
        }
        // 插入到正确位置
        array[j + 1] = tmp;
    }
}

1.2 复杂度：

无论其是否有序、无序，其时间复杂度都为 O(N^2)。

稳定性：稳定

因为其首先利用 i 遍历数组上每一个元素(不钻牛角尖第一个)，随后的 j 还要遍历一段去比较 tmp，属于嵌套循环，因此无论在逻辑上还是代码上都是 O(N^2)，而空间复杂度则为 O(1)，所创建的变量是有限个的

2. 希尔排序

1959年，唐纳德·希尔（Donald Shell）提出了一个改进思路：

先让数组基本有序，再用插入排序完成最终排序。

希尔排序即，缩小增量排序，其具体思想为：

先选定一个整数 gap（称为增量），把待排序文件中的所有记录分成 gap 组，所有距离为 gap 的记录分在同一组内；
对每一组内的记录进行直接插入排序；
然后缩小增量（如 `gap = gap / 2），重复上述分组和排序的工作；
当 gap = 1 时，所有记录在同一组内，此时再执行一次直接插入排序，整个序列就排好序了。

2.1 希尔排序实例

举例排序过程如下：

初始 gap = 5；缩小量为 gap = gap/2

数据如下

排序元素为对应颜色指向的元素下进行排序，得到如下数组

随后 gap = 2；此时每隔两个空间设为一个组类

排序后的数组为：

此后 gap = 1；此时数组统一进行一次大排序，将进行直接插入操作，因此得到

具体动图过程如下：

上 gif 动图中 gap = 2 时直接跳过变换过程，

实现代码如下：

// 希尔排序
public static void shellSort(int[] array) {
    int gap = array.length;
    while(gap > 1) {
        gap = gap/2;
        shell(array,gap);
    }
}
private static void shell(int[] array,int gap) {
    for (int i = gap; i < array.length; i++) {
        int tmp = array[i];
        int j = i - gap;
        // 以下部分与插入排序相同，仅将1改为gap
        while(j >= 0 && array[j] > tmp) {
            array[j + gap] = array[j];
            j -= gap;
        }
        array[j + gap] = tmp;
    }
}

2.2 复杂度：

在学术方面，对于希尔排序的时间复杂度一直有多种说法，也一直尚未有准确的时间复杂度。比如：

以及

根据对书籍总结，我们可以将其时间复杂度视为 O(N^1.25) 到 O(1.6*N^1.25) 来算

3. 选择排序

选择排序过程：

先假设第一个元素为最小元素，暂存其下标
遍历剩余元素是否有比最小元素还小的元素
如有，则在遍历完一轮后交换；若无，则第一层的下标后移一位，假设第二个元素为最小元素，暂存其下标...以此重复

3.1 选择排序实例

举例排序过程如下：

由第一层的 i 暂定最小值，第二层的 j 遍历寻找是否有更小的元素

具体动图如下：

实现代码如下：

    /**
     * 选择排序
     * 时间复杂度：
     * 空间复杂度：
     * 稳定性：
     * @param array
     */
public static void selectSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        // 定义最小元素下标
        int minIndex = i;
        // 向后遍历数组，寻找小于最小元素的元素
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[minIndex])
                minIndex = j;
        }
        swap(array,minIndex,i);
    }
}

/**
 * @param array 数组
 * @param i 下标
 * @param j 要换的元素的下标
 */
public static void swap(int[] array,int i,int j) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}

但上述代码存在优化，优化内容为：

最大最小值可同时找，可减少第二层遍历次数

优化后的过程如下图所述：

定义 left 与 right 为数组两端，i 为中间元素下标在 for 循环中游走，同时比较最大最小值

注意：当默认最小值为实际最大值的时候，在交换最小值过程中实际最大值已被换走，而当最大值交换过程中实际最大值已被换为实际最小值，如图中所举案例 minIndex 要与 left 换，但 left（maxIndex）同时还要与 right 换，因此我们需要在此判断一下，if (maxIndex == left) maxIndex = minIndex;

完整代码如下：

public static void selectSortPlus(int[] array) {
    int left = 0;
    int right = array.length - 1;
    while (left < right) {
        int minIndex = left;
        int maxIndex = left;
        // 遍历中间元素，同时找最大最小值
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < array[minIndex])
                minIndex = i;
            if (array[i] > array[maxIndex])
                maxIndex = i;
        }
        swap(array,left,minIndex);
        // 最大值正好是 left下标，此时已经被上一步换到minIndex了
        if (maxIndex == left) maxIndex = minIndex;
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

/**
 * @param array 数组
 * @param i 下标
 * @param j 要换的元素的下标
 */
public static void swap(int[] array,int i,int j) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}

3.2 复杂度：

对于未优化的版本：

外层循环需要执行 n - 1 次（i 从 0 到 n - 2）；

内层循环比较次数从第一轮到第 n - 1 轮：n - 1 次、n - 2 次、n - 3 次......1 次

由等差数列求和可约等于 n^2/2，即时间复杂度为 O(N^2)、空间复杂度显然为 O(1)

对于优化版本的：

外层循环需执行的次数：n/2 轮

每层内循环需要遍历right - left个元素，我们用归纳法

第 1 轮：n - 1 次；第二轮：n - 3 次；第三轮：n - 5 次......最后一轮：1 次；

综上为公差为 2 的等差数列，最总计算约为 n^2/4；时间复杂度同样为 O(N^2)、空间复杂度同样显然为 O(1)

4. 堆排序

将数组视为二叉树

堆排序过程：

建大根堆
反复将堆顶（最大值）放到末尾
剩余部分重新调整为大根堆
重复直到全部有序

最终结果：升序数组，天然满足小根堆性质

4.1 堆排序实例

举例排序过程如下：

例:集合{ 27,15,19,18,28,34,65,49,25,37 }

createHeap 调用 siftDown 调整为大根堆过程如下:

我们要从最后一个非叶子节点下手,因此我们选定 4 下标与其子树进行比较,因此 4 下标为 parent 索引,9 下标则为 child 索引

child > parent 则交换,child = parent 赋值,parent = (parent -1)/2 向上走
此刻 child > parent,重复步骤一随后得到 parent 为 0 索引

以上为一轮 for 循环,因此我们只需要对非叶子节点从后往前一步步循环换上去即可

具体上述过程可看前篇大根堆小根堆篇

heapSort 过程如下：

将堆顶（最大值）放到末尾，剩余部分重新调整为大根堆，依次进行最终调整为升序数组

具体动图如下：

实现代码如下：

/**
 * 堆排序
 * 时间复杂度：O(NlogN)
 * 空间复杂度：O(1)
 * 稳定性：不稳定
 * @param array
 */
public static void heapSort(int[] array) {
    createHeap(array);
    int end = array.length - 1;
    while (end > 0) {
        // 反复将堆顶（最大值）放到末尾
        swap(array,0,end);
        // 剩余部分重新调整为大根堆
        siftDown(array,0,end);
        end--;
    }
}
// 创建大根堆
private static void createHeap(int[] array) {
    for (int parent = (array.length-2)/2; parent >= 0; parent--) {
        siftDown(array,parent,array.length);    // parent逐步-1 根节点往上走
    }
}
/**
 * @param parent 每棵子树调整的时候 的 起始位置
 * @param length 判断 每棵子树什么时候 调整 结束
 */
// 大根堆 -- 每棵树的根节点向下调
private static void siftDown(int[] array,int parent,int length) {
    int child = 2 * parent + 1; // 求得左子节点所在位
    while(child < length) {   //
        if(child + 1 < length && array[child] < array[child + 1]) {
            child++;    // 若右子树存在且小于左子树，则找到右子树
        }
        if(array[child] > array[parent]) {    // 如果于它的根，则换
            swap(array,child, parent);
            parent = child;     // 根节点向下移动，循环将下面的排好
            child = 2 * parent + 1; // 找根节点下面的左子树
        } else {
            break;  // 跳出循环
        }
    }
}

public static void swap(int[] array,int i,int j) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}

4.2 复杂度：

建堆createHeap()时间复杂度：

排序阶段heapSort()：

while (end > 0) {
    swap(array, 0, end);        // O(1)
    siftDown(array, 0, end);    // O(log n)
    end--;
}

循环次数为 n-1 次；每次 siftDown 的时间复杂度为O(log n)（堆的高度），则总时间复杂度 = O(n log n)。

两部分的总时间复杂度则为：O(N logN)
空间复杂度为 O(1)

5. 冒泡排序

冒泡排序过程：

相邻元素两两比较，如果前面比后面大，就交换
每一轮结束后，当前未排序部分的最大值会“沉”到末尾
重复直到全部有序

5.1 冒泡排序实例

具体动图如下：

该图为最终优化版代码：

/**
 * 冒泡排序：
 * 时间复杂度：O(N^2)
 * 空间复杂度：O(1)
 * 稳定性：稳定
 * @param array
 */
public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        boolean flg = false;
        for (int j = 0; j < array.length - 1 - i; j++) {
            if(array[j] > array[j + 1]) {
                swap(array,j,j + 1);
                flg = true;
            }
        }
        if (!flg) break;
    }
}

具体优化处：

增加 flg 判断是否已有序，从而提前退出循环
j < array.length - 1 - i;减少对比次数，无需多余对比已排好元素

5.2 复杂度：

时间复杂度：

最好情况：当数组有序时，时间复杂度为 O(N)

最坏情况：当数组逆序时，时间复杂度为 O(N^2)

平均情况：O(N^2)

空间复杂度为 O(1)

稳定性：稳定

6. 快速排序

快速排序是 Hoare 于 1960 年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快排的总体思路：

选一个基准值
将数组分成两部分：左边都 ≤ 基准，右边都 ≥ 基准
对左右两部分重复上述过程

6.1 快排方法

6.1.1 递归框架

根据上述排序说明，可以列出以下递归框架：

该递归框架可用于Hoare、挖坑、双指针法

public static void quickSort(int[] array) {
    quick(array,0,array.length - 1);
}

void quick(int[] array, int left, int right) {
    // 递归终止条件：区间内没有元素或只有一个元素
    if (left >= right) {
        return;
    }
    // 分区操作：将数组分成两部分，并返回基准元素的最终位置
    int pivot = partition(array, left, right);
    // 递归排序左半部分：[left, pivot]
    quick(array, left, pivot);

    // 递归排序右半部分：[pivot+1, right]
    quick(array, pivot + 1, right);
}

递归框架下的复杂度说明：

当数组为有序(1，2，3，4，5...)或逆序(5，4，3，2，1...)时候，时间复杂度达到了O(N^2)；最好情况是数组拆分时满足满二叉树时候，时间复杂度达到 O(N logN)，具体计算是由于拆分后每层相加总个数都为 N，二叉树高度为 log N。

而空间复杂度最坏可达到 O(N)因为递归需要开辟内存，并且为逆序是二叉树为单枝二叉树，节点为 N 个则需要递归 N 次；最好情况还是满二叉树时候复杂度达到 O(logN)，因为树的高度为 logN，当递归完左侧之后再递归右侧时，左侧的空间就会释放掉。

注意：以下方法在介绍时不区分递归与否，递归与否与下方分区方法无关

6.1.2 Hoare 分区法

递归下的 Hoare 方法：

排序说明：

基准值一般会选左端或右端值作为基准值，此处我们以左端为基准值
从后边开始找比基准值小的值停下来，与左侧所停值交换；
从前边开始找比基准值大的值停下来，与右侧所停值交换；
最终会停在中间某一处(将该处设为 pivot)，此处将数组分为左侧与右侧，采取分而治之的思想递归

不论好坏情况，一般声明时间复杂度 O(N logN)、空间复杂度 O(log N)

注意以下顺序：

双指针从两端向中间移动

先移动右指针，再移动左指针

交换不满足条件的元素

最后基准归位

图中原数组顺序为：

{6，1，2，7，9，3，4，5，10，8}

注意：由于基准值选在左端，必须先从右向左找小，再从左向右找大。如果左侧先移动，图中数组最终会在 9 位置停下，此时 9 不能与 6 交换；当左侧先走时能保证 left 会停在一个比 6 小的位置

左右相同的程序进行排序，类似二叉树;

注意内容已在图中说明，即循环结束判断标志如上。对照上面所描述步骤可以实现下面代码

private static int partition (int[] array, int left, int right) {
    int tmp = array[left];
    int tmpLeft = left;
    // 双指针在数组中移动判断
    while (right > left) {
        while (right > left && array[right] >= tmp)
            right--;
        while (left < right && array[left] <= tmp)
            left++;
        swap(array,right,left);
    }
    // 走完循环后，基准值还需与中间值交换
    swap(array,left,tmpLeft);
    return left;
}

6.1.3 挖坑法（重点）

挖坑法描述：

tmp 暂存左端值，方便后序放回数组
right 找比 tmp 小的值，若找到，则"填坑"到 left 位置，等待 right 交换完再移动；
left 找比 tmp 大的值，若找到，则"填坑"到 right 位置，然后等待 right 交换完再移动；
重复直到 left == right
最后将基准值填入相遇位置

最终找到 pivot 中间值，该段方法仅需做到这点即可，剩余的是调用方法考虑的

private static int hole_Partition (int[] array, int left, int right){
    int tmp = array[left];
    // 循环条件
    while (left < right) {
        while (left < right && array[right] >= tmp)
            right--;
        // 若右指针跳出循环停下，则右侧赋给左侧
        array[left] = array[right];

        while(left < right && array[left] <= tmp)
            left++;
        // 若左指针跳出循环停下，则左侧赋给右侧
        array[right] = array[left];
    }
    // 最终相遇，将tmp拿回放中间
    array[left] = tmp;
    return left;
}

6.1.4 双指针法

双指针法一般使用情况少，多数为挖坑法

双指针法描述：

tmp 暂存左端值，作为基准值，方便后续归位
prev 指针初始指向 left，标记小于基准值的区域边界
cur 指针从 left+1 开始向右遍历，寻找比基准值小的元素：
1. 若 array[cur] < array[left]，说明找到比基准小的值
2. 先将 prev++，扩大至小于基准的区域
3. 若array[prev] != array[cur]，则交换 array[prev] 与 array[cur]，将小值移到左边
重复步骤 3，知道 cur 指针遍历完整个区间
最后将基准值填入 prev 位置，交换 array[prev]与 array[left]，返回 prev 作为基准最终位置

以下动图即为双指针法排序过程：

代码实现如下：

// 双指针法
private static int twop_Partition (int[] array, int left, int right){
    // 暂存基准值
    int tmp = array[left];
    int prev = left;
    int cur = prev + 1;

    while (cur <= right) {
        // a. 若 array[cur] < tmp，说明找到比基准小的值
        if (array[cur] < tmp) {
            // b. prev++，扩大小于基准的区域
            prev++;
            // c. 若 array[prev] != array[cur]，则交换
            if (array[prev] != array[cur])
                swap(array,prev,cur);
        }
        cur++;
    }
    // 最后将基准值填入 prev 位置
    swap(array,left,prev);
    return prev;
}

6.2 快速排序优化

6.2.1 三数取中优化

三数取中的必要性

三数取中是为了选择一个更好的基准值，以提高快速排序的效率。在快速排序中，选择一个合适的基准值是非常重要的，它决定了每次分割的平衡性。
如果每次选择的基准值都是最左边或最右边的元素，那么在某些情况下，快速排序的效率可能会降低。例如，当待排序序列已经有序时，如果每次选择的基准值都是最左边或最右边的元素，那么每次分割得到的两个子序列的长度差可能会非常大，导致递归深度增加，快速排序的效率降低。
而通过三数取中的优化，可以选择一个更好的基准值，使得每次分割得到的两个子序列的长度差更小，从而提高快速排序的效率；也就是尽量满足之前所说的全满二叉树，而不是单支二叉树

使用三数取中法位置在调用子问题排序之前：

void quickSort(int[] array, int left, int right) {
    // 递归终止条件：区间内没有元素或只有一个元素
    if (left >= right) {
        return;
    }
    // 三数取中法调用出
    getMiddle(array,)
    
    // 分区操作：将数组分成两部分，并返回基准元素的最终位置
    int pivot = partition(array, left, right);
    // 递归排序左半部分：[left, pivot]
    quickSort(array, left, pivot);

    // 递归排序右半部分：[pivot+1, right]
    quickSort(array, pivot + 1, right);
}

根据上图思考以下比较代码：

private static int getMiddle (int[] array, int left, int right) {
    // 找到中位置
    int mid = (left + right) / 2;
        
    if (array[left] < array[right]) {
        if (array[mid] < array[left])
            return left;
        else if (array[mid] > array[right])
            return right;
        else
            return mid;
    } else {
        if (array[mid] < array[right])
            return right;
        else if(array[mid] > array[left])
            return left;
        else
            return mid;
    }
}

6.2.2 小区间优化

小区间优化是指在快速排序中，当待排序的子序列的长度小于一定阈值时，不再继续使用快速排序，而是转而使用直接插入排序。

代码实现：（以子序列元素个数为 10 举例）

仅修改在上面所述的递归框架的 quick 方法修改即可

private static void quick(int[] array,int start,int end) {
    if (start >= end) return;

    if(end - start + 1 <= 10) {
        insertSortRange(array,start, end);
        return;
    }
    // 三数取中法调用出
    int midNum = getMiddle(array,start,end);
    // 更换基准值
    swap(array,start,midNum);

    int privot = twop_Partition(array,start,end);
    quick(array,start,privot - 1);
    quick(array,privot + 1,end);
}
private static void insertSortRange(int[] array,int start,int end) {
    for (int i = start + 1; i <= end; i++) {
        // 定义临时变量进行存储、为下方提供比较对象
        int tmp = array[i];
        int j = i - 1;
        // 边找位置边移动
        while (j >= start && array[j] > tmp) {
            // 将当前值后移
            array[j + 1] = array[j];
            j--;
        }
        // 插入到正确位置
        array[j + 1] = tmp;
    }
}

要注意取值边界

使用直接插入排序的原因：

减少递归深度：使用插入排序来处理较小的子序列，可以减少递归的深度，从而减少了函数调用的开销。
直接插入排序对于本就较有序的数列排序更快，且一次走完数组就能够排序完成。

6.3 非递归快排

非递归快排思路：

创建栈，用来存储区间的左边界和右边界；将整个数组的左右边界压入栈
从栈中弹出一个区间的左右边界，堆该区间进行分区操作
选择基准值，将数组分为左右两部分，基准值归位，返回基准的最终值
将左子区间的左右边界压入栈，将右子区间的左右边界压入栈（重复步骤 2，知道栈空）

以下为思路的实例举例：

代码实现如下：

public static void quickNor(int[] array, int start, int end) {
    // 1. 创建栈，存储区间边界值
    Deque<Integer> stack = new ArrayDeque<>();
    
    // 2. 将初始区间边界压栈
    stack.push(start);  // 左边界
    stack.push(end);    // 右边界
    
    // 3. 循环处理，直到栈为空
    while (!stack.isEmpty()) {
        // 4. 弹出区间的边界值
        int right = stack.pop();  // 注意：先弹出右边界
        int left = stack.pop();   // 再弹出左边界
        
        // 5. 区间有效性检查
        if (left >= right) {
            continue;
        }
        
        // 6. 分区操作，返回基准位置
        int pivot = partition(array, left, right);
        
        // 7. 将左子区间的边界值压栈
        if (left < pivot - 1) {
            stack.push(left);      // 左边界
            stack.push(pivot - 1); // 右边界
        }
        
        // 8. 将右子区间的边界值压栈
        if (pivot + 1 < right) {
            stack.push(pivot + 1); // 左边界
            stack.push(right);     // 右边界
        }
    }
}

注意：pivot 的左右侧为 1 个元素时，不进行压栈

7. 归并排序

归并排序（Merge Sort）采用分治思想。其核心思路是：先把数组不断分成两半，

直到每部分只有一个元素，然后再将有序的两部分合并成更大的有序部分，最终整个数组有序；

归并排序的过程：

先判断当前数组长度是否≤1，如果是则直接返回（递归出口）；
若长度大于 1，则找到数组中间位置，将数组分成左半部分和右半部分；
对左半部分递归调用并排序（重复 1~3 步，直到左半部分为单独个体）
对右半部分递归调用并排序（重复 1~3 步，直到右半部分为单独个体）
左右两部分都已有序后，新建一个临时数组；
同时遍历左右两部分：比较两个部分的当前元素，将较小的那个放入临时数组，并移动对应部分的指针；
重复第 6 步，直到某一部分的所有元素都已被放入临时数组；
将另一部分剩余的所有元素依次放入临时数组；
将临时数组中的元素复制回原数组对应的位置；
返回上一层的递归，继续合并更大的有序片段，直到整个数组完全有序；

图形化表示如下：

7.1 归并排序实例

具体动图如下：

在实际图像表示中，是像动图中，整体划分好两大部分，每部分中两个为一组；

两个为一组排好两组后，以四个为一组再调整；

四个为一组排好两组后，以八个为一组再调整...

最终两大组再合并一起；

实例参考：

原始数组为 [10, 6, 7, 1, 3, 9, 4, 2]

递归拆分

第一层：[0,7] → [0,3] + [4,7]

第二层： [0,3] → [0,1] + [2,3]
[4,7] → [4,5] + [6,7]

第三层：（拆到为单项）

[0,1] → [0] [1]

[2,3] → [2] [3]

[4,5] → [4] [5]

[6,7] → [6] [7]

此时数组被划分为：[10] [6] [7] [1] [3] [9] [4] [2]

从下往上合并

merge(array, 0, 0, 1)，合并 [0,1] → 【10 和 6】

merge(array, 2, 2, 3)，合并 [2,3] → 【7 和 1】

merge(array, 4, 4, 5)，合并 [4,5] → 【3 和 9】

merge(array, 6, 6, 7)，合并 [6,7] → 【4 和 2】

继续往上合并

第二轮合并：[6,10] + [1,7] → [1,6,7,10]

[3,9] + [2,4] → [2,3,4,9]

第三轮合并：[1,6,7,10] + [2,3,4,9] → [1,2,3,4,6,7,9,10]

7.2 递归实现

具体代码实现：

public static void mergeSort(int[] array) {
    mergeSortTmp(array,0,array.length - 1);
}

private static void mergeSortTmp(int[] array,int left,int right) {
    if (left >= right) return;

    // 1.递归分组
    int mid = (left + right) / 2;
    mergeSortTmp(array, left, mid);
    mergeSortTmp(array, mid + 1, right);

    // 2.合并
    merge(array,left,mid,right);
}

private static void merge(int[] array,int left,
                          int mid,int right) {
    // 1.创建临时数组
    int[] tmp = new int[right - left + 1];
    int k = 0;  // 记录临时数组索引
    int s1 = left;      // 左侧小组起始位
    int s2 = mid + 1;   // 右侧小组起始位

    // 2.循环比较放入
    while (s1 <= mid && s2 <= right) {
        if (array[s1] <= array[s2])
            tmp[k++] = array[s1++];
        else
            tmp[k++] = array[s2++];
    }
    // 3.将s1或s2剩下的填入
    while (s1 <= mid)
        tmp[k++] = array[s1++];
    while (s2 <= right)
        tmp[k++] = array[s2++];

    // 4.将临时数组拷贝入原始数组中
    for (int i = 0; i < k; i++) {
        array[i + left] = tmp[i];
    }
}

7.3 非递归实现

实例参考：

// 归并排序 非递归实现
public static void mergeSortNor (int[] array) {
    int gap = 1;    // 小组之间的间隔

    while (gap < array.length) {
        for (int i = 0; i < array.length; i = i + 2 * gap) {
            int left = i;   // 记录第一个小组左值下标
            int mid = left + gap - 1;   // 记录第一个小组右值下标
            // 防止mid数组越界
            if (mid >= array.length)
                mid = array.length - 1;

            int right = mid + gap;  // 记录第二个小组右值下标
            // 防止right数组越界
            if(right >= array.length)
                right = array.length - 1;
            merge(array,left,mid,right);
        }
        gap *= 2;
    }
}

private static void merge (int[] array,int left,
                              int mid,int right) {
    // 1.创建临时数组
    int[] tmp = new int[right - left + 1];
    int k = 0;  // 记录临时数组索引
    int s1 = left;      // 左侧小组起始位
    int s2 = mid + 1;   // 右侧小组起始位

    // 2.循环比较放入
    while (s1 <= mid && s2 <= right) {
        if (array[s1] <= array[s2])
            tmp[k++] = array[s1++];
        else
            tmp[k++] = array[s2++];
    }
    // 3.将s1或s2剩下的填入
    while (s1 <= mid)
        tmp[k++] = array[s1++];
    while (s2 <= right)
        tmp[k++] = array[s2++];

    // 4.将临时数组拷贝入原始数组中
    for (int i = 0; i < k; i++) {
        array[i + left] = tmp[i];
    }
}

二叉树：结构性质、存储方式与遍历实现

Wed, 08 Apr 2026 00:00:00 GMT

1. 树型结构

1.1 了解树

形如图中的结构，称之为树型结构。实际上，数据结构的树 = 图论中的树 + 根节点 + 父子关系

对于数据结构中树的定义

树是由 n（n >= 0）个节点但组成的有限集合。

其中，树的一些基本概念有以下：

节点的度：一个节点含有子树的个数称为该节点的度；

树的度：一棵树中，所有节点度的最大值称为树的度；上图树的度为 3

叶子节点或终端节点：度为 0 的节点称为叶子节点；

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；

根节点：一棵树中，没有双亲节点的节点；

树的高度或深度：树中节点的最大层次；上图树的高度为 4

非终端节点或分支节点：度不为 0 的节点；

2.二叉树

2.1 二叉树的概念

二叉树是一个有限节点集合，满足：

可以是空集（空二叉树）

如果不为空，则由三部分组成：根节点（Root）、左子树（Left Subtree）、右子树（Right Subtree)

并且：左子树和右子树本身也是二叉树

2.1.1 特殊的两种二叉树

满二叉树：一棵二叉树，若每层的节点树都达到最大值，则这棵二叉树就是满二叉树。从数学关系上看，一颗二叉树的层数为 K，则节点总数为 2k- 1，则它就是满二叉树。
完全二叉树：除了最后一层外，其余各层都被完全填满，并且最后一层的节点从左至右连续排列，中间不能空缺

图像概念如下：

2.2 二叉树的性质

若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 2i-1(i>0)个结点
若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 2k - 1(k>=0)
对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
具有n个结点的完全二叉树的深度k为 log2(n+1) 上取整
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为 i 的节点有：
- 若 i > 0,双亲序号：(i - 1)/2; i = 0,i 为根节点编号，无双亲节点
- 若2i+1<n，左孩子序号：2i+1，否则无左孩子
- 若2i+2<n，右孩子序号：2i+2，否则无右孩子

例题：

已知：总共节点个数为 n 的完全二叉树，求叶子节点个数？

前提说明：公式n₀ = n₂ + 1、n₀ + n₁ + n₂ = n

我们做分类讨论

情况一： n 为偶数

完全二叉树中必有且仅有一个度为 1 的节点，即： n₁ = 1

代入性质，即n₀ + 1 + n₂ = n

结合n₀ = n₂ + 1：可得n₂ = (n - 2) / 2

综上， n₀ = n₂ + 1 = n / 2

情况二：n 为奇数

完全二叉树中不存在度为 1 的节点，即： n₁ = 0

代入性质，即n₀ + n₂ = n

结合n₀ = n₂ + 1：可得n₂ = (n - 1) / 2

综上，n₀ = n₂ + 1 = (n + 1) / 2

总结该过程就是以下公式：n₀ = ⌈n / 2⌉注意是向上取整

2.2.1 性质推导

对于性质 3，我们给出以下推导

已知：一棵 N 个节点的树有 N-1 条边，下标 1、2 分别代表度为 1，2 的节点能产生的边数：

n1:产生 n1-1 条边

n2:产生 2*n2 条边

n1+ 2*n2 = N - 1 方程式 1

n0 + n1+ n2 = N 方程式 2

联立解得：n2 + 1 = n0

2.3 二叉树的存储

二叉树的存储结构分为：顺序存储和链式存储；

2.3.1 二叉树的链式存储

二叉树的链式存储是通过一个个的节点引用起来的，常见的表示方式有二叉链表、三叉链表、线索二叉树表示方法；

链式存储使用情况：

形状不规则的普通二叉树
动态变化的二叉树
需要实现复杂逻辑的树

//二叉链表
class Node {
    int val; // 数据域
    Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
    Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}
// 三叉链表
class Node {
    int val; // 数据域
    Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
    Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
    Node parent; // 当前节点的根节点
}
// 线索二叉树
class Node {
    int val;
    ThreadedNode left;
    ThreadedNode right;
    
    // 标志位：0代表孩子，1代表线索（指向前驱/后继）
    int lTag; 
    int rTag; 
}

线索二叉树：

在普通的二叉链表中，一个拥有 n 个结点的二叉树会有 n+1 个空指针域。线索二叉树的核心思想就是利用这些空指针来存放结点在某种遍历序列中的“前驱”和“后继”信息，从而加快遍历速度.

实质就是：线索二叉树 = 用空指针存遍历顺序

线索树中的 right 可以类似理解为链表中的 next 可以向上走，也可以像普通二叉树一样往下找右子树走

ltag = 0 → 左孩子
ltag = 1 → 前驱（线索）

rtag = 0 → 右孩子
rtag = 1 → 后继（线索）

如中序遍历不用递归（线索树）

public void inorderTraverse(ThreadNode root) {
    ThreadNode cur = root;

    // 找到最左节点
    while (cur.ltag == 0) {
        cur = cur.left;
    }

    while (cur != null) {
        System.out.print(cur.val + " ");

        // 如果是线索 → 直接走后继
        if (cur.rtag == 1) {
            cur = cur.right;
        } else {
            // 否则去右子树找最左
            cur = cur.right;
            while (cur != null && cur.ltag == 0) {
                cur = cur.left;
            }
        }
    }
}

而将二叉树转为线索树需要用线索化方法将其转换，如下

public class ThreadedBinaryTreeDemo {

// 节点定义
static class ThreadNode {
    char val;
    ThreadNode left;
    ThreadNode right;

    int ltag; // 0 = 左孩子，1 = 前驱
    int rtag; // 0 = 右孩子，1 = 后继

    public ThreadNode(char val) {
        this.val = val;
    }
}

// 全局前驱指针
static ThreadNode pre = null;
// 递归过程中需要共享“上一个访问的节点”

// 中序线索化
public static void inorderThread(ThreadNode node) {
    if (node == null) return;

    // 1. 处理左子树（保证顺序：左→根→右）
    inorderThread(node.left);

    // 2. 处理当前节点

    // (1) 建立前驱线索
    if (node.left == null) {
        node.left = pre;
        node.ltag = 1;
    }

    // (2) 建立后继线索
    if (pre != null && pre.right == null) {
        pre.right = node;
        pre.rtag = 1;
    }

    // (3) 更新 pre（当前节点成为下一个节点的前驱）
    pre = node;

    // 3. 处理右子树
    inorderThread(node.right);
}

2.3.2 二叉树的顺序存储

顺序存储适合情况：

完全二叉树
满二叉树

顺序存储的核心是：使用数组来模拟二叉树的结构

就如前面性质所提到的：

左孩子：2 * i + 1

右孩子：2 * i + 2

顺序存储（数组下标） = 二叉树的层序遍历顺序

注：当且仅当是完全二叉树时

当不是完全二叉树时，其存储情况如此图

2.4 二叉树的基本操作

2.4.1 二叉树的三种遍历

1.前序遍历

    // 前序遍历
    public void preorderTree(TreeNode root) {
        if(root == null) return;
        System.out.print(root.val+" ");
        preorderTree(root.left);
        preorderTree(root.right);
    }

非递归方法如下：

思路

通过栈来存储当前节点的上一位

解题过程

将 root 赋给 cur，进入循环

循环中 cur 拿到节点就进行压栈并打印，随后向左移动

向左时一路压栈一路打印，直至 cur == null 时，再弹出前一个节点，将其右索引赋值给 cur 并将其进行循环（将 cur 视为另一子树的根节点即可理解）

    // 前序遍历非递归
    public void preorderNor(TreeNode root) {
        if(root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        // 循环判断cur的右侧是否有元素
        while(cur != null || !stack.isEmpty()) {
            // 循环往下遍历左侧元素
            while(cur != null) {
                stack.push(cur);
                System.out.print(cur.val + " ");
                cur = cur.left;
            }
            // cur为空，需要提出栈中一个元素
            TreeNode top = stack.pop();
            cur = top.right;
        }
    }

注意：中序遍历（非递归）与此一样，只是打印位置不同

复杂度

时间复杂度：O(N)

空间复杂度：O(N)（最坏）/ O(log N)（平均）/ O(1)（右单支树）

2.中序遍历

// 中序遍历
public void inorderTree(TreeNode root) {
    if(root == null) return;
    inorderTree(root.left);
    System.out.print(root.val+" ");
    inorderTree(root.right);
}

中序遍历非递归方法与前序遍历非递归类似，仅仅调换打印位置

// 中序遍历非递归
public void inorderNor(TreeNode root) {
    if(root == null) return;
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;

    // 循环判断cur的右侧是否有元素
    while(cur != null || !stack.isEmpty()) {
        // 循环往下遍历左侧元素
        while(cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        // cur为空，需要提出栈中一个元素
        TreeNode top = stack.pop();
        System.out.print(top.val + " ");
        cur = top.right;
    }
}

3.后序遍历

// 后序遍历
public void postorderTree(TreeNode root) {
    if(root == null) return;
    postorderTree(root.left);
    postorderTree(root.right);
    System.out.print(root.val+" ");
}

下面为非递归方法：

注意：

如上图，当 cur 走到 7 时，假设还存在右值“10”，直至走完 “10”，随后弹出 7，又会再次走到判断 7 是否存在右值，因此进入死循环。

为此，我们在循环外定义一个节点prev，以此来标记我们打印过的节点以避免死循环。加上if(top.right != null && top.right != prev)这条判断语句即可

思路

通过栈来存储当前节点的上一位

解题过程

思路延续前面的前序以及中序遍历的思想，仅在处理打印顺序时候需调整

    // 后序遍历非递归
    public void postorderNor(TreeNode root) {
        if(root == null) return;

        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode prev = null;
        while(cur != null || !stack.isEmpty()) {
            while(cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.peek();
            // 注意此处prev用来标记前一个元素是否有被打印
            if(top.right != null && top.right != prev) {
                cur = top.right;
            } else {
                System.out.print(top.val + " ");
                stack.pop();
                prev = top;
            }
        }
    }

复杂度

时间复杂度：O(N)

空间复杂度： O(N)（最坏） / O(log N)（最好）

2.4.2 二叉树的其他操作

1. 获取树中节点个数

// 左子树叶子个数 + 右子树叶子个数（子问题法）
public int getLeafNodeCount(TreeNode root){
    if(root == null) return 0;
    if(root.left == null && root.right == null) return 1;
    return getLeafNodeCount(root.left) + getLeafNodeCount(root.right);
}

2. 获取叶子节点个数

// 获取叶子个数（遍历法）
public static int count = 0;
public void getLeafNodeCount(TreeNode root) {
    if(root == null) return;
    if(root.left == null && root.right == null) {
        count++;
    }
    getLeafNodeCount(root.left);
    getLeafNodeCount(root.right);
}

3. 获取二叉树的高度

public int getHeight(TreeNode root) {
    if(root == null) return 0;
    return Math.max(getHeight(root.right)
            , getHeight(root.left)) + 1;
}

4. 层序遍历

public void levelOrder(TreeNode root) {
    if (root == null) return;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        System.out.print(cur.val + " ");
        
        if (cur.left != null) queue.offer(cur.left);
        if (cur.right != null) queue.offer(cur.right);
    }
}

二叉树 Oj 练习

此题是转换为循环链表

LCR 155. 将二叉搜索树转化为排序的双向链表 - 力扣（LeetCode）

144. 二叉树的前序遍历 - 力扣（LeetCode）

二叉搜索树与双向链表_牛客题霸_牛客网

102. 二叉树的层序遍历 - 力扣（LeetCode）

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

以上题解可参考另一篇文章~

堆与优先队列：建堆、调整与 Top K 问题

Wed, 08 Apr 2026 00:00:00 GMT

1.堆的概念

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质:

堆中某个节点的值总是不大于或不小于其父节点的值;
堆总是一棵完全二叉树;

2. 堆的存储方式

根据堆的概念可知,堆是一棵完全二叉树,因此可以按照层序规则采用顺序存储结构（数组）来高效存储。如上图上面部分的数组;

注意: 对于非完全二叉树,则不适用顺序方式进行存储因为为了能够还原二叉树,空间中就必要存储空节点,因此导致空间利用率底.

给部分内容设计二叉树部分性质,如下:

如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2

如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子

如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子

3. 堆的创建

3.1 堆的向下调整(大根堆/小根堆)

向下调整适用于 1. 建堆、2.删除堆顶元素、3.修改某个节点的值（变小时）

例:集合{ 27,15,19,18,28,34,65,49,25,37 }调整为大根堆

过程如下:

我们要从最后一个非叶子节点下手,因此我们选定 4 下标与其子树进行比较,因此 4 下标为 parent 索引,9 下标则为 child 索引

child > parent 则交换,child = parent 赋值,parent = (parent -1)/2 向上走

此刻 child > parent,重复步骤一随后得到 parent 为 0 索引

以上为一轮 for 循环,因此我们只需要对非叶子节点从后往前一步步循环换上去即可

代码实现如下:

/**
 * parent:usedSize-1为最后一位元素
 * (usedSize-2)/2 为求父节点公式
 */
// O(n)
public void createHeap() {
    for (int parent = (this.usedSize-2)/2; parent >= 0; parent--) {
        siftDown(parent,this.usedSize);    // parent逐步-1 根节点往上走
    }
}
/**
 * @param parent 每棵子树调整的时候 的 起始位置
 * @param usedSize 判断 每棵子树什么时候 调整 结束
 */
// 大根堆 -- 每棵树的根节点向下调
private void siftDown(int parent,int usedSize) {
    int child = 2 * parent + 1; // 求得左子节点所在位
    while(child < usedSize) {   //
        if(child + 1 < usedSize && elem[child] < elem[child + 1]) {
            child++;    // 若右子树存在且小于左子树，则找到右子树
        }
        if(elem[child] > elem[parent]) {    // 如果于它的根，则换
            swap(elem,child, parent);
            parent = child;     // 根节点向下移动，循环将下面的排好
            child = 2 * parent + 1; // 找根节点下面的左子树
        } else {
            break;  // 跳出循环
        }
    }
}
private void swap(int[] elem,int i, int j) {
    int tmp = elem[i];
    elem[i] = elem[j];
    elem[j] = tmp;
}

如若想改为调整为小根堆,只需要将代码中的 "<"和">"互换一下 即可,以上方法称为向下调整法

3.2 堆的向上调整(小根堆/大根堆)

向上调整常用于 1.插入新元素(放在数组末尾)、2.减小某个节点的值、3.删除节点后的调整

以插入新元素为例：

过程如下：

child 为插入元素索引，利用公式求得 parent 位置进行比较，若 child > parent；反之

child 与 parent 交替向上走

// 传入元素
public void offer(int val) {
    if(isFull()) {
        elem = Arrays.copyOf(elem, 2*elem.length);
    }
    elem[usedSize] = val;
    siftUp(usedSize);
    usedSize++;
}
private boolean isFull() {
    return elem.length == usedSize;
}
public void siftUp(int child) {
    int parent = (child - 1)/2;
    while(child > 0) {  // 当 child 不是根节点时继续
        if(elem[child] > elem[parent]) {
            swap(elem,child,parent);
            child = parent;
            parent = (parent-1)/2;
        } else {
            break;
        }
    }
}

topK 问题

topK 问题：有 N 个元素，找出前 K 个最小元素

做法：

方法一：整体排序

方法二：整体建立一个大小为 N 的小根堆

方法三：把前 K 个元素创建为大根堆，遍历剩下的 N-K 个元素，和堆顶元素比较，如果比堆顶元素小，则堆顶元素删除，当前元素入堆

在此，我们以最优最常用的方法三来分析：

思路如图中所述，因为只要数组元素小于前 k 个的最大值，一次次将每一次的最大值挤出该而队列中，去插入更小的元素，此处我们调用比较器去重写 compare 方法

注意：

优先级队列背后的 compare 默认是调整为小根堆，因此我们需要将其重写，调整为大根堆

// 创建比较器
class IntCmp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        // 当 o2 < o1 时，o1 会被放在堆顶方向
        // 修改默认小根堆改为大根堆
        return o2.compareTo(o1);
    }
}

// 与大根堆比较
public static int[] smallestK(int[] arr,int k) {
    // 创建返回数组
    int[] ret = new int[k];
    if(arr == null || k == 0) return ret;
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(k,new IntCmp());
    // 取出k个元素建立二叉树
    for (int i = 0; i < k; i++) {
        priorityQueue.offer(arr[i]);
    }
    // 遍历N - K个元素比较
    for (int i = k; i < arr.length; i++) {
        // 如果小于堆顶元素，则放入元素，删除堆顶元素
        int peekValue = priorityQueue.peek();
        if(arr[i] < peekValue) {
            priorityQueue.poll();
            priorityQueue.offer(arr[i]);
        }
    }
    // 取出前K个元素
    for (int i = 0; i < k; i++) {
        ret[i] = priorityQueue.poll();
    }
    return ret;
}

顺序表与链表：ArrayList、LinkedList 的原理与实现

Fri, 27 Mar 2026 00:00:00 GMT

图片来自于菜鸟教程

1.List 引入

1.什么是 List

在了解 ArrayList即顺序表 (Sequential List) 与 LinkedList即双向链表 (Doubly Linked List) 之前，有必要先明 List是什么。

List 是一个接口，其继承自 Collection，类似可以理解为“合同”。它规定了所有子类需要具备的功能：索引访问 get(i)、插入元素 add、删除元素 remove 等功能。

List 与 ArrayList、LinkedList 的关系

List 首先是一个接口（可理解为合同），而 ArrayList、LinkedList 则是它的实现类（可理解为员工在合同下工作）。也就是说，ArrayList、LinkedList 两个类都需要重写 List 中的方法。

2.ArrayList 的理解

2.1 什么是 ArrayList

先从图片上引入对 ArrayList 的概念，其实就是数组

ArrayList 中文称为顺序表，

从物理意义上：它是用一段连续的物理内存（数组）来表达线性关系的。

从源码上看主要是这几个常量，包括容量，数组，实际大小usedSize...

2.2 ArrayList 的模拟实现

2.2.1 实现 MyArrayList 类

我们尝试模拟实现一下 ArrayList 的主要功能，定义一个 MyArrayList 类

具体代码可访问GitHub远程仓库

首先创建一个模拟 IList 接口，根据接口定义的方法以及 ArrayList 的源码去模拟实现MyArrayList 类

public interface IList {
    // 新增元素,默认在数组最后新增
    public void add(int data);
    // 在 pos 位置新增元素
    public void add(int pos, int data);
    // 判断数组是否已满
    public boolean isFull();
    // 判定是否包含某个元素
    public boolean contains(int toFind);
    // 查找某个元素对应的位置
    public int indexOf(int toFind);
    // 获取 pos 位置的元素
    public int get(int pos);
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value);
    //删除第一次出现的关键字key
    public void remove(int toRemove);
    // 获取顺序表长度
    public int size() ;
    // 清空顺序表
    public void clear();
    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    public void display() ;
}

MyArrayList 类有以下变量及构造方法

public class MyArrayList implements IList{
    public int[] array;
    public int usedSize;
    public static final int DEFAULT_CAPACITY = 10;

    public MyArrayList(){
        array = new int[DEFAULT_CAPACITY];
    }
}

由于 ArrayList 官方源码是适配多种类型而使用泛型，我们为方便理解就从整型去创建。

其涉及的相关题目可以有杨辉三角的实现，简单的洗牌算法参考源码，了解完之后就对 ArrayList 有初步理解了

2.3ArrayList 的局限性

由于 ArrayList 底层代码是一段连续空间，当在 ArrayList 任意位置插入或者删除元素时，就需要将后续元素整体往前或者往后搬移，时间复杂度为 O(n)，效率较低。

3.链表与 LinkedList

3.1 链表的概念

链表是物理存储结构上非连存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。每个节点存储了当前节点的 value 以及对下一个节点的索引

其结构类似图中内容

实际中链表结构又是多样的：

单项或者双向
带头或者不带头
循环或者非循环

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

因此我们以单向无头非循环链表举例。

3.2 链表的模拟实现

3.2.1 自创 MySingleList 类

实现的代码可访问该链接 -> 参考源码

我们同样可以实现上面的 IList 接口，其变量、内部类以及构造方法有以下

public class MySingleList implements IList{
    // 创建整个链表中的各个节点（车厢）
    static class ListNode {
        public int val;
        public ListNode next;	// 对下一个节点的索引
        // 初始化各个节点
        public ListNode(int val) {
            this.val = val;
        }
    }
    // 存储头节点引用（火车头）
    public ListNode head;
}

主要方法有头插法 addFirst()、尾插法 addLast()、任意位置插入 addIndex()、是否包含 contains()、删除节点 remove()等等

我们选部分了解：

头插法：

public void addFirst(int data) {
    ListNode node = new ListNode(data);
    node.next = this.head;
    this.head = node;    
}

即在头节点前插入，时间复杂度为 O(1)，而 ArrayList 中为 O(n)

尾插法：

public void addLast(int data) {
    ListNode node = new ListNode(data);
    if(this.head == null){
        this.head = node;
        return;
    }
    ListNode cur = this.head;
    // cur.next != null可以走到倒数第二个节点
    // 但最后一个节点地址可获取
    while(cur.next != null){
        cur = cur.next;
    }
    cur.next = node;
}

即在最后节点插入，注意最后节点的 next 必须置空

另外补充，官方在链表中增加新节点是默认使用尾插

删除节点：

@Override
public void remove(int key) {
    if(this.head == null){
        return;
    }
    if(this.head.val == key){
        this.head = this.head.next;
        return;
    }
    // 创建当前节点cur
    ListNode cur = FindNodeBeforeKey(key);
    cur.next = cur.next.next;
}

// 查找到删除节点前的一个节点
private ListNode FindNodeBeforeKey(int key){
    // 创建当前节点
    ListNode cur = this.head;
    // cur要每一个都走一遍
    while(cur.next != null){
        if(cur.next.val == key){
            return cur;
        }
        cur = cur.next;
    }
    return null;
}

利用删除节点的前一节点访问到删除节点的 val 值去匹配 key，以及当前节点 cur 的 next 索引的修改

3.3 单链表相关的 OJ 面试题

删除链表中等于给定值 val 的所有节点。Leecode 移除链表元素
反转一个单链表。Leecode 反转一个单链表
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。Leecode 链表的中间节点
输入一个链表，输出该链表中倒数第k个结点。 Leecode 返回倒数第k个节点
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。Leecode 合并两个有序链表
编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。Leecode 分割链表
链表的回文结构。Leecode 回文链表
输入两个链表，找出它们的第一个公共结点。Leecode 相交链表

9.给定一个链表，判断链表中是否有环。Leecode 环形链表

尝试上面的 Oj 题后，相信你对链表有自己的见解了，以上 Oj 题我会同步发出题解文章

3.4 LinkedList 的结构

LinkedList 的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

以下图片即为双向链表结构，包含了 val、prev 前驱、next 后驱以及 head 头指针和尾指针

通过以下集合框架可以发现，LinkedList 也同样实现了 List 接口：

说明：

1.LinkedList 实现了 List 接口

2.LinkedList 的底层使用了双向链表

3.LinkedList 没有实现 RandomAccess 接口，因此 LinkedList 不支持随机访问

4.LinkedList 的任意位置插入和删除时效率比较高，时间复杂度为 O(1)

5.LinkedList 比较适合任意位置插入的场景

3.5 LinkedList 的模拟实现

3.5.1 实现 MyLinkedList 类

和 ArrayList、单向链表一样，同样实现 List 接口，在此我们就模拟实现 IList 接口

public class MyLinkedList implements IList {
    // 内部类-各个节点
    class ListNode{
        public int val;
        public ListNode prev;	// 前驱
        public ListNode next;	// 后驱

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode last;
}

与链表类似，但删除时不再需要提前一个节点，我们可直接到要删除的节点位置

remove() - 删除方法：

@Override
public void remove(int key) {
    ListNode cur = head;
    while(cur != null){
        if(cur.val == key){
            //删除在开头
            if(cur == head){
                head = head.next;
                if (head != null) {
                    // 情况 A: 至少还有两个节点，现在的 head 指向原第二个节点
                    head.prev = null;
                } else {
                    // 情况 B: 原本只有一个节点，删完后 head 为 null
                    // 必须同步清理 last
                    last = null;
                }
            } else{
                //删除在其他（中间、结尾）
                cur.prev.next = cur.next;
                if(cur.next == null){
                    last = last.prev;  // 该情况为删除在结尾
                } else{
                    cur.next.prev = cur.prev;
                }
            }
             return;
        }
        cur = cur.next;
    }
}

如代码中注释，删除位置首先分为两处--

开头、2. 中间和结尾

随后依次在分类讨论情况，其常用方法与 ArrayList 类似

3.6ArrayList、链表、LinkedList 关系

线性表 (Linear List) —— “我们要排成一队” (逻辑协议)

├── 顺序表 (Sequential List) —— “大家必须坐连排座” (底层是数组)

└── 链表 (Linked List) —— “大家随便坐，手拉手就行” (底层是节点)

├── 单向链表 —— “只知道后面是谁”

└── 双向链表 —— “既知道前面，也知道后面”

概念名称	属于什么	物理结构	在 Java 中的“肉身”
顺序表	线性表的一种实现	连续数组	ArrayList
链表	线性表的一种实现	分散节点 + 指针	LinkedList
链表节点	链表的组成零件	包含数据和指针的对象	ListNode类

以上是我关于Java的笔记分享

感谢你读到这里，这也是我学习路上的一个小小记录。希望以后回头看时，能看到自己的成长~

栈与队列：核心操作、循环队列与典型应用

Fri, 27 Mar 2026 00:00:00 GMT

1.栈 Stack

1.1 栈？

栈：是一种特殊的线性表，他只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的元素遵循先进后出的原则。

压栈：数据进入栈中称为进栈/压栈/入栈

出栈：栈的删除操作叫做出栈

其概念图如下：

1.2 队列的三种实现

栈的方法不多，我们可以查看查看 Stack 源码中的方法

其方法说明如下

方法	返回类型	功能
push(E e)	E	将 e 入栈，并返回 e
pop()	E	将栈顶元素出栈并返回
peek()	E	获取栈顶元素
size()	int	获取栈中有效元素个数
empty()	boolean	检测栈是否为空

Java 中栈的常见实现有三种：

实现方式	备注
Stack	老旧，但线程安全（带锁），性能相对较低
ArrayDeque	非线程安全，性能极高
LinkedList	可当作栈使用，但作为栈使用时，性能通常略逊于ArrayDeque

要想了解栈，模拟栈的实现是很有必要的

package myStack;
import exception.EmptyStackException;
import java.util.Arrays;

public class MyStack {
    public int[] elem;
    public int usedSize;

    public MyStack() {
        this.elem = new int[10];
    }

    public void push(int val){
        if(isFull()){
            this.elem = Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize++] = val;
    }

    public boolean isFull(){
        return usedSize == elem.length;
    }

    public int pop(){
        if(isEmpty()){
            throw new EmptyStackException("栈中元素为空");
        }
        int val = elem[usedSize - 1];   //取得栈中的最后值
        usedSize--;    //取消对最后值的索引
        return val;
    }

    public int peek(){
        if(isEmpty()){
            throw new EmptyStackException("栈中元素为空");
        }
        return elem[usedSize - 1];
    }

    public boolean isEmpty(){
        return usedSize == 0;
    }

    public int search(int val){
        for (int i = usedSize - 1;i >= 0;i--) {
            if(elem[i] == val){
                // 返回距离栈顶的距离。栈顶本身返回 1，其下方返回 2，以此类推
                return usedSize - i;
            }
        }
        return -1;
    }
}

代码可详见于远程仓库

1.3 Stack 典型 Oj 题

20. 有效的括号 - 力扣（LeetCode）

150. 逆波兰表达式求值 - 力扣（LeetCode）

Leecode 最小栈

Leecode 用队列实现栈

Leecode 用栈实现队列

有效的括号

对于此题，我们可以先创建几个例子，如([])、([)]、(()据此可以构建该模型。

既然是要左括号匹配右括号，我们可以思考，假设先遇到左括号正常返回 true 的例子，并能够以 最近遇到的左括号 去匹配 右括号，只能是通过 栈（Stack） 这个数据结构来完成了

（从左至右）如图 1

遍历字符串，if {先遇到左括号，push 压栈；}

else {遇到右括号，

if{ stack 为空，返回 false 结束}

else {栈不为空,peek()匹配，如匹配则 pop()弹出，否则 false}

}

注：以上为此题抽象思路,但稍有不足，假设左括号过多（如图三），我们还需最后检查栈是否为空

// 有效的括号
public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (int i = 0; i < s.length(); i++) {
        char ch = s.charAt(i);
        if(ch == '(' || ch == '[' || ch == '{') {
            // 如果匹配，进行压栈
            stack.push(ch);
        } else{
            if(stack.empty()) {
                return false;
            }
            // 若不为空，继续判断是否匹配
            char ch2 = stack.peek();
            // 从栈中取出元素,即不走上面的if了，为右括号
            if(ch == ')' && ch2 == '('
                    || ch == '}' && ch2 == '{'
                    || ch == ']' && ch2 =='['){
                stack.pop();
            }else {
                // 若不匹配上述
                return false;
            }
        }
    }
    //处理匹配完右括号后，左括号是否多出来
    if(!stack.empty()){
        return false;
    }
    return true;
}

逆波兰表达式求值

我们先简单了解以下波兰表达式概念，如下

给出一个中缀表达式：a + b * c + (d * e + f) * g,

转换为后缀表达式：a b c * + d e * f + g * +.

其转换过程如下：将以下每个运算符号都放在括号中，

随后将每个运算符号移除当前所处的括号外，得到

将括号去掉便得到我们的后缀表达式了，而如何按照原先规则运算就是我们这次讲的题了

输入：tokens = ["2","1","+","3","*"]

输出：9

解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

题目给出这样一个示例，可以想到每遍历到操作数就提取两个数字

根据上述思路，我们可以想到用栈来存储每次遍历时遇到的数字，当遇到运算符时，就弹出栈顶的两个元素进行该运算符的计算

注：注意两个数字的位置不要搞错！第一个数字是右操作数，第二个数字是左操作数

由上述思路得出

// 逆波兰表达式求值
public int evalRPN(String[] tokens) {
    Stack<Integer> stack = new Stack<>();
    // 遍历字符串
    for(String x : tokens){
        // 匹配是否是操作符号
        if(!isOperator(x)){
            // 如果是数字就压栈
            int num = Integer.parseInt(x);
            stack.push(num);
        } else{
            // 不是数字就运算
            int val2 = stack.pop();
            int val1 = stack.pop();
            switch(x){
                case"+":
                    stack.push(val1+val2);
                    break;
                case"-":
                    stack.push(val1-val2);
                    break;
                case"*":
                    stack.push(val1*val2);
                    break;
                case"/":
                    stack.push(val1/val2);
                    break;
            }
        }
    }
    return stack.pop();
}

private boolean isOperator(String ch){
    if(ch.equals("+") || ch.equals("-")
            || ch.equals("*") || ch.equals("/")){
        return true;
    }
    return false;
}

1.4 栈、虚拟机栈、栈帧的区分

栈

由本节知道，栈是一种数据结构，遵循先进后出的原则

虚拟机栈

虚拟机栈是 JVM 的一块运行时内存区域

其中，虚拟机栈 = 每个线程私有的调用栈

虚拟机栈主要存的就是我们要说的栈帧

栈帧

栈帧是方法运行时的数据结构，即每次方法调用产生的数据单元

也就是说：每调用一个方法 -> 创建一个栈帧

一个栈帧里通常包含：局部变量表、操作数栈、动态链表、方法返回地址

2.队列 Queue

2.1 什么叫队列

队列：只允许在队尾进行元素插入，在队头进行元素删除的一种特殊线性表，队列遵循先进先出的原则。

对于队列的概念我们可以抽象理解为如下图，类似倒置的栈，但与栈不同

2.2 如何使用队列

java 中，队列与栈不同的是，栈是一个类，而队列是一个接口。

因此我们实现队列的时候就不能像栈一样 new 一个它本身，而是要通过常用的LinkedList(双向链表)、ArrayDeque(动态数组)、PriorityQueue(堆)...实现类来实现。

Queue<Integer> q = new LinkedList<>();
Queue<Integer> q = new ArrayDeque<>();
Queue<Integer> q = new PriorityQueue<>();
...

队列 Queue 的结构如下

队列的基本操作方法：

方法	功能
boolean offer(E e)/add(E e)	入队 enqueue
poll()/remove(): E	出队 dequeue
peek()/element(): E	查看队头
boolean isEmpty()	检查队列是否为空
int size()	获取队列中的有效元素个数

其中，isEmpty() size()这两个方法是定义在父类 Collection 中。

另外上面存在两种一样功能的方法区别差异不大

2.3 模拟实现队列 Queue

在了解完队列的方法后，进一步学习其方法，加深对队列的理解

补充：

顺序结构

数据在内存中连续存储

链式结构

数据在内存中不需要连续，每个元素通过指针（应用连接起来）

在前面学习完的顺序结构（数组、ArrayList...）和链式结构（LinkedList、单链表...）之后，对于队列的实现，我们在后面会说明使用哪个实现会更好

队列的方法十分简单，代码如下，没有很复杂的逻辑。

public class MyQueue {

    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode first = null;
    public ListNode last = null;
    public int usedSize = 0;

    // 入队列（尾入）
    public void offer(int val) {
        ListNode node = new ListNode(val);
        if(isEmpty()) {
            first = last = node;
        } else {
            last.next = node;
            node.prev = last;
            last = last.next;
        }
        usedSize++;
    }

    // 出队列（头出）
    public int poll() {
        if(isEmpty()) {
            return -1;
        }
        int val = first.val;
        first = first.next;
        if(first != null) {
            // 将first的前驱置空
            first.prev = null;
        }
        usedSize--;
        return val;
    }

    // 获取队头元素
    public int peek() {
        if(isEmpty()) {
            return -1;
        }
        return first.val;
    }

    public boolean isEmpty() {
        return usedSize == 0;
    }
}

从逻辑上，顺序结构（数组）、链式结构（单、双链表）都可以实现队列 Queue。

我们可以对比一下

1.数组实现

队头需要 front 标记，队尾需要 rear 标记

必须使用循环数组才能充分利用空间

时间复杂度

入队： O(1)

出队： O(1)

随机访问：O(1)

可以发现其优/缺点：

优：内存连续，空间占用少、随机访问快

缺：必须事先指定数组容量或动态扩容

2.单链表实现

队头 head 指向队头节点，last 指向队尾节点

入队采用尾插法

出队可删除头节点

注：就算有尾节点的标记，也不能从头节点入队，因为删除还是需要找对后一个节点的前一个节点

时间复杂度

入队： O(1)

出队： O(1)

随机访问：O(n)

3.双链表实现

与单链表相同

队头 head 指向队头节点，last 指向队尾节点

入队采用尾插法

出队可删除头节点

时间复杂度

入队： O(1)

出队： O(1)

随机访问：O(n)

但是双链表可以双向遍历，支持在两端操作

特性	数组	单链表	双链表
存储	连续	不连续	不连续
内存占用	少	中	多
入队/出队	O(1)	O(1)	O(1)
随机访问	O(1)	O(n)	O(n)
是否需要扩容	是（或固定容量）	否	否
CPU缓存友好	高	低	低
适用场景	高性能、容量固定或可扩容	容量不确定、出入队灵活	双端操作、容量不确定

2.4 循环队列

循环队列：是顺序队列的一种优化，它解决了顺序队列出对后空间浪费的问题。

普通顺序队列：出队后，队头向后移动，数组前面出现空闲空间，但无法复用

循环队列：把数组看作环形，当 rear 到达数组末尾时，如果前面有空余位置，就可以回到数组开头继续存放元素

对于循环队列，我们给出以下定义

队列用数组存储
front 指向队头
rear 指向队尾的下一个位置

由此，我们可以得到循环公式

入队时：rear = (rear + 1) % capacity

出队时：front = (front + 1) % capacity

队列满条件：(rear + 1) % capacity == front

队列空条件：rear == front

对于循环数组判断是否已满有三种方法

通过添加 usedSize 属性记录

保留一个位置

使用标记，定义 boolean 类型元素

我们拿第三个标记法举例

// 使用不浪费空间方法
class MyCircularQueue{
    public int front;
    public int rear;
    public int[] elem;
    private boolean isFullFlg;
    public MyCircularQueue(int k) {
        elem = new int[k];
        front = 0;
        rear = 0;
        isFullFlg = false;
    }
    // 入队
    public boolean enQueue(int value) {
        if(isFull()) {
            return false;
        }
        elem[rear] = value;
        rear = (rear + 1) % elem.length;    // rear往后移一位
        if(rear == front) {
            isFullFlg = true;
        }
        return true;
    }
    // 出队
    public boolean deQueue() {
        if(isEmpty()) {
            return false;
        }
        front = (front + 1) % elem.length;  // front往后移一位
        isFullFlg = false;  // 只要成功出队，则队列不可能满
        return true;
    }

    // 返回front指向的元素
    public int Front() {
        if(isEmpty()) return -1;
        return elem[front];
    }

    // 返回rear指向的元素
    public int Rear() {
        if(isEmpty()) return -1;
        int index = (rear == 0) ? elem.length - 1 : rear - 1;
        return elem[index];
    }

    public boolean isEmpty() {
        return (rear == front) && !isFullFlg;
    }

    public boolean isFull() {
        return isFullFlg;
    }
}

622. 设计循环队列 - 力扣（LeetCode）

2.5 双端队列 Deque

Deque = Double Ended Queue

双端队列是指允许两端都可以进行入队和出队操作的队列。即说明元素可从队头出入队，也可以从队尾出入队。

双端队列可以用 顺序结构 或 链式结构 实现

Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现

以上是我关于Java的笔记分享

感谢你读到这里，这也是我学习路上的一个小小记录。希望以后回头看时，能看到自己的成长~

算法复杂度：大 O 表示法、时间空间分析与平均情况

Fri, 13 Mar 2026 00:00:00 GMT

算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称为空间复杂度，时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间。

1.时间复杂度

1.1 什么是时间复杂度

算法的时间复杂度是算法执行步骤数量随输入规模 n 增长的趋势，在程序中常用大 O 渐进表示法来表示。

而之所以用大 O 表示法的原因是：

当 n 足够大时

低阶项和常数项影响可以忽略

决定性能的是“最高阶项”

1.2 常见特殊的时间复杂度计算举例

【示例 1】

//计算binarySearch二分查找法的时间复杂度？
int binarySearch(int[] array, int value) {
    int begin = 0;
    int end = array.length - 1;
    while (begin <= end) {
        int mid = begin + ((end-begin) / 2);
        if (array[mid] < value)
            begin = mid + 1;
        else if (array[mid] > value)
            end = mid - 1;
        else
            return mid;
    }
    return -1;
}

最坏情况是：一条直线，一直被不断的分为 1/2，最终分成只剩一个，其推导过程如下

第一次：n/2^1

第二次：n/2^2

第三次：n/2^3...

第x 次：n/2^x -> n/2^x = 1 -> x = log2N，最终时间复杂度为 O(log2N)

【示例 2】

//计算阶乘递归factoria的时间复杂度？
long factorial(int N){
    return N<2 ? N:factorial(N-1)*N;
}

计算公式：递归的时间复杂度 = 递归的次数 * 每次递归执行的次数

该样例计算即：

当 N = 1,时则不再递归，因此递归次数即为 N - 1，

而每次递归执行的语句为三目运算符语句，其执行次数可视为 1，因此为 O(N)

【示例 3】

//计算斐波那契递归fibnacci的时间复杂度？
int fibnacci(int N){
    return N<2 ? fibnacci(N-1)+fibnacci(N-2);
}

以上为粗略计算过程，因此其递归次数就为等比数列求和即可，最终为 O(2^n)

1.3 计算时间复杂度的平均情况

时间复杂度平均情况是：在所有可能输入中，按每种输入出现的概率加权后，算法执行时间的数学期望。

其公式表达情况为：

Ti(n)：第 i 种情况的执行步数

Pi：该情况发生的概率

∑ Pi=1

我们举一个范例，比如线性查找 target：

for (int i = 0; i < n; i++) {
    if (arr[i] == target) return i;
}
return -1;

情况	target 位置	比较次数
第 1 个	0	1
第 2 个	1	2
...	...	...
第 n 个	n-1	n
不存在	—	n

常见合理假设：

target 在数组中等概率出现

每个位置概率为 1/n1/n1/n

或包含“不存在”的情况

计算数学期望：

利用等差数列公式：

最终时间复杂度为 O(n)

2.空间复杂度

2.1 什么是空间复杂度

空间复杂度是：算法在执行过程中，额外占用的内存空间随输入规模 n 增长的趋势

因为在比较算法的时候，面对的是同一份输入，因此不关心算法本身的空间，而只为分析算法为了运行“多申请了多少空间”

以后常遇到的复杂度有：O(1) < O(log2N) < O(N) < O(N*log2N) < O(N2)

其判断复杂度方法与时间复杂度类似，参考时间复杂度即可

Java 包装类与泛型：装箱拆箱、类型擦除与边界约束

Fri, 13 Mar 2026 00:00:00 GMT

1. 包装类

1.1 基本数据类型和其对应的包装类

Java 为了把基本数据类型当作“对象”来使用，专门提供的一组类。

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

1.2 装箱与拆箱

装箱（装包）：把基本数据类型变成包装类类型的过程叫做装箱（装包）。

装箱又分为自动装箱和手动装箱

实际自动装箱底层逻辑还是手动装箱

public class Demo{
    public static void main(String[] args) {
        int a = 100;
        //手动装箱
        Integer ia = Integer.valueOf(a);
        Double da = Double.valueOf(a);
        System.out.println(ia);
        System.out.println(da);

        //自动装箱
        Integer iia = a;
        Double dda = (double) a;
        System.out.println(iia);
        System.out.println(dda);
    }
}

拆箱（拆包）：把包装类类型变成基本数据类型的过程就叫做拆箱（拆包）。

拆箱也分为自动拆箱和手动拆箱

实际自动拆箱底层逻辑还是手动拆箱

public class Demo{
    public static void main(String[] args) {
        Integer ia = 100;
        //手动拆箱
        int a = ia.intValue();
        double d = ia.doubleValue();
        System.out.println(a);
        System.out.println(d);

        //自动拆箱
        int iia = ia;
        double da = ia.doubleValue();
        System.out.println(iia);
        System.out.println(da);
    }
}

1.3 Integer 缓存机制

public class Demo {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b);//true
        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d);//false
    }
}

以上代码中涉及的是自动装包，结果的原因：

Integer.valueOf()会缓存 [-128,127]

在这个范围内：返回同一个对象

超出范围：新对象

我们可以查看 Integer 源码中的valueOf()方法

我们可以看出自动装包输入的 i 在其中是个数组的范围，我们可以查看到 IntegerCache 这样一个类中设定了 low = -128,而high最终被h = 127所赋予，因此得到该缓存数组范围 [-128,127]

我们再思考返回的数组内容，IntegerCache.cache[i + (-IntegerCache.low)]，我们就拿 i = 100代入

而我们通常比较“值”的方法是使用a.equals(b)

2.泛型

泛型就是把“类型”当作参数，在编译期确定下来的一种机制。

其作用是 1、解决“类型不安全”问题，2、消除强制类型转换（向下转型），3、提高代码复用能力

2.1 使用语法

泛型类

列举样例：

class 泛型类名称<>{
//可使用类型参数
}

class ClassName<T1,T2,...,Tn>{
}

class 泛型类名称<类型形参列表>extends 继承类/*此处可使用类型参数*/{
}

class ClassName<T1,T2,...,Tn> extends ParentClass <T1>{
}

举例：

class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

使用如下：

Box<String> box = new Box<>();
box.set("hello");
String s = box.get();

说明：T在定义类时只是占位；在创建对象时才是真正确定类型

泛型方法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

public static <T> T getFirst(T[] arr) {
    return arr[0];
}

解释：

<T>：位于返回值之前，表示该方法定义了一个泛型类型参数 T

T：表示这个方法返回值的类型是T

使用如下：

Integer i = getFirst(new Integer[]{1, 2});
String s = getFirst(new String[]{"a", "b"});

泛型接口

interface Mapper<T> {
    T map(T input);
}

实现方式一（实现时确定类型）：

class StringMapper implements Mapper<String> {
    public String map(String input) {
        return input.toUpperCase();
    }
}

实现方式二（实现时仍保留泛型）：

class DefaultMapper<T> implements Mapper<T> {
    public T map(T input) {
        return input;
    }
}

2.2 泛型的”本质机制“

2.2.1 泛型只存在编译期

Java 的泛型是”伪泛型“

比如：

ArrayList<String>
ArrayList<Integer>

在 JVM 看来都是：

ArrayList

2.2.2 类型擦除

编译过程中，将所有的 T 替换为 Object 这种机制称为：擦除机制

java 的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

ArrayList<String> list = new ArrayList<>();

编译后等价于：

ArrayList list = new ArrayList();

只是编译器偷偷加了强制类型检查和转换。

因此对于两个问题：

1、那为什么，T[] ts = new T[5]; 是不对的，编译的时候，替换为Object，不是相当于：Object[] ts = new Object[5]吗？ 

2、类型擦除，一定是把T变成Object吗？

问题一：

首先 java 编译器不允许这样写，原因不是语法，而是在于类型安全。

因为数组是运行期类型检查的，数组在运行期知道自己真实的元素类型。

另外，泛型是编译期类型检查的，在运行期就已经被删除了，所以 JVM 运行期并不知道元素类型

举例：

假如T[] ts = new T[5];允许

class Box<T> {
    T[] ts = new T[5]; // 假设合法
}

Box<String> box = new Box<>();
Object[] arr = box.ts; // 数组协变，合法
arr[0] = 100;          // 编译通过

首先 arr是Object[]，放Integer是合理的

但box.ts逻辑上应该是String[]，而且编译器也完全无法阻止这个错误

对于问题二：

不一定。无边界泛型 -> 擦除成 Object，因为没有任何约束，最安全的上界就是Object

如果有上界泛型 -> 擦除成”上界类型“，方法级的泛型同理

举例如下：

public <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

擦除后：

public Comparable max(Comparable a, Comparable b) {
    return a.compareTo(b) > 0 ? a : b;
}

另外，对于类型擦除还有许多可以了解的地方

1.泛型信息不会进入 JVM 的方法签名中，也就是说不存在重载

2.数组协变+泛型不变

2.3 泛型的上界

泛型上界：

限制泛型参数”最多能是什么类型“，并向编译器承诺：他至少具备某个父类或接口的能力。

使用语法：

class 泛型类名称<类型参数 extends 类型边界> {
}

这里的extends既表示继承，也表示实现接口。

举个例子：

class Box<T extends Number> {
    T value;

    void print() {
        value.intValue();
    }
}

如果没有extends Number，那么编译器只知道T是Object，Object没有intValue().

但是加上之后，就相当于上界告诉了编译器：T至少是Number，Number定义了intValue()

Java 异常处理：异常体系、传播机制与自定义异常

Mon, 17 Nov 2025 00:00:00 GMT

1.了解异常

1.1 初步认识异常，了解 Exception 家族

在任何代码中，错误以及意外是不可避免的——除数为零，文件路径不正确，非法输入...既然知道存在这种情况，我们就需要提前预防。

因此 Java 的异常处理机制就应运而生。通过抛出异常（throw）、声明异常（throws）和捕获异常（try-catch），实现从错误检测到错误恢复的完整流程。

常见异常：

System.out.println(10/0);
//ArithmeticException 算数异常

int[] arr = {1,2,3,4,5};
System.out.println(arr[10]);
//ArrayIndexOutOfBoundsException 数组越界异常

int arr = null;
System.out.println(arr.length);
//NullPointerException 空指针异常...

事实上，异常又分为编译时异常（受检异常 CheckedException)，运行时异常（非受检异常 UncheckedException）。

编译时异常：

1.编译阶段就会被检查，必须显式处理，否则编译不通过。

2.表示“可预料错误”，如：“文件不存在”、“网络中断”、“数据库连接失败”...

特点：

编译器要求：要么 try-catch 捕获，要么在方法上 throws 声明

运行时异常：

1.运行时才可能发生，编译器不会强制要求处理。

2.表示“程序包逻辑错误或无法预料的问题”。

特点：

通常是开发者的逻辑错误导致的，不建议用 try-catch 去包，而是应修正逻辑。

这里我们先了解下他们的继承关系，如下图

我们可以了解到：

Throwable是异常体系的根，他继承自Object。Throwable有两个体系：Error和Exception

Error表示严重的错误，程序对此一般无能为力，错误不是异常，而是脱离程序控制的问题 eg：

OutOfMemoryError：内存耗尽

NoClassDefFoundError：无法加载某个 Class

StackOverflowError：栈溢出

Exception则是运行时的错误，它可以被捕获并处理。

某些异常是应用程序逻辑处理的一部分，应该捕获并处理。eg：

NumberFormatException：数值类型的格式错误

FileNotFoundException：未找到文件

SocketException：读取网络失败

2. 处理异常

2.1 防御式编程

先了解一下什么是防御式编程，以便让我们更好的了解如何处理异常

防御式编程（Defensive Programming） 是一种编程思想，指在写代码时假设“可能出错”，并提前在程序中检测、预防、或妥善处理这些潜在错误，以防止程序在异常情况下崩溃或产生错误结果

简单理解：
👉 就像司机开车时随时准备刹车，而不是等撞上去再想办法

我们可以举一个例子进行对比：

普通写法（无防御）

import java.io.*;

public class Example1 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("data.txt");  // 假设文件存在
        BufferedReader br = new BufferedReader(fr);
        System.out.println("第一行内容是：" + br.readLine());
        br.close();
    }
}

防御式编程

import java.io.*;

public class Example2 {
    public static void main(String[] args) {
        String filePath = "data.txt";
        File file = new File(filePath);

        // ① 防御：检查文件是否存在
        if (!file.exists()) {
            System.err.println("错误：文件不存在 → " + filePath);
            return;
        }

        // ② 防御：检查是否是普通文件（防止是目录）
        if (!file.isFile()) {
            System.err.println("错误：" + filePath + " 不是一个有效文件");
            return;
        }

        // ③ 使用 try-with-resources，自动关闭流
        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
            String firstLine = br.readLine();

            // ④ 防御：检查文件是否为空
            if (firstLine == null) {
                System.err.println("提示：文件为空，没有任何内容。");
                return;
            }

            System.out.println("第一行内容是：" + firstLine);

        } catch (IOException e) {
            // ⑤ 防御：捕获所有IO错误并给出友好提示
            System.err.println("读取文件时出错：" + e.getMessage());
        }
    }
}

总结一句话就是：防御式编程就是“预先假设问题会发生，并设计好应对措施”，而不是“等异常爆炸再修”。

因此，我们开始踏入 Java 的异常使用啦，先初步了解五个异常常用关键字：

关键字	作用	位置	举例
`throw`	抛出一个具体的异常对象	方法体内	`throw new Exception("出错了");`
`throws`	声明该方法可能抛出哪些异常	方法声明上	`public void readFile() throws IOException`
`try`	可能出错的代码块	方法体内	`try { riskyCode(); }`
`catch`	捕获并处理异常	紧跟 try 后	`catch(Exception e) { ... }`
`finally`	无论是否异常都执行	可选	`finally { cleanUp(); }`

2.2 抛出异常

追踪本源

当发生错误时，比如用户输入非法字符，那么就可以抛出异常。

抛出异常分为两步，我们可以参考 Integer.parseInt()方法

1.创建Exception的实例

2.用 throw语句抛出

eg:

void example(String s){
    if(s == null){
        NullPointerException e = new NullPointerException();
    throw e;
    //通常写为一条语句，用匿名对象
    //throw new NullPointerException();
    }
}

但是，如果一个方法捕获了某个异常后，又在catch子句中抛出新的异常，就相当于把抛出的异常类型“转型”了:

void example1(String s) {
    try {
        example2();
    } catch (NullPointerException e) {
        throw new IllegalArgumentException();
    }
}

void example2(String s) {
    if (s==null) {
        throw new NullPointerException();
    }
}

这段代码展示的就是将NullPointerException异常转为了IllegalArgumentException，最终展示报错结果只有IllegalArgumentException

我们补为 static 方法放在 main 方法中打印出异常栈看看：

public class TestDemo3 {
    public static void main(String[] args) {
        try {
            example1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    static void example1() {
        try {
            example2();
        } catch (NullPointerException e) {
            throw new IllegalArgumentException();
        }
    }

    static void example2() {
        throw new NullPointerException();
    }
}

打印出的异常栈信息即为：

java.lang.IllegalArgumentException
	at demo2.TestDemo3.example1(TestDemo3.java:23)
	at demo2.TestDemo3.main(TestDemo3.java:13)

说明了新的异常丢失了原始异常信息，即看不到了原本的NullPointerException的信息了。

所以，为了追踪完整的异常栈，我们在构造异常的时候就把原始的Exception实例传进去(将 e 对象进行异常包装/异常链)，新的Exception就可持有原来的Exception信息。代码如下：

public class TestDemo3 {
    public static void main(String[] args) {
        try {
            example1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void example1() {
        try {
            example2();
        } catch (NullPointerException e) {
            throw new IllegalArgumentException(e);
        }
    }

    static void example2() {
        throw new NullPointerException();
    }
}

这样我们就保留下来最开始抛出的异常类型了，以方便我们直接溯源根源

java.lang.IllegalArgumentException: java.lang.NullPointerException
	at demo2.TestDemo3.example1(TestDemo3.java:23)
	at demo2.TestDemo3.main(TestDemo3.java:13)
Caused by: java.lang.NullPointerException
	at demo2.TestDemo3.example2(TestDemo3.java:28)
	at demo2.TestDemo3.example1(TestDemo3.java:21)

在代码中获取原始异常可以使用Throwable.getCause()方法。若返回 null，说明已经是“根异常”了。

Throwable.getCause()方法使用

Throwable cause = e.getCause();

->返回触发当前异常的“原始异常”

->如果返回 null，说明当前异常没有再包裹别的异常，是“根异常”。

基本使用：

try {
    someMethod();
} catch (Exception e) {
    Throwable cause = e.getCause();
    System.out.println("当前异常是：" + e);
    System.out.println("原始原因是：" + cause);
}

实际开发中常用：遍历整条异常链

若异常被包装多次，可以使用循环一直调用 getCause()；

static void printChain(Throwable t) {
    while (t != null) {
        System.out.println("异常: " + t);
        t = t.getCause();  // ⭐关键：向上查找
    }
}

2.3 捕获异常

2.3.1 异常声明 throws

throws 处在方法声明参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助 throws 将异常抛出给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。

修饰词 返回值类型 方法名(参数列表) throws 异常类型1,异常类型2...{}

我们举个例子看看 throws 用法

public void OpenConfig(String filename) throws FileNotFoundException{
    if(filename.equals("config.ini")){
        throw new FileNotFountException("配置文件名字不对");
    }
}

语法点注意：

1.throws 必须更在方法的参数列表之后

2.声明的异常必须是 Exception 或者 Exception 的子类

3.方法内部如果抛出多个异常，throws 之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常型具有父子关系，直接声明父类即可。

4.调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用 throws 抛出

2.3.2 try-catch 捕获并处理

throws 对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要 try-catch。

try{
// 将可能出现异常的代码放在这里
    } catch(要捕获的异常类型 e){
// 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类
//时，就会被捕获到
// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
    } catch(异常类型 e){
// 对异常进行处理
    } finally{
// 此处代码一定会被执行到
        }

1.try 块内抛出异常位置，之后的代码将不会被执行

2.如果抛出异常类型与 catch 时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，知道 JVM 收到后中断程序----异常是按照类型来捕获的

3.try 中可能会抛出多个不同的异常对象，则必须使用多个 catch 来捕获----多种异常，多次捕获

2.3.3finally

像在代码中，当程序需要中断并且需要我们关闭资源避免浪费的时候，finally 很好的帮我们解决了这个问题。

语法格式：
        try{
// 可能会发生异常的代码
        }catch(异常类型 e){
// 对捕获到的异常进行处理
        }finally{
// 此处的语句无论是否发生异常，都会被执行到
        }
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

举个范例：

public class TestFinally {
    public static int getData(){
        Scanner sc = null;
        try{
            sc = new Scanner(System.in);
            int data = sc.nextInt();
            return data;
        }catch (InputMismatchException e){
            e.printStackTrace();
        }finally {
            System.out.println("finally中代码");
        }
        System.out.println("try-catch-finally之后代码");
        if(null != sc){
            sc.close();
        }
        return 0;
    }
    public static void main(String[] args) {
        int data = getData();
        System.out.println(data);
    }
}
// 正常输入时程序运行结果：
100
finally中代码
100

上述程序，如果正常输入，成功接收输入后程序就返回了，try-catch-finally 之后的代码根本就没有被释放，造成资源泄漏。

注意：

finally 中的代码一定会执行的，一般在 finally 中进行一些资源清理的扫尾工作。

// 下面程序输出什么？
public static void main(String[] args) {
    System.out.println(func());
}
public static int func() {
    try {
        return 10;
    } finally {
        return 20;
    }
}
A: 10 B: 20 C: 30 D: 编译失败

答案解析：

java 规则：

1.try 中遇到 return 时，先把返回值记录下来，但不立即返回

2.finally 会在 return 执行前运行

3.如果 finally 中也写了 return，他会覆盖 try 的返回值

因此建议：不在 finally 中写 return（被编译器当作一个警告）

【面试题】：

throw 和 throws 的区别？
finally中的语句一定会执行吗？

throws 用于方法声明处，表示该方法可能抛出某类异常，让调用者处理。
throw 用于方法内部，创建并抛出一个异常对象，中断方法执行。
throws 是声明，throw 是动作；throws 后跟异常类型，throw 后跟异常对象。

2.几乎一定会执行，但有两个例外！

JVM 提前退出，eg: 调用 System.exit(0); JVM 直接停止，不执行 finally

finally 执行前被线程杀死，eg: (1)线程再 finally 前被 stop() (2)程序崩溃导致线程终止

2.4 异常的处理流程

我们先了解一下“调用栈”

方法之间是存在互相调用关系的，这种调用关系我们可以用“调用栈”来描述，在 JVM 中有一块内存空间称为“虚拟机栈”专门存储方法之间的调用关系，当代码中出现异常的时候，我们就可以使用e.printStackTrace();的方式查看出现异常代码的调用栈

你（main 方法）→ 去办业务

办事人员让你先去窗口 A（调用 methodA）

窗口 A 又让你先去窗口 B（调用 methodB）

窗口 B 又让你去窗口 C（调用 methodC）

你去每一个窗口，都会把“你当前在哪一层”记录下来。

这就是——调用栈（Call Stack）

然后呢，了解调用栈之后我们能更好的理解异常处理流程了

1.代码运行时发生错误 -> JVM 创建异常对象

2.JVM 将异常抛出到当前方法（throw）

3.JVM 查找匹配的 catch（当前方法内查找）

4.当前方法没有处理 -> 异常向上抛给调用者（throws）

5.异常层层向上，知道被某层 catch 处理

6.如果最终无人处理 -> JVM 答应异常栈 -> 程序终止

如果有匹配的 catch -> catch 执行

7.finally 总会执行

8.若 catch 中再次 throw -> 异常类型被“转换”继续向上抛

3.自定义异常类

当我们在代码中需要抛出异常时，尽量使用 JDK 已定义的异常类型。例如，参数检查不合法，应该抛出IllegalArgumentException：

static void example1(int age){
    if(age <= 0){
        throw new IllegalArgumentException();
    }
}

常见做法是自定义一个 BaseException作为“根异常”，然后，派生出各种业务类型的异常。

BaseException需要从一个适合的Exception派生，通常建议从Runtime Exception派生：

public class BaseException extends RuntimeException {
}

也因此，其他业务类型的异常就可以从BaseException派生：

public class UserNotFoundException extends BaseException {
}

public class LoginFailedException extends BaseException {
}

...

自定义的BaseException应该提供多个构造方法：

public class BaseException extends RuntimeException {
    public BaseException() {
        super();
    }

    public BaseException(String message, Throwable cause) {
        super(message, cause);
    }

    public BaseException(String message) {
        super(message);
    }

    public BaseException(Throwable cause) {
        super(cause);
    }
}

注意事项：

自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常

还需注意受查异常和非受查异常的应用区别

Java String 深入理解：不可变性、常量池与高效拼接

Wed, 29 Oct 2025 00:00:00 GMT

1.字符串构造

1.1 再识 String

String 类常用构造方式：

String s1 = "Hello Sirens";					//直接创建
System.out.println(s1);

String s2 = new String("Hello Sirens");		//对象创建
System.out.println(s1);

char[] array = {'S','i','r','e','n','s'};
String s3 = new String(array);				//对象创建
System.out.println(s3);

注意：

1.String 是引用类型，内部并不存储字符串，而是像静态方法一样，通过引用去调用堆区的 value（JDK9 之后 value 由 char[] 类型改为了 byte[] 类型，）

1.2 String 直接创建与对象创建

String s1 = "Hello";
String s2 = "Sirens";
String s3 = s1;
String s4 = new String("Hello");
String s5 = new String("World");

以上为 String 直接创建和对象创建内存示意图（画起来真累

整个过程：

1️⃣ String s1 = "Hello";

JVM 检查字符串常量池：是否已有 "Hello"？

如果没有，就在堆里创建一个 String对象#1001，内容为 "Hello"；

常量池记录一条映射 "Hello" → #1001；

局部变量表中的 s1 存放引用 #1001。

2️⃣ String s2 = "Sirens";

常量池查找 "Sirens"，没有；

在堆中创建一个新的 String 对象 #1002；

常量池记录 "Sirens" → #1002；

s2 引用 #1002。

3️⃣ String s3 = s1;

这是引用赋值，不是新建。

s3 和 s1 引用完全相同的对象。

4️⃣ String s4 = new String("Hello");

"Hello" 是常量池字面量，已存在，指向堆中 #1001；

new String("Hello") 表示：

读取常量池引用 #1001；

在堆中再创建一个新的 String 对象 #2001；

把 #1001 的字符数组内容复制到 #2001；

s4 引用的是 #2001。

5️⃣ String s5 = new String("World");

常量池中查找 "World"，发现没有；

在堆中创建 "World" 的常量池条目 "World" → #1003；

new String("World") 又在堆中创建一个新的对象 #2002；

s5 引用 #2002。

1.3 编译器优化

重点补充：这是我在学校的课上遇到的代码，说到这我就想提提这个

String hello = "你好";
String testOne = "你" + "好";    // [代码1]
System.out.println(hello == testOne); //输出结果是 true
System.out.println("你好" == testOne); //输出结果是 true
System.out.println("你好" == hello); //输出结果是 true
String you = "你";
String hi = "好";
String testTwo = you + hi;    // [代码2]
System.out.println(hello == testTwo); //输出结果是 false
String testThree = you + hi;
System.out.println(testTwo == testThree); //输出结果是 false

首先我们要知道：

常量+常量=常量

常量+变量=变量

变量+变量=变量

我们分成三部分分析：

部分一：

String hello = "你好";
String testOne = "你" + "好";		//编译器优化

在编译时，Java 编译器发现 "你" 和 "好" 都是常量字符串，于是它直接在编译阶段就做了优化：

String testOne = "你好";

也就是说——

变量	存放内容
`hello`	指向字符串常量池中 `"你好"`
`testOne`	也指向同一个常量池中的 `"你好"`

因为字符串常量池中，"你好" 只有一份副本。

所以：

hello == testOne   // true
"你好" == testOne   // true
"你好" == hello     // true

它们的“==”都在比较同一个引用地址（常量池中同一个对象）。

部分二：

String you = "你";
String hi = "好";
String testTwo = you + hi;

这里的关键在于：

you 和 hi 是变量，不是编译时的常量。

所以，编译器无法在编译期确定 you + hi 的值。
只能在运行时由 StringBuilder 拼接生成新字符串对象。

编译器其实会把上面的代码翻译成：

String testTwo = new StringBuilder()
                    .append(you)
                    .append(hi)
                    .toString();

这时候：

"你" 和 "好" 各自仍然在常量池中；

但拼接产生的 "你好" 是在堆里新创建的对象；

它没有放回常量池。

于是：

hello == testTwo   // false

因为两者引用的地址不同：

hello → 常量池

testTwo → 堆中新对象

部分三：

为什么 testTwo 和 testThree 也不相等

String testThree = you + hi;
System.out.println(testTwo == testThree); // false

理由同上，每次拼接：

都会通过 StringBuilder 重新 new 出一个新的字符串对象；

虽然内容相同，但内存地址不同。

因此：

testTwo == testThree   // false

除非你手动调用 .intern()：

testTwo.intern() == testThree.intern()   // true

intern() 会把字符串放进常量池里，如果常量池已有相同内容的，就直接返回那份引用。

2.String 对象直接的比较

1.==比较所引用的是否同属一个地址

我们知道，当==两边都为基本数据类型变量时，比较的是两值之间是否相等而不是地址。

但 String 不一样，首先 String 不是基本数据类型，而是引用数据类型，这在我们的 Java SE 基础提及过。

String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true

2.boolean equals(Object anObject)方法去按照字典顺序比较

字典序--字符大小的顺序（类比 ascii）

方法库中 String 类本身重写了父类 Object 中的 equals 方法，String 类重写后 equals 方法由比较地址改为了如下规则

System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false

3.int compareTo(String s)方法去按照字典序进行比较

虽然与 equals 同为按照字典序比较，但其返回值不同。equals 返回 boolean 类型，而 compareTo 返回的是 int 类型。

这也和我们之前的文章谈 compareTo 的时候提到过，(s1.compareTo(s2)如果 s1 比 s2 大，那么返回正数；反之。

但也有要点要注意：

String s1 = "abcd";
String s2 = "abe";
String s3 = "ab";
String s4 = "abcd";

System.out.println(s1.compareTo(s2));   //此时都为第三位不同，仅比较到第三位
System.out.println(s3.compareTo(s4));   //此时仅比较长度，因为前面都相同

4.int compareToIgnoreCase(String str)方法，与 compareTo 方式相同，但忽略大小写比较

String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3

3.字符串查找

查找，我们用到的思想就是索引了，String 类提供的常用查找的方法：

方法	功能
char charAt(int index)	返回 index 位置上字符，如果 index 为负数或者越界，抛出 IndexOutOfBoundsException 异常
int indexOf(int ch)	返回 ch 第一次出现的位置，没有返回 -1
int indexOf(int ch,int fromIndex)	从 fromindex 位置开始找 ch 第一次出现的位置，没有返回-1
int indexOf(String str,int fromIndex)	返回 str 第一次出现的位置，没有返回 -1
int lastIndexOf(int ch)	从 fromindex 位置开始找 str 第一次出现的位置，没有返回-1
int lastIndexOf(int ch,int fromIndex)	从后往前找，返回 ch 第一次出现的位置，没有返回-1
int lastIndexOf(int ch,int fromIndex)	从 fromIndex 位置开始找，从后往前找 ch 第一次出现的位置，没有返回-1
int lastIndexOf(String str)	从后往前找，返回 str 第一次出现的位置，没有返回-1
int lastIndexOf(String str,int fromIndex)	从 fromIndex 位置开始找，从后往前找 str 第一次出现的位置，没有返回-1

public static void main(String[] args) {
        String s1 = "Hello SSiirrieeSns";	
        //S  S  i  i  r  r  i  e  e  S  n  s
        //0  1  2  3  4  5  6  7  8  9  10 11
        System.out.println(s1.charAt(2));				//l
        System.out.println(s1.indexOf("r"));			//10
        System.out.println(s1.indexOf("l",3));			//3
        System.out.println(s1.lastIndexOf("S"));		//15
        System.out.println(s1.lastIndexOf("S",13));		//7
        System.out.println(s1.lastIndexOf(" ",13));		//5
    }

以上所调用到的方法产生的 String 类型结果都是方法中 return new String；

4.String 方法

4.1 转换

数值和字符串转换

String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("Sirens", 19));

同样其他类型也能转为 String 类型

int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
//Integer、Double等是Java中的包装类型

方法名	描述
String toUpperCase()	小写转大写
String toLowerCase()	大写转小写
String toCharArray()	字符串转数组
format(格式,数值)	格式化

4.2 字符串调整

替换

方法名	功能
String replaceAll(String regex,String replace)	替换所有的指定内容<br/>(匹配此字符串的正则表达式,用来替换每个匹配项的字符串)
String replaceFirst(String regex,String replacement)	替换首个内容<br/>(匹配此字符串的正则表达式,<font style="color:rgb(51, 51, 51);background-color:rgb(250, 252, 253);">用来替换第一个匹配项的字符串)</font>

注意:

由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

拆分

方法	功能
String[] split(String regex)	将字符串全部拆分<br/>(正则表达式分隔符)
String[] split(String regex,int limit)	将字符串以指定的格式，拆分为 limit 组<br/>(正则表达式分隔符,分割的份数)

注意：

像拆分 IP 地址，有的需要转义字符

1. 字符"|","*","+"都得加上转义字符，前面加上 "\" . 

2. 而如果是 "" ，那么就得写成 "\\" . 

3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

String site = "https://sirens007.github.io";
String[] s = site.split("\\.|://");
for (int i = 0; i < s.length; i++) {
    System.out.print(s[i]+" ");
}

拆分

方法	描述
String[] substring(int beginIndex)	从指定索引截取到结尾
String[] substring(int beginIndex, int endIndex)	截取部分内容

注意：

1.索引是从 0 开始的

2.Java 中默认都是左闭右开区间，所以如果截取部分内容的话 [beginIndex, endIndex),不取右值

补充方法：

方法	描述
boolean contains(CharSequence chars)	contains() 方法用于判断字符串中是否包含指定的字符或字符串<br/>chars -- 要判断的字符或字符串
String trim()	返回字符串的副本，忽略前导空白和尾部空白

使用案例：

 String Str = new String("    sirens007.gtihub.io    ");
 System.out.print("原始值 :" );
 System.out.println( Str );

 System.out.print("删除头尾空白 :" );
 System.out.println( Str.trim() );

//执行结果
//原始值 :    sirens007.github.io        
//删除头尾空白 :sirens007.github.io

5.字符串的不可变性

一、String 是一种不可变对象，字符串中的内容是不可改变的。

为了求证官方文件，我们打开 jdk 源码可以看到该核心定义

class String首先被声明为final，表示不能被继承

其次value数组被声明为private final--表明 value 自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

这说明了以内容：

1.外部无法访问；

2.初始化后不可再被修改引用；

3.数组内容虽可变，但外部没有访问入口。

以上说明意味着：

String 对象一旦创建，就固定绑定了内部value[];

修改字符串（如"abc".replace("a","x")）时，实际上是新创建了一个 String 对象。

举例：

可能很多人认为是 final 修饰了 value 导致 value 不能改变，其实不然

那我们就举一个例子找找是谁限制住了不可修改，如下

我们在 Test5 文件 default final 定义了数组 str，使用 Test3 去访问修改，可知编译器没有报错

当我们修改为了 private 后

显然爆红了，于此我们得到验证应该是 private 限制了你去访问。

二、所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

我们就拿 String 类里的 replace 方法，可以看到的是只有”结果不变“的情况才返回this

即：当字符串内容没有发生任何变化时，直接返回原对象。

6. 字符串修改

我们要尽量避免直接对 String 类型对象进行修改，因为 String 类是不能修改的，所有的修改都会创建新对象，效率很低下，就比如下面这种变量拼接（常量拼接没有问题，零开销）

String s1 = "hello";
String s2 = " world";
String s3 = s1 + s2;

此时编译器会在字节码层面生成：

new StringBuilder()
    .append(s1)
    .append(s2)
    .toString();
//也就是下面这样
StringBuilder stringbuilder = new StringBuilder();
stringbuilder.append("hello");
stringbuilder.append("world");
String ret = stringbuilder.toString();
System.out.println(ret);

所以在运行时：

创建一个新的 StringBuilder；

两次 append()；

再调用 toString() 创建新字符串。

这就是为什么 "hello" + " world" 和 s1 + s2虽然语法一样，但性能差距巨大。

我们还可以用代码来粗略比较一下 StringBuffer 和 StringBuilder

public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 0; i < 10000; ++i){
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        start = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("");
        for(int i = 0; i < 10000; ++i){
            sbf.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for(int i = 0; i < 10000; ++i){
            sbd.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

得到的结果依此是 70 、1、1，可以看出在对 String 进行修改时，效率是非常慢的。因此，如果要修改的话我们尽量使用 StringBuffer 或者 StringBuilder

7.StringBuilder 和 StringBuffer

7.1 二者区别

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder

public final class StringBuilder extends AbstractStringBuilder
implements java.io.Serializable, CharSequence {

    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}

StringBuffer

public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence {

    public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }
}

唯一的区别就在于：

StringBuffer 的方法前多了一个 synchronized 关键字。

StringBuffer：多线程情况下

StringBuffer 类比公共厕所，

每次只能进去一人；

门口有锁（synchronized同步锁），别人必须等前一个人出来才能进去。

确保每次使用都“安全”，不会出现混乱（数据不一致）

你可以这么理解：

假如你和同事都要上厕所（多个线程操作字符串），
StringBuffer 就像门上了锁的公共厕所：
一个用完另一个再用，虽然慢一点，但不会出事故。

StringBuilder：单线程情况下

没有锁，谁抢到谁用

设计时假设“你家就你一个人”，所以没必要加锁

你也可以这么理解：

如果你自己住（单线程程序），
当然不用给厕所门上锁，加锁反而浪费时间。
所以 StringBuilder 就是单人卫生间，速度飞快，但只适合自己用。

7.2 StringBuilder 和 StringBuffer

方法	说明
`StringBuffer append(String str)`	在尾部追加，相当于 `String` 的 `+=`，可以追加：`boolean`、`char`、`char[]`、`double`、`float`、`int`、`long`、`Object`、`String`、`StringBuffer`变量
`char charAt(int index)`	获取 `index`位置的字符
`int length()`	获取字符串的长度
`int capacity()`	获取底层保存字符串空间的大小
`void ensureCapacity(int minimumCapacity)`	扩容
`void setCharAt(int index, char ch)`	将 `index`位置的字符设置为 `ch`
`int indexOf(String str)`	返回 `str`第一次出现的位置
`int indexOf(String str, int fromIndex)`	从 `fromIndex`位置开始找 `str`第一次出现的位置
`int lastIndexOf(String str)`	返回最后一次出现 `str`的位置
`int lastIndexOf(String str, int fromIndex)`	从 `fromIndex`位置开始找 `str`最后一次出现的位置
`StringBuffer insert(int offset, String str)`	在 `offset`位置插入各种基本类型、`String`类型或 `Object`类型数据
`StringBuffer deleteCharAt(int index)`	删除 `index`位置的字符
`StringBuffer delete(int start, int end)`	删除 `[start, end)`区间内的字符
`StringBuffer replace(int start, int end, String str)`	将 `[start, end)`区间的字符替换为 `str`
`String substring(int start)`	从 `start`开始一直到末尾的子串以 `String`方式返回
`String substring(int start, int end)`	将 `[start, end)`范围内的子串以 `String`方式返回
`StringBuffer reverse()`	反转字符串
`String toString()`	将所有字符按 `String`的方式返回

Java 抽象类与接口：类型约束、接口继承与 Object 基类

Fri, 17 Oct 2025 00:00:00 GMT

1.抽象类

1.1啥是抽象类？

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有足够的信息来描绘一个具体的对象，这样的类就是抽象类。

像这样的Animal类一般只为服务创建Dog类和Cat类的，我们就可以直接定义为抽象类（abstract class），以及animal类的bark()方法我们通常不调用，所以我们同样可以写为抽象方法（abstract function）。

像这样子的抽象类和抽象方法就是为了让子类去重写再描述具体对象而产生的。

并且我们同样合理的利用编译器的语法规则去校验我们的代码，以防错误的创建和访问。

1.2抽象类的特性

注意：

1.抽象类不能直接实例化对象，但其他功能和普通类仍然一样

2.抽象类必须被继承

3.抽象方法不能是private的

4.抽象方法不能被final和static修饰，因为抽象方法要被子类重写

5.抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须使用abstract修饰

6.抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

7.抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

1.3如何使用抽象类呢？

我们依旧拿Animal举例哈（问就是想象力匮乏...

public abstract class Animal {
    public abstract void bark();
}

//是在不同文件哈
public class Dog extends Animal
    //记得要重写抽象方法哈
    public void bark(){
        System.out.println("在汪汪汪");
    }
}

1.4抽象类的作用

经过上面的学习，我们可以知道抽象类就是为了给定子类一个大的框架，保证后面的子类根据抽象类做更多定义。

记住哈，抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

另外呢，我想说，我们使用抽象类的意义就是为了多一重编译器的校验，尽管普通类就足够，但既然有这样的语法，我们就应该按照规范去完成啦😊

2.接口

2.1接口的声明

public interface [接口名称]{
    public void method();
}

注意:

1.创建接口时，接口的命名一般以大写字母I开头

2.接口的命名一般使用“形容词”词性的单词

3.接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字

4.接口中的方法都是共有的

2.2接口的使用

接口必须要通过一个“实现类”来实现该接口，并且要实现接口中的所有方法；否则，类必须声明为抽象的类。

eg:(这是两个文件

public interface Iaction{
    void eat();
    void walk();
    void sleep();
    ...
}

public class Dog implements Iaction{
    @Override
    public void eat() {}
    @Override
    public void walk() {}
    @Override
    public void sleep() {}
}

1.子类与父类之间是extends继承关系，类与接口之间是implements实现关系

2.这两种关系可以同时作用

3.继承不能多继承，但一个类可以同时实现多个接口

2.3接口的特性

1.接口当中的成员变量，默认是public static final修饰的（只能是public，用private会编译报错）

2.接口当中的抽象方法，默认都是public abstract修饰的（只能是噢、public abstract，其他修饰符都会报错）

3.如果接口当中的方法被default修饰，那么可以有具体的实现

default void test(){
System.out.println("default method");

4.如果接口当中的方法被static修饰，那么可以有具体的实现

static void test(){
System.out.println("static method");

5.接口是不可以进行实例化的

6.类和接口之间可以使用关键字implements来实现接口

7.一个接口对应一个字节码文件

8.接口中不能有静态代码块和构造方法

9.如果类中没有实现接口中的所有方法，则类必须设置为抽象类

2.4实现多个接口

实现接口不像继承类一样，它可以多个实现，比如下面

public class Animal implements Iwalk,Iswim,Ieat{}

注意：

通常我们用抽象类或父类实现接口的时候，所实现的接口一定要有共性，如walk，eat一些动物都会的...

另外，一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

提示，IDEA中使用 ctrl + i 可以快速实现接口

因此我们可以这样去理解，继承表达的含义是is-a语义，而接口表达的含义是具有xxx特性

猫是一种动物，具有会跑的特性

青蛙也是一种动物，既能跑，也能游泳

这样的话，我们可以不用父类实现所有接口，只需要每一个动物类去单独实现该有的特性，然后在运行类这样写，再在main方法中像这样去调用即可

public class Test {
    public static void walk(IWalk iwalk){
        iwalk.walk();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("PaPy Dog",3);
        Test.walk(dog);
        Test.walk(new Dog("dog",2));	//匿名对象同样也行
    }
}

但是如果该具体动物类没有实现对应接口，那么就会报错

2.5接口间的继承

interface IA{
    public void ia();
}
interface IB{
    public void ib();
}
interface IC extends IA,IB{
    public void ic();
}

但我们去实现接口IC的时候，要重写IC所继承的所有方法，以及它本身的方法。

即要重写ia，ib，ic三个方法

接口间的继承相当于把多个接口合并在一起

3.Object类

3.1初步了解Object类

首先，我们要知道Object类是Java默认提供的一个类，Java里除了Object类，所有的类都是存在继承关系的。默认继承Object父类。即所有类的对象都可以使用Object的引用进攻接收。

eg:我们用Object接受所有类的对象

class Dog{}
class Cat{}

public class Test {
    public static void main(String[] args) {
        Object obj1 = new Dog("dog",2);
        Object obj2 = new Cat("cat",2);
    }
}

也就是说都可以向上转型

所以在开发中，Object类是参数的最高统一类型。但Object类也有定义好的一些方法。我们主要关注hashCode(),equal(),toString()这几个方法即可

3.2获取对象信息

打印对象信息，我们可以直接重写或直接调用Object类的toString方法

// Object类中的toString()方法实现：
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

//重写的toString
@Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    Object obj = new Dog("dog",2);
    System.out.println(obj.toString());  //这样调用即可

Java 接口实践：对象比较、克隆与 equals/hashCode 契约

Fri, 17 Oct 2025 00:00:00 GMT

接口使用实例以及Object类中的equals,hashcode方法

1.Comparable 接口实现

实现该接口时需要加上一个泛型（类比 C++的模板）

Class Student implements Comparable<Student>,我们比较什么类型就填什么类型在<>

我们了解了 Comparable 接口之后，会知道里面存在一个方法 compareTo()

因此 compareTo()需要我们去重写，这其实就是一个比较规则，需要怎么比较类型可以由我们来完成，我们举出一个例子如下

class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        //通过年龄比较
        return this.age - o.age;
        //通过名字比较
        //return this.name.compareTo(o.name);
    }
}

public class Test {
    public static void main(String[] args) {
        Student std1 = new Student("小李",20);
        Student std2 = new Student("小刘",19);
        System.out.println(std1.compareTo(std2));
    }
}

//运行结果为 1

有人会好奇，为什么用名字比较会这么写 return this.name.compareTo(o.name);

可以发现，String 类型中也有 compareTo()方法，因此我们直接调用即可

当我们将用到数组对对象进行排序时，中间的对比过程正是运用了类似这个步骤

class Student /*implements Comparable<Student>*/{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return "Student {name=" + name + ", age=" + age + "}";
    }
    /*@Override
    public int compareTo(Student o) {
        return this.age - o.age;
        //return this.name.compareTo(o.name);
    }*/
}

public class Test {
    public static void main(String[] args) {
        Student std[] = new Student[3];
        std[0] = new Student("小李",20);
        std[1] = new Student("小刘",19);
        std[2] = new Student("小新",18);
        Arrays.sort(std);
        System.out.println(Arrays.toString(std));
    }
}

我们继续使用上面那个例子，将 compareTo()方法以及接口屏蔽会发现运行到Arrays.sort(std);这里的时候发生异常

ClassCastException 报错信息中为类型转换异常

class demo3.Student cannot be cast to class java.lang.Comparable也就是说 Student 不能被转换为 Comparable 型，

图片中的意思是：

这是报错信息中的一个方法，Object[] a 是我们传 Student std[] 的形参

这是原本正确运行需要进行的，但是我们现在连 Comparable 接口都还没有实现，怎么能强转为 Comparable 类型呢，更不用说调用 compareTo()方法了

因此当我们放开 Comparable 实现和 compareTo()方法重写，那么 Arrays.sort()就会按照我们是按名字还是按年龄写的 compareTo()方法去排序。实际上也就是把比较规则放出来，别人才能拿来比较

那么我们得到的结论就是：

只要是自定义的类型，涉及到了大小比较，那就得一定实现 Comparable 接口

至于 Arrays.sort()内部是怎样实现的，我给出一个大概的模拟实现，实际内部更复杂

类似冒泡排序的排序方法

public static void mySort(Comparable[] comparables){
    for (int i = 0; i < comparables.length-1; i++) {
        for (int j = 0; j < comparables.length-1-i; j++) {
            if(comparables[j].compareTo(comparables[j+1]) > 0) {
                Comparable tmp = comparables[j];
                comparables[j] = comparables[j+1];
                comparables[j+1] = tmp;
            }
        }
    }
}

为什么要用 Comparable[] comparables 作为形参呢，因为就是我们前面说的向上转型一样转为 Comparable 类型，我们就可以直接使用这个接口中的方法。

再整体看一下这段代码

class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return "Student {name=" + name + ", age=" + age + "}";
    }
    @Override
    public int compareTo(Student o) {
        //方法二：将this和o调换位置也可以变为降序
        return this.age - o.age;
        //return this.name.compareTo(o.name);
    }
}

public class Test1 {
    public static void mySort(Comparable[] comparables){
        for (int i = 0; i < comparables.length-1; i++) {
            for (int j = 0; j < comparables.length-1-i; j++) {
                //方法一：这里大于零做的是一个升序的排序，改为小于零就是降序了
                if(comparables[j].compareTo(comparables[j+1]) > 0) {
                    //swap(comparables, j, j+1);
                    Comparable tmp = comparables[j];
                    comparables[j] = comparables[j+1];
                    comparables[j+1] = tmp;
                }
            }
        }
    }

    // public static <T> void swap(T[] arr, int i, int j) {
    //     T tmp = arr[i];
    //     arr[i] = arr[j];
    //     arr[j] = tmp;
    // }


    public static void main(String[] args) {
        Student std[] = new Student[3];
        std[0] = new Student("小李",20);
        std[1] = new Student("小刘",19);
        std[2] = new Student("小新",18);
        mySort(std);
        System.out.println(Arrays.toString(std));
        //System.out.println(std1.compareTo(std2));
    }
}

但是这个接口的方法存在一定的局限性，就是我有时候想用年龄去排可以，但我有时候又想用名字去排，但这个方法不能共存，只能一个 compareTo() 方法（比较器）（/也就是比较规则）

补充建议：

其实像上面提到的用年龄比较

    @Override
    public int compareTo(Student o) {
        //通过年龄比较
        return this.age - o.age;
    }

我们实际上还可以用它类型自带的 compare()方法，下面我们举一个例子

让 compareTo() 按 score 从高到低排序；
如果分数相同，则按 年龄从小到大排序。

    @Override
    public int compareTo(Student o) {
        int cmp = Double.compare(o.score,this.score);
        if(cmp == 0){
            cmp = Integer.compare(this.age,o.age);
        }
        return cmp;
    }

这里我们就用到了整型自带的Integer.compare()方法和 double 型自带的Double.compare()方法；为什么建议用类型自带的方法呢而不用以下这种

@Override
public int compareTo(Student o) {
    if (this.score < o.score) {
        return 1;              // 分数低的排在后面
    } else if (this.score > o.score) {
        return -1;             // 分数高的排在前面
    } else {
        return o.age - this.age; // 分数相同时，年龄大的排前
    }
}

问题：compareTo 的返回值逻辑不够直观

🔹 那样写更安全（避免浮点数误差问题）
🔹 逻辑清晰，可读性高
🔹 不会因为 == 比较浮点数出问题

2.Comparator 接口实现

我们可以创建一个新的类 NameComparator

import java.util.Comparator;

public class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1,Student o2){
        return o1.name.compareTo(o2.name);
    }
}

以及另外一个新的类 AgeComparator

import java.util.Comparator;

public class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        //按照降序排
        return o1.age - o2.age;
    }
}

这个方法不需要依赖 Student类去实现任何接口

AgeComparator ageComparator = new AgeComparator();
System.out.println(ageComparator.compare(std[0],std[1]));

直接实例化调用，如果需要升序降序我们可以再去分类写几个升序降序的类即可；即我们可以同时存在多个类似地比较方法，只需要放在不同类去实现接口重写 compare()方法就行！！！

3.Clonable 接口和深拷贝

当我们先了解到下面要讲的 Object 类之后可以再回头看看

Object 类中有一个 clone 方法，这个方法的作用就是字面意思，克隆一个对象

举一个例子：

public class Person implements Cloneable{
    public int age;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

使用步骤：

创建 Person 类，然后实例化一个 person1，接着再克隆给对象 person2

2.重写 Object 父类的 clone() 方法（因为该方法在 Object 中是 protected 访问权） [Alt+Ins 键选择重写克隆 clone()方法即可]

4.注意返回值是父类 Object，所以我们需要向下转型为 Person

5.在 Person类中实现 Cloneable 接口

6.抛去异常处理public static void main(String[] args) throws CloneNotSupportedException

补充一下，Cloneable 是空接口，空接口也叫标记接口，表示当前类可以被克隆

public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        person1.age = 19;
        Person person2 = (Person)person1.clone();
        System.out.println(person2.toString());
    }

我们再拓展一下，新增一个 Money 类

class Money{
    public double money = 19.9;
}

public class Person implements Cloneable{
    public int age;
    public String name;

    public Person(int age,String name){
        this.age=age;
        this.name=name;
    }

    Money m = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", money=" + m.money +
                '}';
    }
}

此时在栈和堆中是这样的，引用同一个 m 对象，我们因此称之为浅拷贝

如果 m 对象也被拷贝了，那就是深拷贝

所以我们就进行如下操作变为深拷贝吧

先让 Money 能够被克隆

class Money implements Cloneable{
    public double money = 19.9;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

然后再修改一下克隆方法

protected Object clone() throws CloneNotSupportedException {
    Person tmp = (Person)super.clone();
    tmp.m = (Money)m.clone();
    return tmp;
}

我们再进行测试一下即可

public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person(19,"小李");
        person1.age = 19;
        Person person2 = (Person)person1.clone();

        System.out.println("修改前："+person1.toString());
        System.out.println("修改前："+person2.toString());
        person2.m.money = 100;
        System.out.println("修改后："+person1.toString());
        System.out.println("修改后："+person2.toString());
    }

返回的结果：

修改前：Person{age=19, name='小李', money=19.9}

修改前：Person{age=19, name='小李', money=19.9}

修改后：Person{age=19, name='小李', money=19.9}

修改后：Person{age=19, name='小李', money=100.0}

此时的 Person2 的 m 对象是另外一个独立的对象，与 Person 引用的 m 不是同一个

4.对象比较equals方法

在Java中，==进行比较时：

a.如果==左右两侧是基本类型变量，比较的是变量中值是否相同

b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

// Object类中的equals方法
public boolean equals(Object obj) {
    return (this == obj); // 使用引用中的地址直接来进行比较
}

我们自己写一个比较引用类型中的基本类型比较(eg:Person类中的name和age)

public boolean equals(Object obj) {
    if (obj == null) {
        return false ;
    }
    if(this == obj) {
        return true ;
    }
// 不是Person类对象
    if (!(obj instanceof Person)) {
        return false ;
    }
    Person person = (Person) obj ; // 向下转型，比较属性值
    return this.name.equals(person.name) && this.age==person.age ;
}

结论：比较对象中内容是否相等的时候，一定要重写equals方法。

5.hashcode方法

我们回忆一下Object中的toString方法

// Object类中的toString()方法实现：
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

我们看到了hashCode()这个方法，他帮我算了一个具体的对象位置，这里面涉及数据结构，但是我们还没学数据结构，没法讲述，所以我们只能说它是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出。

hashcode方法源码：

public native int hashCode();

该方法是一个native方法，底层是由C/C++编写，无法观察到

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看示例代码：

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Person per1 = new Person("Sirens", 20) ;
        Person per2 = new Person("Sirens", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}
//执行结果
460141958
1163157884

注意事项：两个对象的hash值不一样。

像重写equals方法一样，我们也可以重写hashcode()方法。此时我们再来看看。

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Person per1 = new Person("Sirens", 20) ;
        Person per2 = new Person("Sirens", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}
//执行结果
460141958 
460141958

注意事项：哈希值一样。

结论：

1、hashcode方法用来确定对象在内存中存储的位置是否相同 

2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

Java 继承机制：成员访问、构造链与组合选择

Sat, 27 Sep 2025 00:00:00 GMT

1.继承

1.1类的继承

1.1.1 继承格式

Java 中通过 extends关键字可以声明一个类是从另外一个类继承而来的，形式如下：

class 父类 {
}

class 子类 extends 父类 {
}

继承的目的是为了降低代码的重复，避免代码量大且臃肿。通过提取出代码的共性，实现代码的复用。

要注意：

1.子类会将父类中的成员变量或者成员方法继承到子类中

2.子类继承父类后，要添加自己特有成员，体现出与父类不同，否则没必要经行继承。

1.1.1 extends关键字

在 Java 中，类的继承是单一继承的，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

1.2继承类型

注意的是 java 不支持多继承，但支持多重继承。

要知道，事实上我们并不需要过多的继承关系，这会导致向上追踪过于复杂。如果需要继承层次太多，就需要考虑对代码进行重构了。一般我们不希望超过三层的继承关系。

如果想从语法上进行限制继承，就可以使用 final 关键字 了

1.3继承的特性

子类拥有父类非private 的属性、方法
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

1.4子类访问父类

1.4.1 子类访问父类成员变量

通常子类在继承父类之后，父类的成员变量就会依附在子类中。但是如果子类重新定义了与父类同名的成员变量时，那么访问该变量时，会优先访问子类的变量。

eg:

class TestA {
    int a = 1;
    int b = 2;
}
class TestB extends TestA{
    int a = 1111;
}

//实例化 TestB b 
//此时System.out.println(b.a);得到的结果会是 1111

总结：成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

1.4.2 子类访问父类的成员方法

与访问成员变量，如果名字相同以及参数相同，那么会优先访问子类的。

通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用

方法适传递的参数选择合适的方法访问，如果没有则报错；

因此引出了一个问题，如果我偏偏想要访问父类的方法呢？那么就需要我们学习下面这个关键字了(super)

1.5 super 与 this 关键字

1.5.1 super & this

该关键字主要作用：在子类方法中访问父类的成员。

super 关键字：我们可以通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用，引用当前对象，即它所在的方法或构造函数所属的对象实例。

class Animal {
    void eat() {
        System.out.println("animal : eat");
    }
}
 
class Dog extends Animal {
    void eat() {
        System.out.println("dog : eat");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}
 
public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
    }
}

输出结果为：

animal : eat
dog : eat
animal : eat

类以及变量都存放如图位置（jdk8之后）

注意：

1. 只能在非静态方法中使用 

2. 在子类方法中，访问父类的成员变量和方法。

1.5.2 final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

使用final 关键字声明类，就是把类定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写（密封类）：

声明类：

final class 类名 {}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注意：

1.final 定义的类，其中的属性、方法不是final 的。

1.6 子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。

注意：是在父类显示构造方法时。子类需要去调用。

父子父子肯定是先有父再有子，所以在构造子类对象时候，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

class Base{
    int age;
    String name;
    double length;

    public Base(int age, String name) {
        this.age = age;
        this.name  = name;
        System.out.println("Base constructor called");
    }
}

public class Derived extends Base {
    public Derived(int age, String name) {
        super(1,"1");
    }
}

public class Main {
    public static void main(String[] args) {
        Derived d = new Derived(1,"1");
    }
}

//输出结果为：Base constructor called

注意：

1.若父类显示定义无参或者默认的构造方法，在子类构造方法第一行默认由隐含的super()调用，即调用基类构造方法

2.如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

3.在子类构造方法中，super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

1.7 再谈初始化

1.7.1 代码块的执行顺序

class Base {
    public String name;
    public int age;

    public Base(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("Base构造方法");
    }
    {
        System.out.println("Base实例代码块");
    }
    static{
        System.out.println("Base静态代码块");
    }
}

class Derived extends Base {
    public Derived(){
        super("Derived",20);
        System.out.println("Derived构造方法");
    }
    {
        System.out.println("Derived实例代码块");
    }
    static{
        System.out.println("Derived静态代码块");
    }
}

public class Main{
    public static void main(String[] args) {
        Derived d = new Derived();
        System.out.println("==============");
        Derived e = new Derived();
    }
}

//输出结果：
Base静态代码块
Derived静态代码块
Base实例代码块
Base构造方法
Derived实例代码块
Derived构造方法
==============
Base实例代码块
Base构造方法
Derived实例代码块
Derived构造方法

我们可以得到该结论：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行的

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着在执行

4、第二次实例化子对象时，父类和子类的静态代码块都将不会再执行

1.7.1 构造方法的执行顺序

顺序一：

class Y {
    public Y() {
        System.out.print("Y");
    }
}

class X {
    Y y = new Y();  // 成员变量的初始化
    public X() {
        System.out.print("X");
    }
}

public class Main {
    public static void main(String[] args) {
        X x = new X();
    }
}

//执行结果：YX

🔑Java 对象的初始化顺序(记住：先成员，后构造）

在 Java 中，当你 new X() 时，发生的步骤是：

分配内存
JVM 为 X 对象分配空间。
初始化成员变量（包括显式赋值）
在执行构造方法体之前，先对所有实例成员变量（包括 new Y()）进行初始化。
所以会先执行 Y 的构造方法，打印 "Y"。
执行构造方法体
然后才会进入 X 的构造方法，打印 "X"。

顺序二：

class Y{
    public Y(){
        System.out.print("Y");
    }
}
class X extends Y{
    Y y = new Y();
    public X(){
        System.out.print("X");
    }
}
public class Test {
    public static void main(String[] args) {
        X x = new X();
    }
}

//执行结果：YYX

执行顺序是：

因为是继承父类，所以先调用父类构造
其次才是子类字段Y y = new Y();可看作是实例代码块执行顺序
最后才是子类自己的构造方法

顺序三：

class X {
    Y y = new Y(); // (1)
    public X() {   // (2)
        System.out.print("X");
    }
}

class Y {
    public Y() {   // (3)
        System.out.print("Y");
    }
}

public class Z extends X {
    Y y = new Y(); // (4)
    public Z() {   // (5)
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

//执行结果：YXYZ

执行new Z();顺序说明：

执行 X 里的 Y y = new Y(); // (1)，调用 Y() 构造器
👉 进入 X() 构造器
执行 Z 里的 Y y = new Y(); // (4)，调用 Y() 构造器
👉 进入 Z() 构造器

调用说明：

JVM 给 Z 对象分配内存，成员变量先设为默认值（此时 X.y = null, Z.y = null）。
Z extends X，所以先去构造 X。但在调用 X() 构造方法体前，必须先初始化 X 的成员变量。

总结： “父变量 → 父构造 → 子变量 → 子构造”

1.8protected关键字

主要限制：类或类中成员能否在类外或者其他包中被访问。

注意：父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了

1.9 继承与组合

组合，组合并没有涉及到特殊的语法，仅仅是将一个类的实例作为另一个类的字段。

继承表示对象间is-a的关系：狗是动物，猫是动物

组合表示对象间has-a的关系：汽车（包含轮子，车座...）

class Tire{
    ...
}
class Engine{
    ..
}
class VehicleSystem{
    ...
}

class Car{
    private Tire tire;
    private Engine engine;
    private VehicleSystem vs;
    ...
}

class Benz extends Car{
    ...
}

一般建议：能用组合尽量用组合。

以上是我关于Java继承的笔记分享，

感谢你读到这里，这也是我学习路上的一个小小记录。希望以后回头看时，能看到自己的成长~

Java 多态机制：类型转换、方法重写与动态绑定

Sat, 27 Sep 2025 00:00:00 GMT

1.多态

对一个事物产生不同的态度

1.1多态实现条件

多态实现的三个必要条件

必须在父类的继承体系下
子类必须要对父类中方法进行重写
通过父类的引用调用重写的方法

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。如果有，再去调用子类的同名方法。

1.2向上转型和向下转型

1.2.1向上转型

概念：创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型对象名 = new 子类类型()

Animal animal = new Cat("元宝",2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

向上转型的几种方法：

直接赋值
方法的传参
方法的返回值

注意事项：

通过父类的引用，调用子类特有的方法是无法直接调用的，这里只能调用父类自己的。

class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
}

class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
}

public class Test {
    //方法二：方法的传参
    public static void function(Animal animal){
    }
    //方法三：返回值
    public static Animal function2(){
        Dog dog = new Dog("Papy Dog");
        return dog;
    }
    public static void main(String[] args) {
        //方法一：直接赋值
        Animal dog = new Dog("Papy Dog");
        Cat cat = new Cat("Papy Cat");
        //方法二：方法的传参
        function(cat);
        //方法三：返回值
        Animal dog2 = function2();
    }
}

1.2.2向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

继续根据向上转型的类举例：

class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
}

class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
}

public class Test{
    public static void main(String[] args){
        Dog dog = new Dog("Papy Dog");
        Cat cat = new Cat("Papy Cat");
        Animal animal = new Dog("Papy Dog");	//向上转型
        Dog dog = (Dog)animal;		//合法的向下转型
        //cat = (Cat)animal;		//非法的向下转型
    }
}

注意向下转型的要求：

必须先有向上转型（前提）
对象的真实类型必须是目标子类或者其子类
需要强制类型转换（Cast）
推荐instanceof检查类型（安全转型方式）

if (a instanceof Dog) {
    Dog d = (Dog) a;
    d.bark();
}

来个比喻呢就是

向上转型：你把 “iPhone” 当成 “手机” 来用，没问题。
向下转型：你把 “手机” 强行当成 “iPhone” 用，只有当它本来就是 iPhone 才行，如果本来是 “小米”，那么立马报错。

1.3重写与重载

1.3.1重写

class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
    public void eat(){
        System.out.println("Animal在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
    public void eat(){
        System.out.println("Dog在吃饭");
    }
}

//输出结果：Dog在吃饭

以上例子构成了重写，按规则是要调用父类的eat的，但是构成了动态绑定（伏笔）

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 形参列表与被重写方法的参数列表必须完全相同。

方法重写的规则：

子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 (参数列表) 要完全一致
被重写的方法返回值类型可以不同，但是必须是具有父子关系的
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
父类被static、private修饰的方法、构造方法都不能被重写。
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

对第二点解释：

class Parent {
    Number getValue() { return 1; }
}
class Child extends Parent {
    @Override
    Integer getValue() { return 2; } // OK，Integer 是 Number 的子类
}

1.3.2重写与重载的区别

区别点	重载Overload	重写Override
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改[除非构成父子类关系]
访问限定符	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

重写的原则：

对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。

父类：DrinkMachine（饮料机）

class DrinkMachine {
    public void makeDrink() {
        System.out.println("制作普通饮料");
    }
}

子类：CoffeeMachine（咖啡机）

class CoffeeMachine extends DrinkMachine {
    @Override
    public void makeDrink() {
        System.out.println("制作咖啡");
    }
}

eg：比如饮料机。父类：DrinkMachine 子类：咖啡机CoffeeMachine，如果直接改DrinkMachine的makeDrink()方法把“普通饮料“换成”咖啡“，那以后所有买饮料的人都只能喝咖啡了，果汁党就会抗议 😂。

正确做法应该就是新建CoffeeMachine，只改子类逻辑，不影响父类

1.3.3动态绑定与静态绑定

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

解释如下：

class Parent {
    void hello() {
        System.out.println("Parent hello");
    }
}

class Child extends Parent {
    @Override
    void hello() {
        System.out.println("Child hello");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();  // 向上转型
        p.hello();               // 打印什么？
    }
}

(1)编译期

编译器只知道 p 的静态类型是 Parent，所以它会去 Parent 类中查找有没有 hello() 方法。
查到以后，编译器就说：“行，这个调用是合法的。”
但 它不会决定最终调用哪个版本。

👉 所以编译期只检查 方法是否存在，但不绑定到具体实现。

(2)运行期

运行时，p 实际上引用的是一个 Child 对象。
Java 虚拟机（JVM）在调用 p.hello() 的时候，会根据 对象的真实类型（运行时类型） 来决定到底执行 Parent.hello() 还是 Child.hello()。
因为 Child 重写了 hello()，所以 JVM 调用的是 Child 的版本。

这就是动态绑定（Dynamic Dispatch）

JVM底层原理

在JVM的方法区（Java8后都是元空间Metaspace）里，每个类都会有一张方法表 （Method Table，类似 C++ 的 vtable）。

1.类加载时：

JVM 为 Parent 类建立方法表，里面有 hello -> Parent.hello 的映射。
JVM 为 Child 类建立方法表，发现 hello 被重写了，就把 hello -> Child.hello 替换掉。

2.对象创建时：

当new Child()执行时，对象头里会有一个指针，指向Child的类信息（包括方法表）。

3.方法调用时：

执行 p.hello()，JVM 并不会直接调用 Parent.hello()，而是：

看 p 的运行时类型 → 发现它指向 Child
在 Child 的方法表里查找 hello() → 找到 Child.hello() → 调用它。

👉 因此，真正起作用的是 运行时对象的类信息 + 方法表查找，而不是变量的声明类型。

我们可以类比为：

编译期：老师点名检查->”这个学生‘回答问题’的功能吗？“（有）

运行期：真正回答问题的是具体学生，可能每个人回答的方式不同。

1.4回顾多态

1.4.1多态思想

class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
    public void eat(){
        System.out.println(this.name+"在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
    @Override
    public void eat(){
        System.out.println(this.name+"在吃饭");
    }
}

class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
    @Override
    public void eat(){
        System.out.println(this.name+"在吃饭");
    }
}

public class Test{
    public static void func(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("Papy Dog");
        Cat cat = new Cat("Papy Cat");
        func(dog);
        func(cat);
    }
}

输出结果：
Papy Dog在吃饭
Papy Cat在吃饭

调用同一个方法，得到不同的结果（多态思想）

1.4.2多态的优缺点

优点：

public static void drawShapes() {
    Rect rect = new Rect();
    Cycle cycle = new Cycle();
    Flower flower = new Flower();
    String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
    for (String shape : shapes) {
        if (shape.equals("cycle")) {
            cycle.draw();
        } else if (shape.equals("rect")) {
            rect.draw();
        } else if (shape.equals("flower")) {
            flower.draw();
        }
    }
}

我们使用多态的话，就能优化一下我们的代码

public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
    Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
            new Rect(), new Flower()};
    for (Shape shape : shapes) {
        shape.draw();
    }
}

缺点：

多态的缺陷--代码的运行效率降低

1.属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

2.构造方法没有多态性

以上是我关于Java多态的笔记分享，

感谢你读到这里，这也是我学习路上的一个小小记录。希望以后回头看时，能看到自己的成长~

Java 类与对象：实例化、构造方法、封装与静态成员

Mon, 22 Sep 2025 00:00:00 GMT

1.定义类

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
 
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

注意：

1.一般一个文件当中只定义一个类

2.main方法所在的类一般要使用public修饰

3.public修饰的类必须要与文件名相同

4.不要随意修改public修饰的类的名字

2.创建对象（类的实例化）

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "Sirens" );
   }
}

输出内容为以下：

小狗的名字是：Sirens

3.访问实例（成员）变量与方法

通过已创建的对象来访问成员方法：

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

实质上在main方法中通过.来访问对象中的变量以及方法

4.构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

下面是一个构造方法示例：

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

注意：

this(...)必须是构造方法中第一条语句

5.综上范例

public class Employee{
	private String name;
	private int age;
	private String designation;//称号
	private double salary;
	
	public Employee(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public int getAge(){
		return age;
	}
	
	public void setDesignation(String designation){
		this.designation = designation;
	}

	public String getDesignation(){
		return designation;
	}
	
	public void setSalary(double salary){
		this.salary = salary;
	}
		
	public double getSalary(){
			return salary;
		}

	// 打印信息
	public void printEmployee() {
		System.out.println(this);
	}

	// 重写 toString 方法
	@Override
	public String toString() {
		return "名字: " + name + "\n" +
				"年龄: " + age + "\n" +
				"职位: " + designation + "\n" +
				"薪水: " + salary;
	}
}

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该 

引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

在类中访问类的变量时，尽量养成使用this的习惯，防止出现形参赋值给形参的情况

默认初始化

对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如

数据类型	默认值
byte	0
char	'\u0000'
short	0
int	0
long	0L
boolean	false
float	0.0f
double	0.0
reference	null

6.源文件声明规则

当在一个源文件中定义多个类，并且还有 import 语句和 package 语句时，要特别注意这些规则。

一个源文件中只能有一个 public 类
一个源文件可以有多个非 public 类
源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

7.封装

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

7.1访问限定符

范围	private	default	protected	public
同一包中的同一类	✔	✔	✔	✔
同一包中的不同类		✔	✔	✔
不同包中的子类			✔	✔
不同包中的非子类				✔

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

【说明】

protected主要是用在继承中，继承部分详细介绍

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

7.2实现Java封装的步骤

1.修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
    private String name;
    private int age;
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2.对每个值属性提供对外的公共方法访问，也就是创建一对赋取值的方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下，这些方法被称为getter和setter方法。

因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

8.Java包（Package）

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间

包的作用

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

8.1 创建包

基本规则 

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 io.github.sirens007 )

包名要和代码路径相匹配. 例如创建io.github.sirens007的包, 那么会存在一个对应的路径 io.github.sirens007来存储代码.

如果一个类没有 package 语句, 则该类被放到一个默认包中.

即图中软件包，点击后输入 io.github.sirens007则会创建一个三级目录

8.2 import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。

在 Java 中，import 关键字用于导入其他类或包中定义的类型，以便在当前源文件中使用这些类型。

import 关键字用于引入其他包中的类、接口或静态成员，它允许你在代码中直接使用其他包中的类，而不需要完整地指定类的包名。

在 java 源文件中 import 语句必须位于 Java 源文件的头部，其语法格式为：

import package1[.package2…].(classname|*);

import 语句位于 package 语句之后：

// 第一行非注释行是 package 语句
package com.example;
 
// import 语句引入其他包中的类
import java.util.ArrayList;
import java.util.List;
 
// 类的定义
public class MyClass {
    // 类的成员和方法
}

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

可以使用 import语句来引入一个特定的类：

import  io.github.sirens007;

这样，你就可以在当前源文件中直接使用 sirens007 类的方法、变量或常量。

也可以使用通配符 * 来引入整个包或包的子包：

import io.sirens007.mypackage.*;

这样，你可以导入 io.sirens007.mypackage 包中的所有类，从而在当前源文件中使用该包中的任何类的方法、变量或常量。注意，使用通配符 * 导入整个包时，只会导入包中的类，而不会导入包中的子包。

在导入类或包时，你需要提供类的完全限定名或包的完全限定名。完全限定名包括包名和类名的组合，以点号 . 分隔

import java.util.ArrayList; // 引入 java.util 包中的 ArrayList 类
import java.util.*; // 引入 java.util 包中的所有类

import com.example.MyClass; // 引入 com.example 包中的 MyClass 类
import com.example.*; // 引入 com.example 包中的所有类

8.2.1 常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要 

6. java.io:I/O编程开发包。

8.3 Package 的目录结构

类放在包中会有两种主要的结果：

包名成为类名的一部分，正如我们前面讨论的一样。
包名必须与相应的字节码所在的目录结构相吻合。

下面是管理你自己 java 中文件的一种简单方式：

将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java作为扩展名。例如：

// 文件名 :  Car.java
package vehicle;
 
public class Car {
   // 类实现  
}

接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。

....\vehicle\Car.java

现在，正确的类名和路径将会是如下样子：

类名 -> vehicle.Car
路径名 -> vehicle\Car.java (在 windows 系统中)

通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。

例如：有一个 io.github.test 的包，这个包包含一个叫做 Hello.java 的源文件，那么相应的，应该有如下面的一连串子目录：

....\io\github\test\Hello.java

编译的时候，编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件，输出文件的名字就是这个类型的名字，并加上 .class 作为扩展后缀。例如：

// 文件名: Hello.java
 
package io.github.test;
public class Hello {
      
}
class Google {
      
}

现在，我们用-d选项来编译这个文件，如下：

$javac -d . Hello.java

这样会像下面这样放置编译了的文件：

.\io\github\test\Hello.class
.\io\github\test\Google.class

你可以像下面这样来导入所有 \io\github\test\ 中定义的类、接口等：

import io.github.test.*;

编译之后的 .class 文件应该和 .java 源文件一样，它们放置的目录应该跟包的名字对应起来。但是，并不要求 .class 文件的路径跟相应的 .java 的路径一样。你可以分开来安排源码和类的目录。

<path-one>\sources\io\github\test\Hello.java
<path-two>\classes\io\github\test\Google.class

这样，你可以将你的类目录分享给其他的编程人员，而不用透露自己的源码。用这种方法管理源码和类文件可以让编译器和java 虚拟机（JVM）可以找到你程序中使用的所有类型。

9.static 成员

9.1static 修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

它与类相关而不是与实例相关，即无论创建多少个类实例，静态变量在内存中只有一份拷贝，被所有实例共享。

重点：类的静态成员变量特性

1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3.静态类变量存储在方法区中

4.生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

类的加载和卸载

加载（Load）：当你第一次使用这个类（比如 new、访问静态变量/方法）时，JVM 的类加载器会把它加载到 方法区。

卸载（Unload）：当一个类不再被任何地方使用时，JVM 才有可能把它卸载。

9.2static 修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

重点：静态方法特性

1.不属于某个具体的对象，是类方法

2.可以通过对象调用，也可以通过 类名.静态方法名(...)方式调用，更推荐类名调用

3.不能在静态方法中访问任何非静态成员变量

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

5. 静态方法无法重写，不能用来实现多态(此处大家暂时不用管，后序多态位置详细讲解)。

补充第三点：

静态变量/方法（static）
属于 类本身，不依赖某个对象，类一加载就存在。
调用方式：类名.方法() 或者 对象.方法()（其实推荐用类名）。
非静态变量/方法（实例成员）
属于 对象实例，必须通过 new 出来的对象才会存在。
调用方式：对象.方法()。

Q1:为什么静态方法不能访问非静态变量呢

因为静态方法执行的时候，对象可能还没有创建

eg:

class Demo {
    int age = 10;         // 非静态变量（实例变量）
    static int count = 0; // 静态变量

    static void printInfo() {
        System.out.println(age); // ❌ 报错！
    }
}

运行逻辑：

JVM 加载 Demo 类时，count 已经存在（方法区 / 元空间里）。
但是 age 是实例变量，只有在执行 new Demo() 时，才会分配内存到堆里。
static void printInfo() 可能在没有任何对象的时候被调用，这时 JVM 不知道该取哪个对象的 age。

所以编译器直接禁止你在静态方法里访问 age。

Q2:. 静态方法中为什么不能调用任何非静态方法？

我们先复习一下静态和非静态方法

静态方法
属于类本身，类加载时就存在，不依赖对象。调用时 JVM 直接用「类信息」执行，不需要 new 对象。

非静态方法
属于对象实例，必须依赖对象才能调用。JVM 在调用时，默认会传入一个隐藏的 this 指针，告诉方法「我是谁」，这样方法才能访问对象里的实例变量。

他们的关键区别在于是否有this

调用非静态方法时，编译器会在字节码层面自动加上 this。
比如写：

obj.sayHello();

编译后相当于：

Demo.sayHello(obj);

调用静态方法时，不存在 this，因为它不依赖对象。

Demo.staticHello();

编译后就是单纯的 Demo.staticHello()，没有对象上下文

因此静态方法里没有this，所以编译器根本不知道你想让哪个对象去执行这个非静态方法。

解决办法：

方法一：在静态方法里创建对象

static void test() {
    Demo d = new Demo();
    d.sayHello(); // ✅ 通过对象调用非静态方法
}

方法二：把目标方法也改成静态

static void sayHello() {
    System.out.println("Hello from static method");
}

static void test() {
    sayHello(); // ✅ 直接调用
}

总结就是： 静态方法不能调用非静态方法，是因为静态方法没有 this，而非静态方法必须依赖 this 才能运行

9.3static 成员变量初始化

初始化方法有以下：

1.就地初始化

2.通过get、set方法初始化

3.构造方法初始化（相对较少）

4.代码块初始化

10.代码块

10.1 代码块分类

使用{}定义的一段代码称为代码块，根据代码块定义的位置以及关键字，又可分为以下四种：

静态代码块（一般用于初始化静态成员变量）
非静态代码块/实例代码块/构造代码块
同步代码块...

代码块执行顺序

静态代码块 -> 实例代码块 -> 构造方法

注意： 静态代码块只会执行一次（涉及知识点：双亲委派模型

补充：如果静态/实例代码块有平级，那么就和他们各自类型的先后顺序有关系

构造方法主要看调用了的哪个构造

注意事项 

静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
实例代码块只有在创建对象时才会执行

public class Main{
    String number = "123";
    {
        number = "125";
        System.out.println("eg coder");
    }

    Main(String number){
        this.number = number;
        System.out.println("struction func");
    }

    static{
        String number = "124";
        System.out.println("static coder");
    }
}


//输出结果：
//static coder
//eg coder
//struction func

对象的打印

平常我们直接打印对象时，会直接输出对象名+ @ +一串字符 这实际上是toString默认方法

如图下

但当我们自己写上了toString方法的时候，就会输出我们自己想要的内容了

快捷键：Alt+Insert选中toString即可（静态方法默认不输出，需要可自己补充）

Java 语法基础（二）：运算符、流程控制与数组

Tue, 16 Sep 2025 00:00:00 GMT

第四节.运算符

1.仅补充%

System.out.println(10%3);//1
System.out.println(-10%3);//-1
System.out.println(10%-3);//1
System.out.println(-10%-3);//-1

2.前置++与后置++

可以理解为+号在前面就先加，加号在后面就不加

int a = 1;
int b = ++a;
int c = a++;

System.out.println(b);	//2
System.out.println(c);	//1

//但要注意
a=a++;	//1,与c++不同

3.关系运算符

< , > , <= , >= ,== 返回值：true or false;

4.逻辑运算符

运算符	作用	示例	结果
`&&`	逻辑与（都为真才真）	`true && false`	`false`
`		`	逻辑或（有一个真就真）
`!`	逻辑非（取反）	`!true`	`false`

逻辑与

1.两个表达式必须都是布尔表达式

2.如果第一个表达式为假，那么就不会执行第二个表达式

逻辑或

1.两个表达式必须都是布尔表达式

2.只要有一个为真，那么整体为真

3.假设第一个为真，那么第二个就不会执行

逻辑非

1.作用在布尔表达式

& 和 | 如果表达式结果为 boolean 时，也表示逻辑运算，但与 && || 相比，他们不支持短路求值，

如果两边不是布尔表达式，那么还是按位与按位或操作

System.out.println(10 > 20 & 10 / 0 ==0)l;		//程序输出异常
System.out.println(10 < 20 | 10 / 0 ==0)l;		//程序输出异常

他们逻辑符号两侧都会执行

5.位运算符

按位与

00001010
00010100
---------
00000000

按位或

00001010
00010100
---------
00011110

按位异或：如果该位为 0 则转为 1，如果该位为 1 则转为 0

注意：

1.左移1位，相当于原数字 *2，左移N位，相当于原数字 *2 的N次方.

2.右移1位，相当于原数字 /2，右移N位，相当于原数字 /2 的N次方.

3.偶遇计算机计算位移效率高于计算乘除，当某个代码正好乘除 2 的N次方的时候可以用位移运算代替.

4.移动负数位或者移位位数过大都没有意义.

第五节.循环语句

for 循环

适合：已知次数的循环

for (int i = 1; i <= 5; i++) {
    System.out.println("第 " + i + " 次执行");
}

执行结果：打印 1 到 5。

while 循环

适合：不知道循环次数，但有一个条件控制

int i = 1;
while (i <= 5) {
    System.out.println("第 " + i + " 次执行");
    i++;
}

和上面的效果一样。

do...while 循环

至少执行一次，再判断条件。

int i = 1;
do {
    System.out.println("第 " + i + " 次执行");
    i++;
} while (i <= 5);

和 while 的区别是：

- `while`：先判断，再执行。
- `do...while`：先执行，再判断。

switch语句

适合选项

switch(表达式){
    case 常量值1:{
        语句1;
        [break;]
    }
    case 常量值2:{
        语句2;
        [break;]
    }
    ...
    default:{
        内容都不满足时执行语句;
        [break;]
    }
}

多个case后的常量值不可以重复

switch的括号内只能是以下类型的表达式：

基本类型：byte、char、short、int，注意不能是long类型
引用类型：String常量串、枚举类型

第六节.数组（Array）

什么是数组？

数组就是 一组相同类型的数据 的集合。
它可以用一个名字存放多个数据，并通过 下标（索引） 来访问。

例子：

int[] scores = {95, 88, 76, 100};
System.out.println(scores[0]); // 输出第一个元素 95
System.out.println(scores[3]); // 输出第四个元素 100

👉 注意：数组的下标是 从 0 开始 的。

数组的声明与初始化

数组的初始化主要分为动态初始化以及静态初始化。

1. 动态初始化：在创建数组时，直接指定数组中元素的个数 

int[] array = new int[10];

2. 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定 

语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan};

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

【注意事项】

静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。

静态初始化时, {}中数据类型必须与[]前数据类型一致。

静态初始化可以简写，省去后面的new T[]。

3.数组初始化内容

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.0
char	/u0000
boolean	false

遍历数组

用循环来访问数组的所有元素：

int[] arr = {10, 20, 30, 40, 50};
for (int i = 0; i < arr.length; i++) {
    System.out.println("第 " + (i+1) + " 个元素：" + arr[i]);
}

这里 arr.length 表示数组的长度。

5.二维数组

数据类型[][] 数组名称 = new 数据类型 [行数][列数];
数据类型[][] 数组名称 = new 数据类型 [][] { 初始化数据 };
数据类型[][] 数组名称 = new 数据类型 [行数][];

补充对二维数组是一维数组的深度理解

int[][] array ={{1,2,3},{4,5,6}};
System.out.println(array.length); //2
System.out.println(array[0].length);//3
System.out.println(Arrays.toString(array[1])); //[4, 5, 6]
String ret = System.out.println(Arrays.deepToString(array));
System.out.println(ret);	//[[1,2,3],[4,5,6]]

其中array的底层为图中所示

数组补充内容

1. 找最大值和最小值

思路：

假设第一个元素是最大/最小值。
遍历数组，依次比较更新。

int[] arr = {12, 45, 7, 89, 23};
int max = arr[0];
int min = arr[0];

for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
    if (arr[i] < min) {
        min = arr[i];
    }
}
System.out.println("最大值：" + max);
System.out.println("最小值：" + min);

2. 倒序输出数组

有时我们希望反过来输出：

int[] arr = {1, 2, 3, 4, 5};
for (int i = arr.length - 1; i >= 0; i--) {
    System.out.print(arr[i] + " ");
}

👉 这个思路也能用于「数组反转」。

3. for each遍历（增强 for 循环）

Java 提供了简化的遍历写法（但不能改变数组里的值）：

int[] arr = {10, 20, 30};
for (int num : arr) {
    System.out.println(num);
}

4. 多维数组（二维数组）

二维数组 = 表格。
比如存放学生成绩（3 个学生，每人 2 门课）：

int[][] scores = {
    {90, 85},
    {70, 88},
    {100, 95}
};
System.out.println(scores[0][1]); // 第1个学生的第2门课成绩 85

Java 语法基础（一）：标识符、数据类型与变量

Wed, 03 Sep 2025 00:00:00 GMT

第一节.标识符

即：在程序中由用户给类名、方法名或者变量所取的名字。

有效字符：数字、字母、下划线、美元符号

其中不能以数字开头，不能是关键字除（main），可以以下划线、美元符号开头

public class Main {
    //psvm
    public static void main(String[] args) {
    }
}

注意：

1.java的数组的定义方式：int[] array

C语言数组的定义方式：int arr[] 其中int[]才为类型，因此java是修正过来了

2.在java当中，函数叫做方法。

第二节.关键字

用于定义访问权限修饰符的关键字
private	protected	public
用于定义类，函数，变量修饰符的关键字
abstract	final	static	synchronized
用于定义类与类之间关系的关键字
extends	implements
用于定义建立实例及引用实例，判断实例的关键字
new	this	super	instanceof
用于异常处理的关键字
try	catch	finally	throw	throws
用于包的关键字
package	import
其他修饰符关键字
native	strictfp	transient	volatile	assert

第三节.数据类型与变量

数据类型

类型	占用内存	例子	说明
`byte`	1 字节	`byte b = 100;`	-128 ~ 127
`short`	2 字节	`short s = 1000;`	范围比 int 小
`int`	4 字节	`int age = 20;`	最常用整数类型
`long`	8 字节	`long bigNum = 100000L;`	末尾加 `L`
`float`	4 字节	`float pi = 3.14f;`	小数，末尾加 `f`
`double`	8 字节	`double price = 19.99;`	最常用小数类型
`char`	2 字节	`char grade = 'A';`	单个字符，用 `' '`
`boolean`	1 位	`boolean isOk = true;`	只有 `true` 或 `false`

此处char与c++有所不同，c++为1个字节，并且java不区分32或64位操作系统

变量

变量的命名规则

只能用 字母、数字、下划线、美元符号，且不能以数字开头
不能用 Java 关键字（如 class、int）
见名知意（推荐小驼峰命名法：myName）

double a = 1.1;
double b = 1.1;
System.out.println(a*b);
//1.2100000000000002

此处和浮点数的存储有关系

float double

精度：float 小数点后6位

1.123456789

浮点型变量

double注意事项：

1.double在任何系统下都占8个字节

2.浮点数与整数在内存中的存储方式不同，不能单纯使用2n的形式来计算

3.double的包装类型为Double

4.double类型的内存布局遵守 IEEE 754 标准（和C语言一样），尝试使用有限的内存空间表示可能无限的小数，势必会存在一定的精度误差，英雌浮点数是个近似值，并不是精确值。

float注意事项：

1.float类型在java中占4个字节，同样遵循 IEEE 754 标准，由于表示的数据精度范围小，一般在工程上用到浮点数都优先考虑double，不太推荐使用float，float的包装类型为Float。

字符型变量

char注意事项：

1.java中使用单引号 + 单个字母 的形式表示字符字面值。

2.计算机中的字符本质上是一个整数，在C语言中使用ASCll表示字符，而java中使用 Unicode 表示字符因此一个字符占用两个字节，表示的字符种类更多，包括中文。所以Unicode的字符集比ASCll要大

布尔型变量

boolean注意事项：

1.boolean 类型的变量只有两种取值，true表示真，false表示假

2.java 的 boolean 类型和int 不能相互转换，不存在 1表示true，0表示false 这样的用法。

类型转换

在java中，当参与运算数据类型不一致时，就会进行类型转换，java中类型转换主要分为两种：自动类型转换(隐式) 和强制类型转换(显式)。

自动类型转换（隐式）：

自动类型转换即：在代码编译时，编译器会自动进行处理；

特点：数据范围小的转为数据范围大的时会自动进行。

转换只发生在赋值的过程里，变量本身的类型不会改变。

//整数类型的范围关系是：
byte < short < int < long < float < double

int a = 10;
long b = 10L;
b = a; 			//编译器会自动将int提升为long
b = (long) a;	//编译器自动帮你加上(long)

强制类型转换（显式）：

强制类型转换：代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的。

float f = 3.14f;
double d = 3.14;
f =(float) d;	// float -> double,数据范围由大到小，需要强转，否则编译失败

//补充：
//当你参与运算的数据 小于4个字节的很好 会进行提升
byte a = 10;
byte b = 20;
//byte c = (byte)(a+b) //因为a + b会自动提升类型为int，底层为避免溢出而设计
int c = a+b;

注意：

1.不相干的类型，不能进行强制类型转换。

2.将一个字面值常量进行赋值的时候，java 会自动针对数字范围进行检查。

补充：题目

short a = 128;
byte b = (byte)a;
System.out.println(b); // -128

原因：Java 的整数都是 二进制补码存储

short 占 16 位（2 字节），范围是 -32768 ~ 32767。
byte 占 8 位（1 字节），范围是 -128 ~ 127。

重点：当你从大类型（short）强制转换到小类型（byte）时，只会保留低 8 位，高位直接丢弃。

拆解过程：

Step 1：128 的二进制（short，16 位）

0000 0000 1000 0000   （十六进制：0x0080）

Step 2：强制转换为 byte（取低 8 位）

1000 0000

Step 3：解释这个 8 位二进制（byte 类型）

在 Java 中，byte 是有符号的，范围是 -128 ~ 127。
1000 0000 的最高位是 1，说明它是一个负数（补码形式）。

补码 → 原码的过程：

1000 0000 （补码）
= -128    （这是 byte 的最小值）

字符串类型

注意：

1.java当中的字符串不是以\0结尾的

2.当字符串和整数还在一起使用+号的意思就是一个拼接的意思

eg:

int a = 10,b = 20;
System.out.println("a:"+a + b);//a:1020
//原因：a:+a已经拼接表示为字符串了，因此该整体再与b之间也是拼接关系

部分情况下，需要将字符串和整型数字之间进行转换：

1.int 转成 String

int num = 10;
//mean1
String str1 = num + "";
//mean2
String str2 = String.valueOf(num);

2.String 转成 int

String str = "100";
int num = Integer.parseInt(str);

Git 日常使用指南：版本回退、分支管理与远程仓库

Wed, 27 Aug 2025 00:00:00 GMT

📝以自己经验用Git

1.Git基础概念

Git = word写文档 GitHub = 腾讯文档分享协作

Git三个区域

工作区（Working Directory）—— 你正在编辑的文件
  ↓ git add
暂存区（Staging Area）—— 即将提交的快照
  ↓ git commit
版本库（Repository）—— Git 保存的历史记录

完整的开发流程通常是：

# 修改代码
git add 文件名             # 添加文件到暂存区
git commit -m "说明信息"   # 提交暂存区到版本库

2.本地 Git 仓库操作

以下内容是指在终端中使用

git config --global user.name "待填入名字"
git config -- global user.email "待填入邮箱"	#建议使用注册GitHub的用户名和邮箱，便于同步
                                  # --global 表示在你这台电脑上的所有仓库都使用这套设置。

git init #建立Git仓库，初始化Git仓库
         #或者从GitHub上拉一个项目（如刚创建了远程仓库）
git clone https://github.com/Sirens007/MyStorage.git

#如创建一个新文件
echo "#我的第一个项目" > README.md
#添加到Git暂存区
git add README.md
#提交到本地仓库
git commit -m "添加了README文件"
#绑定 GitHub 仓库作为远程仓库 origin	（即origin为远程仓库昵称）
git remote add origin https://github.com/Sirens007/MyStorage.git
#首次推送GitHub
git push -u origin main #如果提示 main 不存在，可以先用 git branch -M main 把默认的 master 分支改名。

git status
#查看当前工作状态 （如查看还未暂存的文件
git log
#查看提交历史

3.查看状态与差异

当你已经完成了基本的 add 和 commit 操作后，日常开发中你最常用的两个命令是：

git status：查看当前仓库状态
git diff：查看文件内容发生了哪些改动

一、git status —— 查看状态

git status

作用：

查看当前工作区和暂存区的状态。

原理解释：

Git 会比较这三者的内容是否一致：

工作目录中的文件
暂存区中的文件（通过 git add 添加的）
最后一次提交的版本（历史）

<h4 id="98be1ecf">🔴 情况1：工作区干净</h4> <pre data-language="bash" id="WQi54" class="ne-codeblock language-bash"><code>$ git status On branch master nothing to commit, working tree clean</code></pre> 意思是：没有文件被修改，也没有新增或删除。

<h4 id="3e1a3f71">🟡 情况2：修改了文件但还没 add</h4> <pre data-language="bash" id="ZGtno" class="ne-codeblock language-bash"><code>$ git status modified: hello.txt</code></pre> 说明 <code class="ne-code">hello.txt</code> 有改动，但还没有被添加进暂存区。

<h4 id="c160fd94">🟢 情况3：已 add 到暂存区但还没 commit</h4> <pre data-language="bash" id="L2q4R" class="ne-codeblock language-bash"><code>$ git status Changes to be committed: (use "git restore --staged <file>..." to unstage) modified: hello.txt</code></pre> </details>

二、git diff —— 查看修改内容

git diff

作用

显示当前工作目录中未加入暂存区的变更（对比的是：工作区 ↔ 暂存区）

你也可以用：

git diff hello.txt

来查看某个具体文件的改动。

<details class="lake-collapse"><summary id="u423a2fc5">补充</summary><h4 id="k8LQy">查看已经 add 但还未 commit 的差异：</h4><pre data-language="bash" id="J3Z0b" class="ne-codeblock language-git"><code>git diff --cached</code></pre>或者：<pre data-language="bash" id="cEllX" class="ne-codeblock language-git"><code>git diff --staged</code></pre><h4 id="u539c">作用：</h4><ul class="ne-ul"><li id="udf0dfced" data-lake-index-type="0">查看“暂存区”中与“上一次提交版本”之间的差异。</li></ul></details>

4.文件恢复与版本回退

开发中你经常会遇到这些情况：

场景	想做的事
改错文件了	想恢复回之前保存的版本
add 错文件了	想撤回到未暂存状态
commit 之后后悔了	想撤销或回退提交
改了很多但不想要了	想恢复整个文件夹到之前状

本节主要命令：

git restore：恢复文件内容（推荐）
git checkout：旧版本恢复（老派用法）
git reset：取消暂存、版本回退
git log：查看历史提交

一、恢复工作区文件：git restore

git restore <filename>

eg:
echo "bad line" >> hello.txt      # 加了一行错误内容
git restore hello.txt             # 撤销这次改动

作用：

把某个文件恢复到上一次 git add 或 git commit 之后的状态，取消你刚刚改的内容。

背后原理：

从 Git 暂存区或仓库中拿出该文件的版本，覆盖当前工作区。

二、撤销 git add：git restore --staged

git restore --staged <filename>

eg:
git add hello.txt
git restore --staged hello.txt  #撤回add，但改动还在

作用：

把文件从暂存区移除，但保留工作区的改动。

使用场景：

你 git add 了一个不该提交的文件，可以用这条命令撤回。

三、版本回退：git reset

命令：取消已经 add 的内容

git reset filename

等效于上面那句 git restore --staged，只是老一点的写法。

命令：回退到上一个提交版本（慎用）

git reset --hard HEAD

作用：

把整个项目（工作区 + 暂存区）恢复到上一次提交的状态。

❗❗ 注意：--hard 是“硬回退”，不可恢复的清空当前修改，一定要确认再用！

四、查看历史版本：git log

显示提交历史
会看到一堆 commit xxx... 的 ID、作者、时间、提交说明

git log

eg:
git log -p hello.txt	#查看历史内容改了什么

5.分支管理（分支的创建、切换、合并）

在实际开发中，我们经常会遇到这种需求：

不打扰主线代码，先试试一个新功能
多个开发人员各自写各自的功能
想在多个版本之间切换工作

这时，就要用到「分支（branch）」来隔离、管理不同的开发线。

补充对分支的理解，如我在main分支创建了a.txt （未add），此时创建dev分支可以看见main分支对a.txt的更改。但如果我在dev上commit之后，回到main之后则不存在a.txt文件了，就相当于两个工作区一样

Git 分支基本概念

主分支：默认叫 master（或 main）
分支的本质：一个指向某次提交的“指针”
HEAD：指向当前分支的位置（你正在干活的分支）

1.查看已有分支： git branch 分支名

git branch

会列出当前所有分支，当前所在的分之前有*标记

2.创建新分支：git branch 分支名

git branch dev

创建一个名为dev的新分支，复制自当前分支的最新提交。

3.切换分支：git switch 分支名

git switch dev

此时已切换dev分支，开始在上面开发了
如果是老版本Git，也可以用git checkout dev。

4.创建并切换新分支：一条命令搞定

git switch -c dev

相当于：

git branch dev
git switch dev

Git 会尝试把dev上的改动合并进master，如果没有冲突，会自动完成。

5.合并分支：git merge

切换会主分支后，合并新分支的内容：

git switch main
git merge dev

Git 会尝试把dev上的改动合并进main，如果没有冲突，会自动完成。

6.删除分支（合并后清理）：git branch -d

git branch -d dev

如果你确认合并完了，就可以删掉旧分支。

6.搭建ssh远程连接（无需梯子）

一、配置git bash

在git bash中运行以下：

ssh-keygen -t ed25519 -C "你的GitHub邮箱"

当提示：

Enter file in which to save the key (~/.ssh/id_ed25519):

你可以直接回车（会覆盖旧的 id_ed25519）
或者输入一个新名字，比如：

~/.ssh/id_ed25519_laptop

二、启用新的ssh key

eval "$(ssh-agent -s)"

ssh-add ~/.ssh/id_ed25519_laptop

三、把公钥加到Github

cat ~/.ssh/id_ed25519_laptop.pub

复制整段（从 ssh-ed25519 开始到最后），
然后在 GitHub → Settings → SSH and GPG keys → New SSH key → 粘贴保存。
标题建议写成 “Laptop - 2025” 这种好区分的名字。

四、验证

ssh -T git@github.com

看到：

Hi Sirens007! You've successfully authenticated...

说明配置成功

7.远程仓库操作

1.远程仓库概念

本地 Git 仓库 = 你电脑上的版本库（.git 目录）。
远程仓库 = 存在于服务器（比如 GitHub）上的版本库。

2.四个常用操作

（1）clone - 从远程仓库下载到本地

git clone https://github.com/Sirens007/MyStorage.git

#运行后，你本地就有一个 myproject 目录，并且可以直接 git pull 或 git push。

作用：

会在本地新建一个文件夹
自动把该仓库的所有版本历史下载到本地
自动设置好 origin 这个远程名，指向该仓库

（2）remote - 管理远程仓库地址

查看已有远程：

git remote -v

添加远程：

git remote add origin https://github.com/Sirens007/MyStorage.git

修改远程：

git remote set-url origin <新地址>

删除远程：

git remote remove origin

origin 是默认的远程仓库名字，你也可以用别的名字。

（3）push - 推送本地代码到远程

第一次推送（如果远程没有内容）：

git push -u origin main

解释：

origin：远程仓库名
main：分支名
-u：记住这个推送目标，下次可以直接git push

之后推送就可以：

git push

（4）pull - 从远程拉取最新版本

git pull origin main

作用：

把远程 main 分支的最新提交下载到本地
并与本地当前分支合并

如果远程没有变化，你会看到：

Already up to date.

（5）远程分支与本地分支的关系

当你执行 git clone 或 git fetch 后，Git 会在本地维护远程分支的快照，叫做 远程跟踪分支，格式一般是 origin/分支名。
本地分支和远程分支是分开的，推送（push）和拉取（pull）就是它们之间的同步操作。

（6）查看远程分支

git branch -r

只列出远程仓库的分支

git branch -a

本地和远程所有分支都会显示

（7）跟踪远程分支的新建本地分支

如果远程有个分支，你想在本地工作，需要先新建一个本地分支跟踪远程：

git switch-c dev origin/dev

这会基于远程dev分支新建本地dev分支

（8）远程仓库冲突解决

多人合作时，推送可能被拒绝，提示远程有更新需要先拉取：

git push
To https://github.com/xxx.git
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to 'https://github.com/xxx.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. ...

这时，需要先拉取远程的最新修改：

git pull --rebase origin main

--rebase 表示把你的提交“挪到”最新远程修改之后，避免额外合并提交。

（9）查看远程仓库详情

git remote show origin

可以看到：

远程分支状态
你本地分支对应的上游分支
是否有可推送或拉取的内容

Mizuki 博客部署指南：本地构建与 GitHub Pages 发布

Wed, 27 Aug 2025 00:00:00 GMT

环境依赖

在开始使用 Mizuki 之前，您需要确保系统满足以下要求：

Node.js >= 20
pnpm >= 9
Git

安装Node.js

访问 Node.js 官网下载并安装最新版本的 Node.js。建议使用 LTS 版本。

安装完成后，打开终端或命令提示符，运行以下命令验证 Node.js 是否安装成功：

node -v
npm -v

如果显示版本号，则表示安装成功。

安装pnpm

如果您尚未安装 pnpm，可以通过 npm 安装：

npm install -g pnpm

安装完成后，打开终端或命令提示符，运行以下命令验证 pnpm 是否安装成功：

pnpm -v

如果显示版本号，则表示安装成功。

安装Git

访问 Git 官网下载并安装适合您操作系统的 Git 版本。

安装完成后，打开终端或命令提示符，运行以下命令验证 Git 是否安装成功：

git --version

如果显示版本号，则表示安装成功。

项目启动

1.克隆项目

首先将模板拉下到本地仓库

git clone https://github.com/matsuzaka-yuki/Mizuki.git
cd ...//cd到项目地址处

2.安装依赖

使用 pnpm 安装项目依赖：

pnpm install

3.配置博客

在启动项目之前，您需要根据自己的需求进行配置：

编辑 src/config.ts 文件来自定义博客设置
更新站点信息、主题颜色、横幅图片和社交链接
配置翻译设置和特殊页面功能

4.启动开发服务器

运行以下命令启动开发服务器：

pnpm dev

启动成功后，您可以在浏览器中访问 http://localhost:4321 查看您的博客。

5.打包网站

在本地项目处运行以下命令将网站打包成静态文件，生成到 dist 目录中：

pnpm build

生成的 dist 目录可以部署到您自己的服务器上。

部署到GitHub Pages

如果您希望将博客托管在 GitHub Pages 上，Mizuki 项目通常会包含一个 GitHub Actions 工作流，可以帮助您自动化部署过程。您需要确保在 astro.config.mjs 中配置正确的 base 路径。

还有将package.json的script中加入

{
  "scripts": {
    "build": "vite build",  
    "deploy": "gh-pages -d dist -r https://github.com/<你的用户名>/<你的仓库名>.git"
  }
}

总共要改的配置文件为astro.config.mjs、package.json、src/config.ts

部署到 github.io 网址

在 astro.config.mjs 中配置文件设置 site 和 base 选项。

import { defineConfig } from 'astro/config'

export default defineConfig({
  site: 'https://sirens007.github.io/',
  base: '/',
})

Site

site 的值必须是以下之一：

基于你的用户名的以下网址: https://<username>.github.io
为 GitHub 组织的私有页面自动生成的随机网址：https://<random-string>.pages.github.io/

提示

如果出现了以下情况，则不要设置 base 参数：

你的页面是由根文件夹所提供。

你的源码存储库是位于 https://github.com/<USERNAME>/<USERNAME>.github.io。

Base

base 的值应该是你的仓库名称，以正斜杠开头，例如 /my-blog。这样做是为了让 Astro 理解你的网站根目录是 /my-repo，而不是默认的 /。

注意

当配置了这个值后，你所有的内部页面链接都必须以你的 base 值作为前缀：

<a href="/my-repo/about">关于本站</a>

查看更多关于配置 base 值的信息。

（可选）在GitHub Pages上使用自定义域名

设置一个自定义域

你可以选择通过将一个 ./public/CNAME 文件添加到你的项目中，来设置自定义域

这会将你的站点部署在你的自定义域而不是 <YOUR_USERNAME>.github.io。

不要忘记为你的域名提供商配置 DNS。

要配置 Astro 以在 GitHub Pages 上使用自定义域名，请将你的域名设置为 site 的值。不要为 base 设置值：

import { defineConfig } from 'astro/config'

export default defineConfig({
    site: 'https://example.com',
})

方法一：配置GitHub Action

在你的项目中的 .github/workflows/ 目录创建一个新文件 deploy.yml，并粘贴以下 YAML 配置信息。

name: Deploy to GitHub Pages

on:
# 每次推送到 `main` 分支时触发这个“工作流程”
# 如果你使用了别的分支名，请按需将 `main` 替换成你的分支名
push:
    branches: [ main ]
# 允许你在 GitHub 上的 Actions 标签中手动触发此“工作流程”
workflow_dispatch:

# 允许 job 克隆 repo 并创建一个 page deployment
permissions:
contents: read
pages: write
id-token: write

jobs:
build:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout your repository using git
        uses: actions/checkout@v4
    - name: Install, build, and upload your site
        uses: withastro/action@v3
        # with:
        # path: . # 存储库中 Astro 项目的根位置。（可选）
        # node-version: 20 # 用于构建站点的特定 Node.js 版本，默认为 20。（可选）
        # package-manager: pnpm@latest # 应使用哪个 Node.js 包管理器来安装依赖项和构建站点。会根据存储库中的 lockfile 自动检测。（可选）

deploy:
    needs: build
    runs-on: ubuntu-latest
    environment:
    name: github-pages
    url: ${{ steps.deployment.outputs.page_url }}
    steps:
    - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

（可选）如果你在本地开发期间或预览构建期间，将环境变量传入给 Astro 项目，则需要定义 deploy.yml 文件中的任何公共变量，以便在部署到 Github 页面时处理它们。

jobs:
build:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout your repository using git
        uses: actions/checkout@v4
    - name: Install, build, and upload your site
        uses: withastro/action@v3
        env:
        # 使用单引号来包裹变量值
        PUBLIC_EVM_WALLET_ADDRESS: '0x4bFc229A40d41698154336aFF864f61083E76659'

在 GitHub 上，跳转到存储库的 Settings 选项卡并找到设置的 Pages 部分。
选择 GitHub Actions 作为你网站的 Source，然后按 Save。
选择 GitHub Actions 作为你网站的 Source，然后按 Save。

你的网站现在应该已完成发布了！当你将更改推送到 Astro 项目的存储库时，GitHub Action 将自动为你部署它们。

方法二：增加gh-pages分支

安装部署

pnpm add -D gh-pages

安装 gh-pages 包，它会帮你把 dist/ 目录推送到 GitHub 仓库的 gh-pages （自动创建）分支。

运行命令

pnpm run build → 生成 dist/
pnpm run deploy → 自动把 dist/ 上传到 GitHub Pages

日常维护

1.修改/新增文章或页面

在本地项目里（比如 src/content、posts、pages 等目录），新建或修改 Markdown/HTML/JSX 文件。

2. 重新构建

pnpm build

作用：把修改后的源代码再打包到 dist/ 目录。
原因：GitHub Pages 只会展示 dist 文件夹里的内容，而不会读取你的源代码。

3. 部署到 GitHub Pages

pnpm run deploy

作用：自动运行 gh-pages -d dist，把最新的 dist/ 推送到 gh-pages 分支。
原因：GitHub Pages 是根据 gh-pages 分支的内容来渲染你的网站的。

部署 | Mizuki主题官方文档

Git 协作工作流：分支、提交、推送与 Pull Request

Wed, 20 Aug 2025 00:00:00 GMT

📝Git工作流程

1.克隆仓库

如果你要参与一个已有的项目，通常会创建一个新的分支：

git clone https://github.com/username/repo.git
cd repo

2.创建新分支

为了避免直接在main或master分支上进行开发，通常会创建一个新的分支：

git checkout -b new-feature

3.工作目录

在工作目录中进行代码编辑、添加新文件或删除不需要的文件。

4.暂存文件

将修改的文件添加到暂存区，以便进行下一步的提交操作：

git add filename
# 或者添加所有修改的文件
git add .

5.提交更改

将暂存区的更改提交到本地仓库，并添加提交信息：

git commit -m "Add new feature"

6.拉取最新更改

推送本地更改之前，最好从远程仓库拉取最新的更改，以避免冲突：

git pull origin main
# 或者如果在新的分支上工作
git pull origin new-feature

7.推送更改

将本地的提交推送到远程仓库：

git push origin new-feature

8.创建Pull Request（PR）

在github或其他托管平台上创建Pull Request，邀请团队成员进行代码审查。PR合并后，你的更改就会合并到主分支。

9.合并更改

在PR审核通过并合并后，可以将远程仓库的主分支合并到本地分支：

git checkout main
git pull origin main
git merge new-feature

10.删除分支

如果不需要新功能分支，可以将其删除：

git branch -d new-feature

或者从远程仓库删除分支：

git push origin --delete new-feature

📝Git创建仓库

git init

Git使用git init命令来初始化一个Git仓库，Git的很多命令都需要在Git的仓库中运行，所以git init是使用Git的第一个命令。

在执行完git init命令后，Git仓库会生成一个.git目录，该目录包含了资源的所有元数据，其他的项目目录保持不变。

使用方法

进入想要创建仓库的目录，或者先创建一个新的目录：

mkdir my-project
cd my-project

使用当前目录作为Git仓库，我们只需使用它初始化。

git init

该命令执行完成后会在当前目录生成一个.git目录。

使用我们指定目录作为Git仓库。

git init newrepo

初始化后，会在newrepo目录下会出现一个名为.git的目录，所有Git需要的数据和资源都存放在这个目录中。

如果当前目录下有几个文件想要纳入版本控制，需要先使用git add 命令告诉Git开始对这些文件进行跟踪，然后提交：

git add *.c 	 #将所有.c文件纳入版本控制
git add README #添加README文件（一般为项目说明文档），可以是README.md、README.txt
git commit -m '初始化项目版本'  #

以上命令将目录一下以 .c 结尾及README文件提交到仓库中。

注：在Linux系统中，commit信息使用单引号 ' ，Windows系统，commit信息使用双引号"。

所以在git bash中 git commit -m '提交说明' 这样是可以的，在Windows命令行中就要使用双引号 git commit -m "提交说明"。

git clone

我们使用git clone 从现有的Git仓库中拷贝项目（类似svn checkout）。

克隆仓库的命名格式为：

git clone <repo>

如果我们需要克隆到指定的目录，可以使用以下命令格式：

git clone <repo> <directory>

参数说明：

repo:Git仓库
directory:本地仓库

比如，要克隆Ruby语言的Git代码仓库Grit，可以用下面的命令：

git clone git://github.com/Sirens007/MyStorage.git Mystorage
#git:为Git专属协议，类似https

#git clone git://github.com/Sirens007/MyStorage.git 是仓库地址，指向Github上名为MyStorage的仓库

配置

git的设置使用 git config 命令

显示当前的git配置信息：

$ git config --list
#输出以下信息
credential.helper=osxkeychain
core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
core.ignorecase=true
core.precomposeunicode=true

编辑git配置文件：

git config -e	#针对当前仓库

或者：

git config -e --global	#针对系统上所有仓库

设置提交代码时的用户信息：

git config --global user.name "Sirens007"
git config --global user.email "2921646312@qq.com"

如果去掉 --global参数支队当前仓库有效。

Git基本操作

Git 的工作就是创建和保存你项目的快照及与之后的快照进行对比。

本章将对有关创建与提交你的项目快照的命令作介绍。

Git常用的是以下6个命令：git clone、git push、git add、git commit、git checkout、git pull，之后会详细介绍

说明：

workplace：工作区
staging area：暂存区/缓存区
local repository：版本库或本地仓库
remote respository：远程仓库

一个简单的操作步骤：

git init
git add
git commit

git init - 初始化仓库。
git add - 添加文件到暂存区。
git commit - 将暂存区内容添加到仓库中。

创建仓库命令

git创建仓库的命令：

命令	说明
git init	初始化仓库
git clone	拷贝一份远程仓库，也就是下载一个项目

提交与修改

Git的工作就是创建和保存你的项目的快照及与之后的快照进行对比。

下表列出有关创建与提交你的项目的快照的命令：

命令	说明
git add	添加文件到暂存区
git status	查看仓库当前的状态，显示有变更的文件
git diff	比较文件的不同，即暂存区和工作区的差异
git difftool	使用外部差异工具查看和比较文件的更改
git range-diff	比较两个提交范围之间的差异
git commit	提交暂存区到本地仓库
git reset	回退版本
git rm	将文件从暂存区和工作区中删除
git mv	移动或重命名工作区文件
git notes	添加注释
git checkout	分支切换
git switch（Git 2.23版本）	更清晰地切换分支
git restore（Git 2.23版本）	恢复或撤销文件的更改
git show	显示Git对象的详细信息

提交日志

命令	说明
git log	查看历史提交记录
git blame <file>	以列表形式查看指定文件的历史修改记录
git shortlog	生成简洁的提交日志摘要
git describe	生成一个可读的字符串，该字符串基于Git的标签系统来描述当前的提交

远程操作

命令	说明
git remote	远程仓库操作
git fetch	从远程获取代码库
git pull	下载远程代码并合并
git push	上传远程代码并合并
git submodule	管理包含其他Git仓库的项目

Git文件状态

Git的文件状态分为三种：工作目录（Working Directory）、暂存区（Staging Area）、本地仓库（Local Repository）。

工作目录（Working Directory）

工作目录是你在本地计算机上看到的项目文件。它是你实际操作文件的地方，包括查看、编辑、删除和创建文件。所有对文件的更改首先发生在工作目录中。

在工作目录中的文件可能有以下几种状态：

未跟踪（Untracked）：新创建的文件，未被Git记录。
已修改（Modified）：已被Git跟踪的文件发生了更改，但这些更改还没有被提交到Git记录中。

暂存区（Staging Area）

暂存区，也被称为索引（Index），是一个临时存储区域，用于保存即将提交到本地仓库的更改。你可以选择性地将工作目录中的更改添加到暂存区中，这样你就可以一次提交多个文件的更改，而不必提交所有文件的更改。

使用git add <filename<filename>> 命令将文件从工作目录添加到暂存区。
使用git add . 命令将当前目录下的所有更改添加到暂存区。

本地仓库（Local Respository）

本地仓库是一个隐藏在 .git 目录中的数据库，用于存储项目的所有提交历史记录。每次你提交更改时，Git会将暂存区中的内容保存到本地仓库中。

使用 git commit -m "commit message" 命令将暂存区中的更改提交到本地仓库。

文件状态的转换流程

未跟踪（Untracked）： 新创建的文件最初是未跟踪的。它们存在于工作目录中，但没有被Git跟踪。

git add newfile.txt # 添加文件到暂存区

git status # 查看状态，显示 newfile.txt 在暂存区

已跟踪（Tracked）： 通过git add 命令将未跟踪的文件添加到暂存区后，文件变为已跟踪状态。

Syrena

Java 文件与 I/O 流：File、字节流、字符流与文件操作

1.File 概述

属性

构造方法

方法

2. 文件内容的读写--数据流

InputStream 概述

FileInputStream 概述

OutpuStream 概述

FileOutputStream 概述

Reader 概述

Writer 概述

示例一

示例二

示例三

Java Socket 编程：TCP、UDP 与回显服务器实践

1.网络编程

1.1 基本模型

2.Socket

2.1 TCP 协议特点

2.2 UDP 协议

2.3 UDP 数据包套接字编程

2.3.1 API 介绍

DatagramSocket

DatagramPacket

2.3.2 回显服务器示例

UDP Echo Server

UDP Echo Client

2.4 TCP 流套接字编程

2.4.1 API 介绍

ServerSocket

Socket

2.4.2 回显服务器示例

TCP Echo Server

TCP Echo Client

具体解释~

3.IO 多路复用（了解一下~）

网络通信基础：IP、端口、协议分层与数据封装

1. 网络通信基础

1.1 IP 地址

1.2 端口号

1.3 协议

1.4 五元组

2. 协议分层

2.1 同层之间遵守协议，相邻层之间使用服务

2.2 OSI 七层模型

2.3 TCP/IP 五层（或四层）模型

2.4 一则信息的全过程

2.4.1 数据发送

2.4.2 数据接收

Java 并发进阶（三）：线程安全容器与并发集合

1.线程安全的集合类

1.1 多线程下使用 ArrayList

自己使用同步机制（synchronized 或者 ReentrantLock）

Collections.synchronizedList()包装

CopyOnWriteArrayList写入时复制

1.2 多线程下使用队列

ArrayBlockingQueue

LinkedBlockingQueue

PriorityBlockingQueue

1.3 多线程下使用哈希表

HashMap 不负责线程同步

Hashtable把关键方法加锁

ConcurrentHashMap缩小需要互斥的范围

Java 并发进阶（二）：CAS、原子类与 JUC 工具

1.CAS

1.1 CAS 实现原子类

1.2 用 CAS 实现自旋锁

1.3 CAS 的 ABA 问题

ABA 问题解决

2.JUC 的常见类

2.1 Callable 接口

2.2 ReentrantLock

2.3 信号量 Semaphore

2.3.1 acquire()申请资源

2.3.2 release()释放资源

2.4 CountDownLatch

Java 并发进阶（一）：锁策略与 synchronized 原理

1.常见锁策略

1.1 多线程下使用 `ArrayList`

`Collections.synchronizedList()`包装

`CopyOnWriteArrayList`写入时复制

`ArrayBlockingQueue`

`LinkedBlockingQueue`

`PriorityBlockingQueue`

`Hashtable`把关键方法加锁

`ConcurrentHashMap`缩小需要互斥的范围

2.3.1 `acquire()`申请资源

2.3.2 `release()`释放资源

2.`synchronized` 原理

`ThreadPoolExecutor` 自定义线程池

`Executors`封装好的常用线程池

`shutdown()`方法

`awaitTermination()`方法

4.1 标准库中的`Timer`

1.初识线程 `Thread`

2.1 继承 `Thread`

2.2 实现 `Runnable` 接口

2.3.1 使用匿名内部类创建 `Thread`

2.3.2 使用匿名内部类创建 `Runnable`

2.3.3 使用 `Lambda` 创建线程

3.`Thread` 常用属性和方法

3.1 `Thread` 常见属性

3.2 `Thread` 常见构造方法

3.3 启动一个线程-`start()`

3.5 等待一个线程 - `join()`

5.`synchronized` 关键字

5.1 `synchronized` 的特性

5.2 `synchronized`使用示例

5.2.1 `synchronized` 修饰代码块

5.2.2 `synchronized` 修饰普通方法

6.`volatile` 关键字

7.`wait` 和 `notify`

7.1 `wait()` 方法

7.2 `notify()`方法

7.3 `notifyAll()` 方法