Merge branch 'master' of https://github.com/CyC2018/Interview-Notebook

2018-07-20 11:59:19 +08:00
parent 7098f855a9 1788a5c9de
commit 1cea4ba2aa
22 changed files with 813 additions and 294 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1 @@
+.DS_Store
--- a/BOOKLIST.md
+++ b/BOOKLIST.md
@ -12,6 +12,7 @@
 - [鸟哥的 Linux 私房菜](https://book.douban.com/subject/4889838/)
 - [Unix 环境高级编程](https://book.douban.com/subject/25900403/)
 - [Unix/Linux 编程实践教程](https://book.douban.com/subject/1219329/)
+- [Operating Systems: Three Easy Pieces (OSTEP)](http://pages.cs.wisc.edu/~remzi/OSTEP/)

 # 计算机网络

@ -63,7 +64,7 @@

 # 开发工具

- [Pro Git](https://book.douban.com/subject/3420144/)
+- [Pro Git](https://git-scm.com/book/zh/v2)
 - [正则表达式必知必会](https://book.douban.com/subject/2269648/)

 # 编码实践
--- a/README.md
+++ b/README.md
@ -1,4 +1,5 @@
-<!-- ![](https://img.shields.io/badge/update-today-blue.svg) ![](https://img.shields.io/badge/gitbook-making-lightgrey.svg)</br> -->
+[![](https://img.shields.io/badge/_-gitter-blue.svg)](https://gitter.im/CyC2018-Interview-Notebook/Lobby?utm_source=share-link&utm_medium=link&utm_campaign=share-link) [![](https://img.shields.io/badge/>-gitbook-blue.svg)](https://legacy.gitbook.com/book/cyc2018/interview-notebook/details) 
+
 | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
 | 算法[:pencil2:](#算法-pencil2) | 操作系统[:computer:](#操作系统-computer)|网络[:cloud:](#网络-cloud) | 面向对象[:couple:](#面向对象-couple) |数据库[:floppy_disk:](#数据库-floppy_disk)| Java [:coffee:](#java-coffee)| 分布式 [:sweat_drops:](#分布式-sweat_drops)| 工具[:hammer:](#工具-hammer)| 编码实践[:speak_no_evil:](#编码实践-speak_no_evil)| 后记[:memo:](#后记-memo) |
@ -138,31 +139,39 @@ Google 开源项目的代码风格规范。

 **关于仓库**

-[BOOKLIST](https://github.com/CyC2018/Interview-Notebook/blob/master/BOOKLIST.md)，这个书单是笔者至今看的一些比较好的技术书籍，虽然没有全都翻完，但是每本书多多少少都看过一部分。
+这个仓库是笔者的一个学习笔记，主要总结一些比较重要的知识点，希望对大家有所帮助。

-这个仓库是笔者的一个学习笔记，主要记录一些比较重要的知识点，希望对大家有所帮助。
+笔记不是从网上到处复制粘贴拼凑而来，虽然有少部分内容会直接引入书上原文或者官方技术文档的原文，但是没有直接摘抄其他人的博客文章，只做了参考，参考的文章会在最后给出链接。

-笔记并不是从网上到处复制粘贴拼凑而来，虽然少部分内容会直接引入书上原文或者官方技术文档的原文，但是没有直接摘抄其他人的博客文章，只做了一点参考，参考的文章会在最后给出链接。
+[BOOKLIST](https://github.com/CyC2018/Interview-Notebook/blob/master/BOOKLIST.md)，这个书单是笔者至今看的一些比较好的技术书籍，虽然没有全都看完，但每本书多多少少都看了一部分。

 **如何贡献**

 笔记内容是笔者一个字一个字打上去的，难免会有一些笔误，如果发现笔误可直接在相应文档进行编辑修改。

+欢迎提交对本仓库的改进建议~
+
 **授权相关**

-虽然没有加开源协议，但是默认允许非商业使用。转载使用请注明出处，谢谢。
+虽然没有加开源协议，但是允许非商业性使用。
+
+转载使用请注明出处，谢谢！

 **上传方案**

 笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。

-进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。这里提供了笔者实现的 GFM 文档转换工具的下载：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
+进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
+
+这里提供了笔者实现的 GFM 文档转换工具的链接：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。

 **排版指南**

-笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。这里提供了笔者实现的中英混排文档在线排版工具：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)，目前实现了加空格的功能，之后打算实现对英文专有名词提示首字母大写的功能。
+笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。

-不使用 `![]()` 这种方式来引用图片是为了能够控制图片以合适的大小显示。而且 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` ，所以只能使用 img 标签来引用图片。
+笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。
+
+这里提供了笔者实现的中英混排文档在线排版工具的链接：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。

 **声明**

--- a/notes/HTTP.md
+++ b/notes/HTTP.md
@ -66,7 +66,7 @@

 ## URL

- URI（Uniform Resource Indentifier，统一资源标识符）
+- URI（Uniform Resource Identifier，统一资源标识符）
 - URL（Uniform Resource Locator，统一资源定位符）
 - URN（Uniform Resource Name，统一资源名称），例如 urn:isbn:0-486-27557-4。

@ -232,7 +232,7 @@ CONNECT www.example.com:443 HTTP/1.1

 -  **500 Internal Server Error** ：服务器正在执行请求时发生错误。

-  **503 Service Unavilable** ：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。
+-  **503 Service Unavailable** ：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。

 # 四、HTTP 首部

@ -313,7 +313,9 @@ CONNECT www.example.com:443 HTTP/1.1

 HTTP 协议是无状态的，主要是为了让 HTTP 协议尽可能简单，使得它能够处理大量事务。HTTP/1.1 引入 Cookie 来保存状态信息。

-Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器下次向同一服务器再发起请求时被携带并发送到服务器上。它用于告知服务端两个请求是否来自同一浏览器，并保持用户的登录状态。
+Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器之后向同一服务器再次发起请求时被携带上，用于告知服务端两个请求是否来自同一浏览器。由于之后每次请求都会需要携带 Cookie 数据，因此会带来额外的性能开销（尤其是在移动环境下）。
+
+Cookie 曾一度用于客户端数据的存储，因为当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。新的浏览器 API 已经允许开发者直接将数据存储到本地，如使用 Web storage API （本地存储和会话存储）或 IndexedDB。

 ### 1. 用途

@ -321,8 +323,6 @@ Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据
 - 个性化设置（如用户自定义设置、主题等）
 - 浏览器行为跟踪（如跟踪分析用户行为等）

-Cookie 曾一度用于客户端数据的存储，因为当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。由于服务器指定 Cookie 后，浏览器的每次请求都会携带 Cookie 数据，会带来额外的性能开销（尤其是在移动环境下）。新的浏览器 API 已经允许开发者直接将数据存储到本地，如使用 Web storage API （本地存储和会话存储）或 IndexedDB。
-
 ### 2. 创建过程

 服务器发送的响应报文包含 Set-Cookie 首部字段，客户端得到响应报文后把 Cookie 内容保存到浏览器中。
@ -367,7 +367,7 @@ console.log(document.cookie);

 标记为 Secure 的 Cookie 只应通过被 HTTPS 协议加密过的请求发送给服务端。但即便设置了 Secure 标记，敏感信息也不应该通过 Cookie 传输，因为 Cookie 有其固有的不安全性，Secure 标记也无法提供确实的安全保障。

-标记为 HttpOnly 的 Cookie 不能被 JavaScript 脚本调用。因为跨域脚本 (XSS) 攻击常常使用 JavaScript 的 `Document.cookie` API 窃取用户的 Cookie 信息，因此使用 HttpOnly 标记可以在一定程度上避免 XSS 攻击。
+标记为 HttpOnly 的 Cookie 不能被 JavaScript 脚本调用。因为跨站脚本攻击 (XSS) 常常使用 JavaScript 的 `Document.cookie` API 窃取用户的 Cookie 信息，因此使用 HttpOnly 标记可以在一定程度上避免 XSS 攻击。

 ```html
 Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly
@ -387,7 +387,7 @@ Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径

 除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。

-Session 可以存储在服务器上的文件、数据库或者内存中，现在最常见的是将 Session 存储在内存型数据库中，比如 Redis。
+Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在内存型数据库中，比如 Redis。

 使用 Session 维护用户登录的过程如下：

@ -485,7 +485,7 @@ ETag: "82e22293907ce725faf67773957acd12"
 If-None-Match: "82e22293907ce725faf67773957acd12"
 ```

-Last-Modified 首部字段也可以用于缓存验证，它包含在源服务器发送的响应报文中，指示源服务器对资源的最后修改时间。但是它是一种弱校验器，因为只能精确到一秒，所以它通常作为 ETag 的备用方案。如果响应首部字段里含有这个信息，客户端可以在后续的请求中带上 If-Modified-Since 来验证缓存。服务器只在所请求的资源在给定的日期时间之后对内容进行过修改的情况下才会将资源返回，状态码为 200 OK。如果请求的资源从那时起未经修改，那么返回一个不带有消息主体的 304 Not Modified 响应，
+Last-Modified 首部字段也可以用于缓存验证，它包含在源服务器发送的响应报文中，指示源服务器对资源的最后修改时间。但是它是一种弱校验器，因为只能精确到一秒，所以它通常作为 ETag 的备用方案。如果响应首部字段里含有这个信息，客户端可以在后续的请求中带上 If-Modified-Since 来验证缓存。服务器只在所请求的资源在给定的日期时间之后对内容进行过修改的情况下才会将资源返回，状态码为 200 OK。如果请求的资源从那时起未经修改，那么返回一个不带有消息主体的 304 Not Modified 响应。

 ```html
 Last-Modified: Wed, 21 Oct 2015 07:28:00 GMT
@ -507,7 +507,7 @@ If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT

 ### 2. 流水线

-默认情况下，HTTP 请求是按顺序发出的，下一个请求只有在当前请求收到应答过后才会被发出。由于会受到网络延迟和带宽的限制，在下一个请求被发送到服务器之前，可能需要等待很长时间。
+默认情况下，HTTP 请求是按顺序发出的，下一个请求只有在当前请求收到相应之后才会被发出。由于会受到网络延迟和带宽的限制，在下一个请求被发送到服务器之前，可能需要等待很长时间。

 流水线是在同一条长连接上发出连续的请求，而不用等待响应返回，这样可以避免连接延迟。

@ -627,7 +627,7 @@ HTTP/1.1 使用虚拟主机技术，使得一台服务器拥有多个域名，
 - 网络访问控制
 - 访问日志记录

-代理服务器分为正向代理和反向代理两种，用户察觉得到正向代理的存在，而反向代理一般位于内部网络中，用户察觉不到。
+代理服务器分为正向代理和反向代理两种，用户察觉得到正向代理的存在；而反向代理一般位于内部网络中，用户察觉不到。

 <div align="center"> <img src="../pics//a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/> </div><br>

--- a/notes/Java
+++ b/notes/Java
@ -49,7 +49,7 @@ public static void listAllFiles(File dir)
        System.out.println(dir.getName());
        return;
    }
-    for (File file : Objects.requireNonNull(dir.listFiles())) {
+    for (File file : dir.listFiles()) {
        listAllFiles(file);
    }
 }
@ -65,8 +65,9 @@ public static void copyFile(String src, String dist) throws IOException
    FileInputStream in = new FileInputStream(src);
    FileOutputStream out = new FileOutputStream(dist);
    byte[] buffer = new byte[20 * 1024];
-    /* read() 最多读取 buffer.length 个字节
-       返回的是实际读取的个数，返回 -1 的时候表示读到 eof，即文件尾 */
+    // read() 最多读取 buffer.length 个字节
+    // 返回的是实际读取的个数
+    // 返回 -1 的时候表示读到 eof，即文件尾
    while (in.read(buffer, 0, buffer.length) != -1) {
        out.write(buffer);
    }
@ -82,7 +83,7 @@ Java I/O 使用了装饰者模式来实现。以 InputStream 为例，InputStrea
 实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。

 ```java
-FileInputStream fileInputStream = new FileInputStream("file/1.txt");
+FileInputStream fileInputStream = new FileInputStream(filePath);
 BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
 ```

@ -92,22 +93,25 @@ DataInputStream 装饰者提供了对更多数据类型进行输入的操作，

 不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。

- InputStreamReader 实现从文本文件的字节流解码成字符流；
- OutputStreamWriter 实现字符流编码成为文本文件的字节流。
+- InputStreamReader 实现从字节流解码成字符流；
+- OutputStreamWriter 实现字符流编码成为字节流。

 逐行输出文本文件的内容：

 ```java
-FileReader fileReader = new FileReader("file/1.txt");
-BufferedReader bufferedReader = new BufferedReader(fileReader);
-String line;
-while ((line = bufferedReader.readLine()) != null) {
-    System.out.println(line);
+public static void readFileContent(String filePath) throws IOException
+{
+    FileReader fileReader = new FileReader(filePath);
+    BufferedReader bufferedReader = new BufferedReader(fileReader);
+    String line;
+    while ((line = bufferedReader.readLine()) != null) {
+        System.out.println(line);
+    }
+    // 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
+    // 在调用 BufferedReader 的 close() 方法时会去调用 fileReader 的 close() 方法
+    // 因此只要一个 close() 调用即可
+    bufferedReader.close();
 }
-/* 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
-   在调用 BufferedReader 的 close() 方法时会去调用 fileReader 的 close() 方法
-   因此只要一个 close() 调用即可 */
-bufferedReader.close();
 ```

 编码就是把字符转换为字节，而解码是把字节重新组合成字符。
@ -216,8 +220,10 @@ InetAddress.getByAddress(byte[] address);
 public static void main(String[] args) throws IOException
 {
    URL url = new URL("http://www.baidu.com");
-    InputStream is = url.openStream();                           /* 字节流 */
-    InputStreamReader isr = new InputStreamReader(is, "utf-8");  /* 字符流 */
+    // 字节流
+    InputStream is = url.openStream();
+    // 字符流
+    InputStreamReader isr = new InputStreamReader(is, "utf-8");
    BufferedReader br = new BufferedReader(isr);
    String line = br.readLine();
    while (line != null) {
@ -253,7 +259,7 @@ public static void main(String[] args) throws IOException

 I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。

-面向流的 I/O 一次处理一个字节数据，一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
+面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。

 面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。

@ -325,7 +331,7 @@ I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重
 ```java
 public static void fastCopy(String src, String dist) throws IOException
 {
-    FileInputStream fin = new FileInputStream(src);      /* 获得源文件的输入字节流 */
+    FileInputStream fin = new FileInputStream(src);      /* 获取源文件的输入字节流 */
    FileChannel fcin = fin.getChannel();                 /* 获取输入字节流的文件通道 */
    FileOutputStream fout = new FileOutputStream(dist);  /* 获取目标文件的输出字节流 */
    FileChannel fcout = fout.getChannel();               /* 获取输出字节流的通道 */
@ -344,10 +350,16 @@ public static void fastCopy(String src, String dist) throws IOException

 ## 选择器

-一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
+NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。
+
+NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
+
+通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。

 因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件具有更好的性能。

+应该注意的是，只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。
+
 <div align="center"> <img src="../pics//4d930e22-f493-49ae-8dff-ea21cd6895dc.png"/> </div><br>

 ### 1. 创建选择器
@ -394,7 +406,7 @@ int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
 int num = selector.select();
 ```

-使用 select() 来监听事件到达，它会一直阻塞直到有至少一个事件到达。
+使用 select() 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。

 ### 4. 获取到达的事件

@ -514,10 +526,6 @@ public class NIOClient

 内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。

-只有文件中实际读取或者写入的部分才会映射到内存中。
-
-现代操作系统一般会根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制只不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。
-
 向内存映射文件写入可能是危险的，仅只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。

 下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，您可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
@ -530,8 +538,8 @@ MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);

 NIO 与普通 I/O 的区别主要有以下两点：

- NIO 是非阻塞的。应当注意，FileChannel 不能切换到非阻塞模式，套接字 Channel 可以。
- NIO 面向块，I/O 面向流。
+- NIO 是非阻塞的
+- NIO 面向块，I/O 面向流

 # 八、参考资料

--- a/notes/Java
+++ b/notes/Java
@ -1,5 +1,5 @@
 <!-- GFM-TOC -->
-* [一、基本类型](#一基本类型)
+* [一、数据类型](#一数据类型)
    * [包装类型](#包装类型)
    * [缓存池](#缓存池)
 * [二、String](#二string)
@ -38,7 +38,7 @@
 <!-- GFM-TOC -->


-# 一、基本类型
+# 一、数据类型

 ## 包装类型

@ -81,7 +81,7 @@ Integer n = 123;
 System.out.println(m == n); // true
 ```

-valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接使用缓存池的内容。
+valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。

 ```java
 public static Integer valueOf(int i) {
@ -194,7 +194,7 @@ String 不可变性天生具备线程安全，可以在多个线程中安全地

 使用 String.intern() 可以保证相同内容的字符串变量引用相同的内存对象。

-下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同对象，而 s3 是通过 s1.intern() 方法取得一个对象引用，这个方法首先把 s1 引用的对象放到 String Poll（字符串常量池）中，然后返回这个对象引用。因此 s3 和 s1 引用的是同一个字符串常量池的对象。
+下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同对象，而 s3 是通过 s1.intern() 方法取得一个对象引用，这个方法首先把 s1 引用的对象放到 String Pool（字符串常量池）中，然后返回这个对象引用。因此 s3 和 s1 引用的是同一个字符串常量池的对象。

 ```java
 String s1 = new String("aaa");
@ -204,7 +204,7 @@ String s3 = s1.intern();
 System.out.println(s1.intern() == s3);  // true
 ```

-如果是采用 "bbb" 这种使用双引号的形式创建字符串实例，会自动地将新建的对象放入 String Poll 中。
+如果是采用 "bbb" 这种使用双引号的形式创建字符串实例，会自动地将新建的对象放入 String Pool 中。

 ```java
 String s4 = "bbb";
@ -266,7 +266,7 @@ public class PassByValueExample {

 ## float 与 double

-1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是下转型，会使得精度下降，因此 Java 不能隐式执行下转型。
+1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。Java 不能隐式执行向下转型，因为这会使得精度降低。

 ```java
 // float f = 1.1;
@ -341,8 +341,8 @@ Java 中有三个访问权限修饰符：private、protected 以及 public，如

 可以对类或类中的成员（字段以及方法）加上访问修饰符。

- 成员可见表示其它类可以用这个类的实例访问到该成员；
- 类可见表示其它类可以用这个类创建对象。
+- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
+- 类可见表示其它类可以用这个类创建实例对象。

 protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。

@ -484,7 +484,7 @@ System.out.println(InterfaceExample.x);
 使用抽象类：

 - 需要在几个相关的类中共享代码。
- 需要能控制继承来的方法和域的访问权限，而不是都为 public。
+- 需要能控制继承来的成员的访问权限，而不是都为 public。
 - 需要继承非静态（non-static）和非常量（non-final）字段。

 使用接口：
@ -629,7 +629,7 @@ x.equals(y) == x.equals(y); // true
 对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false

 ```java
-x.euqals(null); // false;
+x.equals(null); // false;
 ```

 **3. 实现** 
@ -685,7 +685,7 @@ System.out.println(set.size());   // 2

 理想的散列函数应当具有均匀性，即不相等的实例应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来，可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。

-一个数与 31 相乘可以转换成移位和减法：`31\*x == (x<<5)-x`，编译器会自动进行这个优化。
+一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。

 ```java
@Override
@ -763,10 +763,10 @@ try {
 ```

 ```html
-java.lang.CloneNotSupportedException: CloneTest
+java.lang.CloneNotSupportedException: CloneExample
 ```

-以上抛出了 CloneNotSupportedException，这是因为 CloneTest 没有实现 Cloneable 接口。
+以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。

 ```java
 public class CloneExample implements Cloneable {
@ -937,9 +937,7 @@ private 方法隐式地被指定为 final，如果在子类中定义的方法和

 **1. 静态变量** 

-静态变量在内存中只存在一份，只在类初始化时赋值一次。
-
- 静态变量：类所有的实例都共享静态变量，可以直接通过类名来访问它；
+- 静态变量：类所有的实例都共享静态变量，可以直接通过类名来访问它；静态变量在内存中只存在一份。
 - 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

 ```java
@ -1114,7 +1112,7 @@ Reflection is powerful, but should not be used indiscriminately. If it is possib
 Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error**  和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：

 -  **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
-  **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序奔溃并且无法恢复。
+-  **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。

 <div align="center"> <img src="../pics//PPjwP.png" width="600"/> </div><br>

--- a/notes/Java
+++ b/notes/Java
@ -255,6 +255,34 @@ List<String> synList = Collections.synchronizedList(list);
 List<String> list = new CopyOnWriteArrayList<>();
 ```

+CopyOnWriteArrayList 是一种 CopyOnWrite 容器，从以下源码看出：读取元素是从原数组读取；添加元素是在复制的新数组上。读写分离，因而可以在并发条件下进行不加锁的读取，读取效率高，适用于读操作远大于写操作的场景。
+
+```java
+public boolean add(E e) {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        Object[] elements = getArray();
+        int len = elements.length;
+        Object[] newElements = Arrays.copyOf(elements, len + 1); 
+        newElements[len] = e;
+        setArray(newElements);
+        return true;
+    } finally {
+        lock.unlock();
+    }
+}
+
+final void setArray(Object[] a) {
+    array = a;
+}
+
+@SuppressWarnings("unchecked")
+private E get(Object[] a, int index) {
+    return (E) a[index];
+}
+```
+
 ## LinkedList

 ### 1. 概览
--- a/notes/Java
+++ b/notes/Java
@ -23,7 +23,8 @@
 * [五、互斥同步](#五互斥同步)
    * [synchronized](#synchronized)
    * [ReentrantLock](#reentrantlock)
-    * [synchronized 和 ReentrantLock 比较](#synchronized-和-reentrantlock-比较)
+    * [比较](#比较)
+    * [使用选择](#使用选择)
 * [六、线程之间的协作](#六线程之间的协作)
    * [join()](#join)
    * [wait() notify() notifyAll()](#wait-notify-notifyall)
@ -498,6 +499,8 @@ public synchronized static void fun() {

 ## ReentrantLock

+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁.
+
 ```java
 public class LockExample {

@ -529,23 +532,8 @@ public static void main(String[] args) {
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```

-ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁，相比于 synchronized，它多了以下高级功能：

-**1. 等待可中断** 
-
-当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
-
-**2. 可实现公平锁** 
-
-公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
-
-synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
-
-**3. 锁绑定多个条件** 
-
-一个 ReentrantLock 对象可以同时绑定多个 Condition 对象。
-
-## synchronized 和 ReentrantLock 比较
+## 比较

 **1. 锁的实现** 

@ -553,13 +541,25 @@ synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。

 **2. 性能** 

-新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等。目前来看它和 ReentrantLock 的性能基本持平了，因此性能因素不再是选择 ReentrantLock 的理由。synchronized 有更大的性能优化空间，应该优先考虑 synchronized。
+新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。

-**3. 功能** 
+**3. 等待可中断** 

-ReentrantLock 多了一些高级功能。
+当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。

-**4. 使用选择** 
+ReentrantLock 可中断，而 synchronized 不行。
+
+**4. 公平锁** 
+
+公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
+
+synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
+
+**5. 锁绑定多个条件** 
+
+一个 ReentrantLock 可以同时绑定多个 Condition 对象。
+
+## 使用选择

 除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。

@ -1232,7 +1232,7 @@ Thread 对象的 start() 方法调用先行发生于此线程的每一个动作

 > Thread Join Rule

-join() 方法返回先行发生于 Thread 对象的结束。
+Thread 对象的结束先行发生于 join() 方法返回。

 <div align="center"> <img src="../pics//thread-join-rule.png" width=""/> </div><br>

@ -1240,7 +1240,7 @@ join() 方法返回先行发生于 Thread 对象的结束。

 > Thread Interruption Rule

-对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 Thread.interrupted() 方法检测到是否有中断发生。
+对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。

 ### 7. 对象终结规则

@ -1385,22 +1385,21 @@ synchronized 和 ReentrantLock。

 ### 2. 非阻塞同步

-互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。
+互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。

-从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
+互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。

-随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。
+随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。

-乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。

-CAS 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新。但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。
+硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。

 J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。

-在下面的代码 1 中，使用了 AtomicInteger 执行了自增的操作。代码 2 是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。代码 3 是 getAndAddInt() 源码，var1 指示内存位置，var2 指示新值，var4 指示操作需要加的数值，这里为 1。在代码 3 的实现中，通过 getIntVolatile(var1, var2) 得到旧的预期值。通过调用 compareAndSwapInt() 来进行 CAS 比较，如果 var2=var5，那么就更新内存地址为 var1 的变量为 var5+var4。可以看到代码 3 是在一个循环中进行，发生冲突的做法是不断的进行重试。
+以下代码使用了 AtomicInteger 执行了自增的操作。

 ```java
-// 代码 1
 private AtomicInteger cnt = new AtomicInteger();

 public void add() {
@ -1408,15 +1407,17 @@ public void add() {
 }
 ```

+以下代码是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。
+
 ```java
-// 代码 2
 public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
 }
 ```

+以下代码是 getAndAddInt() 源码，var1 指示内存地址，var2 指示旧值，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果 var2==var5，那么就更新内存地址为 var1 的变量为 var5+var4。可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
+
 ```java
-// 代码 3
 public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
@ -1427,7 +1428,9 @@ public final int getAndAddInt(Object var1, long var2, int var4) {
 }
 ```

-ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。J.U.C 包提供了一个带有标记的原子引用类“AtomicStampedReference”来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
+
+J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。

 ### 3. 无同步方案

@ -1435,9 +1438,9 @@ ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了

 **（一）可重入代码（Reentrant Code）** 

-这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
+这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。

-可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
+可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。

 **（二）栈封闭** 

--- a/虚拟机.md
+++ b/虚拟机.md
@ -174,7 +174,7 @@ obj = null;  // 使对象只被软引用关联

 **（三）弱引用** 

-被弱引用关联的对象一定会被垃圾收集器回收，也就是说它只能存活到下一次垃圾收集发生之前。
+被弱引用关联的对象一定会被垃圾收集器回收，也就是说它只能存活到下一次垃圾收集。

 使用 WeakReference 类来实现弱引用。

@ -388,11 +388,11 @@ CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。

 G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。

-Java 堆被分为新生代、老年代和永久代，其它收集器进行收集的范围都是整个新生代或者老生代，而 G1 可以直接对新生代和永久代一起回收。
+Java 堆被分为新生代、老年代和永久代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 可以直接对新生代和老年代一起回收。

 <div align="center"> <img src="../pics//4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/> </div><br>

-G1 把堆划分成多个大小相等的独立区域（Region），新生代和永久代不再物理隔离。
+G1 把堆划分成多个大小相等的独立区域（Region），新生代和老年代不再物理隔离。

 <div align="center"> <img src="../pics//9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/> </div><br>

@ -457,15 +457,17 @@ G1 把堆划分成多个大小相等的独立区域（Region），新生代和

 （四）动态对象年龄判定

-虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 区中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
+虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。

 （五）空间分配担保

-在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的；如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC，尽管这次 Minor GC 是有风险的；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那这时也要改为进行一次 Full GC。
+在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。
+
+如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那么就要进行一次 Full GC。

 ### 3. Full GC 的触发条件

-对于 Minor GC，其触发条件非常简单，当 Eden 区空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
+对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：

 （一）调用 System.gc()

@ -483,11 +485,15 @@ G1 把堆划分成多个大小相等的独立区域（Region），新生代和

 （四）JDK 1.7 及以前的永久代空间不足

-在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据，当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。
+在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。
+
+当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。
+
+为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。

 （五）Concurrent Mode Failure

-执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（有时候“空间不足”是指 CMS GC 当前的浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
+执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。

 # 三、类加载机制

--- a/notes/Leetcode-Database
+++ b/notes/Leetcode-Database
@ -209,9 +209,9 @@ https://leetcode.com/problems/classes-more-than-5-students/description/

 ```html
 +---------+
-| Email   |
+| class   |
 +---------+
-| a@b.com |
+| Math    |
 +---------+
 ```

@ -305,6 +305,8 @@ HAVING

 # 196. Delete Duplicate Emails

+https://leetcode.com/problems/delete-duplicate-emails/description/
+
 ## Description

 邮件地址表：
@ -319,14 +321,15 @@ HAVING
 +----+---------+
 ```

-查找重复的邮件地址：
+删除重复的邮件地址：

 ```html
-+---------+
-| Email   |
-+---------+
-| a@b.com |
-+---------+
+----+------------------+
+| Id | Email            |
+----+------------------+
+| 1  | john@example.com |
+| 2  | bob@example.com  |
+----+------------------+
 ```

 ## SQL Schema
@ -435,7 +438,8 @@ SELECT
    State
 FROM
    Person P
-    LEFT JOIN Address AS A ON P.PersonId = A.PersonId;
+    LEFT JOIN Address A
+    ON P.PersonId = A.PersonId;
 ```

 # 181. Employees Earning More Than Their Managers
@ -481,7 +485,8 @@ SELECT
    E1.NAME AS Employee
 FROM
    Employee E1
-    INNER JOIN Employee E2 ON E1.ManagerId = E2.Id
+    INNER JOIN Employee E2
+    ON E1.ManagerId = E2.Id
    AND E1.Salary > E2.Salary;
 ```

@ -558,7 +563,8 @@ SELECT
    C.Name AS Customers
 FROM
    Customers C
-    LEFT JOIN Orders O ON C.Id = O.CustomerId
+    LEFT JOIN Orders O
+    ON C.Id = O.CustomerId
 WHERE
    O.CustomerId IS NULL;
 ```
@ -681,7 +687,7 @@ https://leetcode.com/problems/second-highest-salary/description/
 +---------------------+
 ```

-如果没有找到，那么就返回 null 而不是不返回数据。
+没有找到返回 null 而不是不返回数据。

 ## SQL Schema

@ -788,7 +794,8 @@ SELECT
    COUNT( DISTINCT S2.score ) Rank
 FROM
    Scores S1
-    INNER JOIN Scores S2 ON S1.score <= S2.score
+    INNER JOIN Scores S2
+    ON S1.score <= S2.score
 GROUP BY
    S1.id
 ORDER BY
--- a/notes/MySQL.md
+++ b/notes/MySQL.md
@ -250,7 +250,7 @@ SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;

 ```sql
 SELECT film_id, actor_ id FROM sakila.film_actor
-WhERE actor_id = 1 AND film_id = 1;
+WHERE actor_id = 1 AND film_id = 1;
 ```

 ### 3. 索引列的顺序
@ -351,7 +351,7 @@ do {
 - 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。

 ```sql
-SELECT * FROM tag
+SELECT * FROM tab
 JOIN tag_post ON tag_post.tag_id=tag.id
 JOIN post ON tag_post.post_id=post.id
 WHERE tag.tag='mysql';
@ -379,7 +379,7 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);

 垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。

-在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库 payDB、用户数据库 userBD 等。
+在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库 payDB、用户数据库 userDB 等。

 ## Sharding 策略

--- a/notes/SQL.md
+++ b/notes/SQL.md
@ -170,7 +170,6 @@ FROM mytable
 LIMIT 2, 3;
 ```

-
 # 八、排序

 -  **ASC** ：升序（默认）
--- a/notes/Socket.md
+++ b/notes/Socket.md
@ -10,9 +10,9 @@
 * [二、I/O 复用](#二io-复用)
    * [select](#select)
    * [poll](#poll)
+    * [比较](#比较)
    * [epoll](#epoll)
-    * [select 和 poll 比较](#select-和-poll-比较)
-    * [epoll 工作模式](#epoll-工作模式)
+    * [工作模式](#工作模式)
    * [应用场景](#应用场景)
 * [参考资料](#参考资料)
 <!-- GFM-TOC -->
@ -106,17 +106,11 @@ select/poll/epoll 都是 I/O 多路复用的具体实现，select 出现的最
 int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
 ```

-readset, writeset, exceptset 参数，分别对应读、写、异常条件的描述符集合。
+有三种类型的描述符类型：readset、writeset、exceptset，分别对应读、写、异常条件的描述符集合。fd_set 使用数组实现，数组大小使用 FD_SETSIZE 定义。

-timeout 参数告知内核等待所指定描述符中的任何一个就绪的最长时间；
+timeout 为超时参数，调用 select 会一直阻塞直到有描述符的事件到达或者等待的时间超过 timeout。

-成功调用返回结果大于 0；出错返回结果为 -1；超时返回结果为 0。
-
-每次调用 select 都需要将 readfds, writefds, exceptfds 链表内容全部从应用进程缓冲区复制到内核缓冲区。
-
-返回结果中内核并没有声明 fd_set 中哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程需要遍历所有的 fd_set。
-
-select 最多支持 1024 个描述符，其中 1024 由内核的 FD_SETSIZE 决定。如果需要打破该限制可以修改 FD_SETSIZE，然后重新编译内核。
+成功调用返回结果大于 0，出错返回结果为 -1，超时返回结果为 0。

 ```c
 fd_set fd_in, fd_out;
@ -163,21 +157,7 @@ else
 int poll(struct pollfd *fds, unsigned int nfds, int timeout);
 ```

-```c
-struct pollfd {
-    int fd;        // 文件描述符
-    short events;  // 监视的请求事件
-    short revents; // 已发生的事件
-};
-```
-
-它和 select 功能基本相同，同样需要每次都将描述符从应用进程缓冲区复制到内核缓冲区，调用返回后同样需要进行轮询才能知道哪些描述符已经准备好。
-
-poll 取消了 1024 个描述符数量上限，但是数量太大以后不能保证执行效率，因为复制大量内存到内核十分低效，所需时间与描述符数量成正比。
-
-poll 在描述符的重复利用上比 select 的 fd_set 会更好。
-
-如果在多线程下，如果一个线程对某个描述符调用了 poll 系统调用，但是另一个线程关闭了该描述符，会导致 poll 调用结果不确定，该问题同样出现在 select 中。
+pollfd 使用链表实现。

 ```c
 // The structure for two events
@ -211,6 +191,28 @@ else
 }
 ```

+## 比较
+
+### 1. 功能
+
+select 和 poll 的功能基本相同，不过在一些实现细节上有所不同。
+
+- select 会修改描述符，而 poll 不会；
+- select 的描述符类型使用数组实现，FD_SETSIZE 大小默认为 1024，因此默认只能监听 1024 个描述符。如果要监听更多描述符的话，需要修改 FD_SETSIZE 之后重新编译；而 poll 的描述符类型使用链表实现，没有描述符的数量的限制；
+- poll 提供了更多的事件类型，并且对描述符的重复利用上比 select 高。
+- 如果一个线程对某个描述符调用了 select 或者 poll，另一个线程关闭了该描述符，会导致调用结果不确定。
+
+### 2. 速度
+
+select 和 poll 速度都比较慢。
+
+- select 和 poll 每次调用都需要将全部描述符从应用进程缓冲区复制到内核缓冲区。
+- select 和 poll 的返回结果中没有声明哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程都需要使用轮询的方式来找到 I/O 完成的描述符。
+
+### 3. 可移植性
+
+几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
+
 ## epoll

 ```c
@ -219,21 +221,15 @@ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
 int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
 ```

+epoll_ctl() 用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理，进程调用 epoll_wait() 便可以得到事件完成的描述符。
+
+从上面的描述可以看出，epoll 只需要将描述符从进程缓冲区向内核缓冲区拷贝一次，并且进程不需要通过轮询来获得事件完成的描述符。
+
 epoll 仅适用于 Linux OS。

-它是 select 和 poll 的增强版，更加灵活而且没有描述符数量限制。
+epoll 比 select 和 poll 更加灵活而且没有描述符数量限制。

-它将用户关心的描述符放到内核的一个事件表中，从而只需要在用户进程缓冲区和内核缓冲区拷贝一次。
-
-select 和 poll 方式中，进程只有在调用一定的方法后，内核才对所有监视的描述符进行扫描。而 epoll 事先通过 epoll_ctl() 来注册描述符，一旦基于某个描述符就绪时，内核会采用类似 callback 的回调机制，迅速激活这个描述符，当进程调用 epoll_wait() 时便得到通知。
-
-新版本的 epoll_create(int size) 参数 size 不起任何作用，在旧版本的 epoll 中如果描述符的数量大于 size，不保证服务质量。
-
-epoll_ctl() 执行一次系统调用，用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理。
-
-epoll_wait() 取出在内核中通过链表维护的 I/O 准备好的描述符，将他们从内核复制到应用进程中，不需要像 select/poll 对注册的所有描述符遍历一遍。
-
-epoll 对多线程编程更有友好，同时多个线程对同一个描述符调用了 epoll_wait() 也不会产生像 select/poll 的不确定情况。或者一个线程调用了 epoll_wait() 另一个线程关闭了同一个描述符也不会产生不确定情况。
+epoll 对多线程编程更有友好，一个线程调用了 epoll_wait() 另一个线程关闭了同一个描述符也不会产生像 select 和 poll 的不确定情况。

 ```c
 // Create the epoll descriptor. Only one is needed per app, and is used to monitor all sockets.
@ -282,64 +278,42 @@ else
 }
 ```

-## select 和 poll 比较

-### 1. 功能
+## 工作模式

-它们提供了几乎相同的功能，但是在一些细节上有所不同：
-
- select 会修改 fd_set 参数，而 poll 不会；
- select 默认只能监听 1024 个描述符，如果要监听更多的话，需要修改 FD_SETSIZE 之后重新编译；
- poll 提供了更多的事件类型。
-
-### 2. 速度
-
-poll 和 select 在速度上都很慢。
-
- 它们都采取轮询的方式来找到 I/O 完成的描述符，如果描述符很多，那么速度就会很慢；
- select 只使用每个描述符的 3 位，而 poll 通常需要使用 64 位，因此 poll 需要在用户进程和内核之间复制更多的数据。
-
-### 3. 可移植性
-
-几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
-
-## epoll 工作模式
-
-epoll_event 有两种触发模式：LT（level trigger）和 ET（edge trigger）。
+epoll 的描述符事件有两种触发模式：LT（level trigger）和 ET（edge trigger）。

 ### 1. LT 模式

-当 epoll_wait() 检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用 epoll_wait() 时，会再次响应应用程序并通知此事件。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。
+当 epoll_wait() 检测到描述符事件到达时，将此事件通知进程，进程可以不立即处理该事件，下次调用 epoll_wait() 会再次通知进程。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。

 ### 2. ET 模式

-当 epoll_wait() 检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用 epoll_wait() 时，不会再次响应应用程序并通知此事件。很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
+和 LT 模式不同的是，通知之后进程必须立即处理事件，下次再调用 epoll_wait() 时不会再得到事件到达的通知。
+
+很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

 ## 应用场景

-很容易产生一种错觉认为只要用 epoll 就可以了，select poll 都是历史遗留问题，并没有什么应用场景，其实并不是这样的。
+很容易产生一种错觉认为只要用 epoll 就可以了，select 和 poll 都已经过时了，其实它们都有各自的使用场景。

 ### 1. select 应用场景

-select() poll() epoll_wait() 都有一个 timeout 参数，在 select() 中 timeout 的精确度为 1ns，而 poll() 和 epoll_wait() 中则为 1ms。所以 select 更加适用于实时要求更高的场景，比如核反应堆的控制。
+select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时要求更高的场景，比如核反应堆的控制。

-select 历史更加悠久，它的可移植性更好，几乎被所有主流平台所支持。
+select 可移植性更好，几乎被所有主流平台所支持。

 ### 2. poll 应用场景

-poll 没有最大描述符数量的限制，如果平台支持应该采用 poll 且对实时性要求并不是十分严格，而不是 select。
+poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。

-需要同时监控小于 1000 个描述符。没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
+需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。

-需要监控的描述符状态变化多，而且都是非常短暂的。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且epoll 的描述符存储在内核，不容易调试。
+需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且epoll 的描述符存储在内核，不容易调试。

 ### 3. epoll 应用场景

-程序只需要运行在 Linux 平台上，有非常大量的描述符需要同时轮询，而且这些连接最好是长连接。
-
-### 4. 性能对比
-
-[epoll Scalability Web Page](http://lse.sourceforge.net/epoll/index.html)
+只需要运行在 Linux 平台上，并且有非常大量的描述符需要同时轮询，而且这些连接最好是长连接。

 # 参考资料

@ -348,3 +322,5 @@ poll 没有最大描述符数量的限制，如果平台支持应该采用 poll
 - [Synchronous and Asynchronous I/O](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx)
 - [Linux IO 模式及 select、poll、epoll 详解](https://segmentfault.com/a/1190000003063859)
 - [poll vs select vs event-based](https://daniel.haxx.se/docs/poll-vs-select.html)
+- [select / poll / epoll: practical difference for system architects](http://www.ulduzsoft.com/2014/01/select-poll-epoll-practical-difference-for-system-architects/)
+- [Browse the source code of userspace/glibc/sysdeps/unix/sysv/linux/ online](https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/)
--- a/notes/代码风格规范.md
+++ b/notes/代码风格规范.md
@ -2,5 +2,5 @@
 <!-- GFM-TOC -->


- [Twitter Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.mde)
+- [Twitter Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.md)
 - [Google Java Style Guide](http://google.github.io/styleguide/javaguide.html)
--- a/notes/剑指
+++ b/notes/剑指
@ -440,7 +440,7 @@ public int pop() throws Exception {

 如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。

-<div align="center"> <img src="../pics//955af054-8872-4569-82e7-2e10b66bc38e.png" width="250"/> </div><br>
+<div align="center"> <img src="../pics//a0df8edc-581b-4977-95c2-d7025795b899.png" width="300"/> </div><br>

 递归方法是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，避免重复求解子问题。

@ -603,13 +603,15 @@ public int RectCover(int n) {

 ## 题目描述

-把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。NOTE：给出的所有元素都大于 0，若数组大小为 0，请返回 0。
+把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
+
+例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。NOTE：给出的所有元素都大于 0，若数组大小为 0，请返回 0。

 ## 解题思路

 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；否则解在 [m + 1, h] 之间，令 l = m + 1。

-因为 h 的赋值表达式为 h = m，因此循环体的循环条件应该为 l < h，详细解释请见 [Leetcode 题解](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3.md#%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE)。
+因为 h 的赋值表达式为 h = m，因此循环体的循环条件应该为 l < h，详细解释请见 [Leetcode 题解](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3.md#%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE) 二分查找部分。

 复杂度：O(logN) + O(1)

@ -732,10 +734,10 @@ private void initDigitSum() {
            n /= 10;
        }
    }
-    digitSum = new int[rows][cols];
+    this.digitSum = new int[rows][cols];
    for (int i = 0; i < this.rows; i++)
        for (int j = 0; j < this.cols; j++)
-            digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
+            this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
 }
 ```

@ -747,24 +749,17 @@ private void initDigitSum() {

 把一根绳子剪成多段，并且使得每段的长度乘积最大。

-For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
+```html
+n = 2
+return 1 (2 = 1 + 1)
+
+n = 10
+return 36 (10 = 3 + 3 + 4)
+```

 ## 解题思路

-### 动态规划解法
-
-```java
-public int integerBreak(int n) {
-    int[] dp = new int[n + 1];
-    dp[1] = 1;
-    for (int i = 2; i <= n; i++)
-        for (int j = 1; j < i; j++)
-            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
-    return dp[n];
-}
-```
-
-### 贪心解法
+### 贪心

 尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现，如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。

@ -786,6 +781,19 @@ public int integerBreak(int n) {
 }
 ```

+### 动态规划
+
+```java
+public int integerBreak(int n) {
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    for (int i = 2; i <= n; i++)
+        for (int j = 1; j < i; j++)
+            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
+    return dp[n];
+}
+```
+
 # 15. 二进制中 1 的个数

 [NowCoder](https://www.nowcoder.com/practice/8ee967e43c2c4ec193b040ea7fbb10b8?tpId=13&tqId=11164&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
@ -804,7 +812,7 @@ public int NumberOf1(int n) {

 ### n&(n-1)

-O(logM) 时间复杂度解法，其中 M 表示 1 的个数。
+O(M) 时间复杂度解法，其中 M 表示 1 的个数。

 该位运算是去除 n 的位级表示中最低的那一位。

@ -965,28 +973,19 @@ public ListNode deleteDuplication(ListNode pHead) {

 ## 题目描述

-请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
+请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。
+
+在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。

 ## 解题思路

 应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。

-```html
-if p.charAt(j) == s.charAt(i)  :  then dp[i][j] = dp[i-1][j-1];
-if p.charAt(j) == '.'          :  then dp[i][j] = dp[i-1][j-1];
-if p.charAt(j) == '*'          :
-     if p.charAt(j-1) != s.charAt(i)  :  then dp[i][j] = dp[i][j-2]  // a* only counts as empty
-     if p.charAt(j-1) == s.charAt(i) or
-        p.charAt(i-1) == '.'          :
-              then dp[i][j] = dp[i-1][j]   // a* counts as multiple a
-                or dp[i][j] = dp[i][j-1]   // a* counts as single a
-                or dp[i][j] = dp[i][j-2]   // a* counts as empty
-```
-
 ```java
 public boolean match(char[] str, char[] pattern) {
    int m = str.length, n = pattern.length;
    boolean[][] dp = new boolean[m + 1][n + 1];
+
    dp[0][0] = true;
    for (int i = 1; i <= n; i++)
        if (pattern[i - 1] == '*')
@ -997,10 +996,13 @@ public boolean match(char[] str, char[] pattern) {
            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
                dp[i][j] = dp[i - 1][j - 1];
            else if (pattern[j - 1] == '*')
-                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.')
-                    dp[i][j] = dp[i][j - 1] || dp[i][j - 2] || dp[i - 1][j];
-                else
-                    dp[i][j] = dp[i][j - 2];
+                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
+                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
+                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
+                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
+                } else
+                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty
+
    return dp[m][n];
 }
 ```
@ -1011,10 +1013,25 @@ public boolean match(char[] str, char[] pattern) {

 ## 题目描述

-请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串 "+100","5e2","-123","3.1416" 和 "-1E-16" 都表示数值。 但是 "12e","1a3.14","1.2.3","+-5" 和 "12e+4.3" 都不是。
+请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
+
+例如，字符串 "+100","5e2","-123","3.1416" 和 "-1E-16" 都表示数值。但是 "12e","1a3.14","1.2.3","+-5" 和 "12e+4.3" 都不是。

 ## 解题思路

+使用正则表达式进行匹配。
+
+```html
+[]  ： 字符集合
+()  ： 分组，在这里是为了让表达式更清晰
+?   ： 重复 0 ~ 1
+   ： 重复 1 ~ n
+*   ： 重复 0 ~ n
+.   ： 任意字符
+\\. ： 转义后的 .
+\\d ： 任意数字
+```
+
 ```java
 public boolean isNumeric(char[] str) {
    if (str == null)
@ -1029,7 +1046,7 @@ public boolean isNumeric(char[] str) {

 ## 题目描述

-保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。
+需要保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。

 ## 解题思路

--- a/notes/数据库系统原理.md
+++ b/notes/数据库系统原理.md
@ -25,7 +25,7 @@
    * [快照读与当前读](#快照读与当前读)
 * [六、Next-Key Locks](#六next-key-locks)
    * [Record Locks](#record-locks)
-    * [Grap Locks](#grap-locks)
+    * [Gap Locks](#gap-locks)
    * [Next-Key Locks](#next-key-locks)
 * [七、关系数据库设计理论](#七关系数据库设计理论)
    * [函数依赖](#函数依赖)
@ -70,7 +70,7 @@

 一旦事务提交，则其所做的修改将会永远保存到数据库中。即使系统发生崩溃，事务执行的结果也不能丢失。

-可以通过数据库备份和恢复来实现，在系统发生崩溃时，使用备份的数据库进行数据恢复。
+可以通过数据库备份和恢复来实现，在系统发生奔溃时，使用备份的数据库进行数据恢复。

 ----

@ -79,7 +79,7 @@
 - 只有满足一致性，事务的执行结果才是正确的。
 - 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时要只要能满足原子性，就一定能满足一致性。
 - 在并发的情况下，多个事务并发执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。
- 事务满足持久化是为了能应对数据库崩溃的情况。
+- 事务满足持久化是为了能应对数据库奔溃的情况。

 <div align="center"> <img src="../pics//35650b4b-efa1-49ba-9680-19837027cfc9.png" width="500"/> </div><br>

@ -346,7 +346,7 @@ InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回

 ### 4. UPDATE

-将当前系统版本号作为更新后的数据行快照的创建版本号，同时将当前系统版本号作为更新前的数据行快照的删除版本号。可以理解为先执行 DELETE 后执行 INSERT。
+将当前系统版本号作为更新前的数据行快照的删除版本号，并将当前系统版本号作为更新后的数据行快照的创建版本号。可以理解为先执行 DELETE 后执行 INSERT。

 ## 快照读与当前读

@ -378,7 +378,7 @@ Next-Key Locks 也是 MySQL 的 InnoDB 存储引擎的一种锁实现。MVCC 不

 锁定整个记录（行）。锁定的对象是记录的索引，而不是记录本身。如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚集索引，因此 Record Locks 依然可以使用。

-## Grap Locks
+## Gap Locks

 锁定一个范围内的索引，例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。

@ -491,7 +491,7 @@ Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门

 有以下函数依赖：

- Sno -> Sname, Sdept, Mname
+- Sno -> Sname, Sdept
 - Sdept -> Mname

 关系-2
--- a/notes/算法.md
+++ b/notes/算法.md
@ -24,8 +24,7 @@
    * [堆排序](#堆排序)
    * [小结](#小结)
 * [六、查找](#六查找)
-    * [链表实现无序符号表](#链表实现无序符号表)
-    * [二分查找实现有序符号表](#二分查找实现有序符号表)
+    * [初级实现](#初级实现)
    * [二叉查找树](#二叉查找树)
    * [2-3 查找树](#2-3-查找树)
    * [红黑树](#红黑树)
@ -1178,7 +1177,9 @@ public interface OrderedST<Key extends Comparable<Key>, Value> {
 }
 ```

-## 链表实现无序符号表
+## 初级实现
+
+### 1. 链表实现无序符号表

 ```java
 public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
@ -1253,7 +1254,7 @@ public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
 }
 ```

-## 二分查找实现有序符号表
+### 2. 二分查找实现有序符号表

 使用一对平行数组，一个存储键一个存储值。

@ -1308,7 +1309,7 @@ public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implement
    @Override
    public void put(Key key, Value value) {
        int index = rank(key);
-        // 如果找到已经存在的节点键位 key，就更新这个节点的值为 value
+        // 如果找到已经存在的节点键为 key，就更新这个节点的值为 value
        if (index < N && keys[index].compareTo(key) == 0) {
            values[index] = value;
            return;
@ -1398,7 +1399,7 @@ public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, V
 }
 ```

-（为了方便绘图，二叉树的空链接不画出来。）
+（为了方便绘图，下文中二叉树的空链接不画出来。）

 ### 1. get()

@ -1427,7 +1428,7 @@ private Value get(Node x, Key key) {

 ### 2. put()

-当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接使得该节点正确链接到树中。
+当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接指向该节点，使得该节点正确地链接到树中。

 <div align="center"> <img src="../pics//107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/> </div><br>

@ -1454,7 +1455,9 @@ private Node put(Node x, Key key, Value value) {

 ### 3. 分析

-二叉查找树的算法运行时间取决于树的形状，而树的形状又取决于键被插入的先后顺序。最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。
+二叉查找树的算法运行时间取决于树的形状，而树的形状又取决于键被插入的先后顺序。
+
+最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。

 <div align="center"> <img src="../pics//4d741402-344d-4b7c-be01-e57184bcad0e.png" width="200"/> </div><br>

@ -1467,8 +1470,7 @@ private Node put(Node x, Key key, Value value) {
 floor(key)：小于等于键的最大键

 - 如果键小于根节点的键，那么 floor(key) 一定在左子树中；
- 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就找到，否则根节点就是 floor(key)。
-
+- 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就返回，否则根节点就是 floor(key)。

 ```java
 public Key floor(Key key) {
@ -1497,7 +1499,7 @@ rank(key) 返回 key 的排名。

 - 如果键和根节点的键相等，返回左子树的节点数；
 - 如果小于，递归计算在左子树中的排名；
- 如果大于，递归计算在右子树中的排名，并加上左子树的节点数，再加上 1（根节点）。
+- 如果大于，递归计算在右子树中的排名，加上左子树的节点数，再加上 1（根节点）。

 ```java
@Override
@ -1793,15 +1795,15 @@ private Node put(Node x, Key key, Value value) {

 - 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。
 - 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
- 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，这个条件至关重要，直接影响到散列表的性能。
+- 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，如果不能满足这个条件，有可能产生很多冲突，从而导致散列表的性能下降。

 除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。

-对于其它数，可以将其转换成整数的形式，然后利用除留余数法。例如对于浮点数，可以将其表示成二进制形式，然后使用二进制形式的整数值进行除留余数法。
+对于其它数，可以将其转换成整数的形式，然后利用除留余数法。例如对于浮点数，可以将其的二进制形式转换成整数。

-对于有多部分组合的键，每部分都需要计算 hash 值，并且最后合并时需要让每部分 hash 值都具有同等重要的地位。可以将该键看成 R 进制的整数，键中每部分都具有不同的权值。
+对于多部分组合的类型，每个部分都需要计算 hash 值，这些 hash 值都具有同等重要的地位。为了达到这个目的，可以将该类型看成 R 进制的整数，每个部分都具有不同的权值。

-例如，字符串的散列函数实现如下
+例如，字符串的散列函数实现如下：

 ```java
 int hash = 0;
@ -1823,7 +1825,7 @@ Java 中的 hashCode() 实现了 hash 函数，但是默认使用对象的内存
 int hash = (x.hashCode() & 0x7fffffff) % M;
 ```

-使用 Java 自带的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()。
+使用 Java 自带的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()：

 ```java
 public class Transaction {
@ -1850,15 +1852,19 @@ public class Transaction {

 ### 2. 基于拉链法的散列表

-拉链法使用链表来存储 hash 值相同的键，从而解决冲突。此时查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
+拉链法使用链表来存储 hash 值相同的键，从而解决冲突。
+
+查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
+
+对于 N 个键，M 条链表 (N>M)，如果 hash 函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 \~N/M。

 <div align="center"> <img src="../pics//b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png" width="300"/> </div><br>

-对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 \~N/M。
-
 ### 3. 基于线性探测法的散列表

-线性探测法使用空位来解决冲突，当冲突发生时，向前探测一个空位来存储冲突的键。使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。
+线性探测法使用空位来解决冲突，当冲突发生时，向前探测一个空位来存储冲突的键。
+
+使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。

 <div align="center"> <img src="../pics//dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/> </div><br>

@ -1962,9 +1968,7 @@ public void delete(Key key) {

 <div align="center"> <img src="../pics//386cd64f-7a9d-40e6-8c55-22b90ee2d258.png" width="400"/> </div><br>

-α = N/M，把 α 称为利用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。
-
-为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。
+α = N/M，把 α 称为使用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。

 ```java
 private void resize() {
@ -2044,7 +2048,9 @@ public class SparseVector {
 2. 将 1 个圆盘从 from -> to
 3. 将 n-1 个圆盘从 buffer -> to

-如果只有一个圆盘，那么只需要进行一次移动操作，从上面的移动步骤可以知道，n 圆盘需要移动 (n-1)+1+(n-1) = 2n-1 次。 
+如果只有一个圆盘，那么只需要进行一次移动操作。
+
+从上面的讨论可以知道，n 圆盘需要移动 (n-1)+1+(n-1) = 2n-1 次。

 <div align="center"> <img src="../pics//54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/> </div><br>

@ -2093,7 +2099,7 @@ from H1 to H3
 - c : 40
 - d : 80

-可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码能让出现频率最大的字符编码最短，从而保证最终的编码长度最短。
+可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码能让出现频率最高的字符的编码最短，从而保证整体的编码长度最短。

 首先生成一颗哈夫曼树，每次生成过程中选取频率最少的两个节点，生成一个新节点作为它们的父节点，并且新节点的频率为两个节点的和。选取频率最少的原因是，生成过程使得先选取的节点在树的最底层，那么需要的编码长度更长，频率更少可以使得总编码长度更少。

--- a/notes/计算机网络.md
+++ b/notes/计算机网络.md
@ -199,7 +199,7 @@ TCP/IP 协议族是一种沙漏形状，中间小两边大，IP 协议在其中

 透明表示一个实际存在的事物看起来好像不存在一样。

-帧使用首部和尾部进行定界，如果帧的数据部分含有和首部尾部相同的内容，那么帧的开始和结束位置就会被错误的判定。需要在数据部分出现首部尾部相同的内容前面插入转义字符，如果出现转义字符，那么就在转义字符前面再加个转义字符，在接收端进行处理之后可以还原出原始数据。这个过程透明传输的内容是转义字符，用户察觉不到转义字符的存在。
+帧使用首部和尾部进行定界，如果帧的数据部分含有和首部尾部相同的内容，那么帧的开始和结束位置就会被错误的判定。需要在数据部分出现首部尾部相同的内容前面插入转义字符。如果数据部分出现转义字符，那么就在转义字符前面再加个转义字符。在接收端进行处理之后可以还原出原始数据。这个过程透明传输的内容是转义字符，用户察觉不到转义字符的存在。

 <div align="center"> <img src="../pics//c5022dd3-be22-4250-b9f6-38ae984a04d7.jpg" width="600"/> </div><br>

@ -279,11 +279,11 @@ CSMA/CD 表示载波监听多点接入 / 碰撞检测。

 -  **多点接入** ：说明这是总线型网络，许多主机以多点的方式连接到总线上。
 -  **载波监听** ：每个主机都必须不停地监听信道。在发送前，如果监听到信道正在使用，就必须等待。
-  **碰撞检测** ：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每一个主机在发送数据之前都已经监听到信道为空闲，但是由于电磁波的传播时延的存在，还是有可能会发生碰撞。
+-  **碰撞检测** ：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每个主机在发送数据之前都已经监听到信道为空闲，但是由于电磁波的传播时延的存在，还是有可能会发生碰撞。

 记端到端的传播时延为 τ，最先发送的站点最多经过 2τ 就可以知道是否发生了碰撞，称 2τ 为  **争用期** 。只有经过争用期之后还没有检测到碰撞，才能肯定这次发送不会发生碰撞。

-当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用  **截断二进制指数退避算法**  来确定，从离散的整数集合 {0, 1, .., (2<sup>k</sup>-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
+当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用  **截断二进制指数退避算法**  来确定。从离散的整数集合 {0, 1, .., (2<sup>k</sup>-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。

 <div align="center"> <img src="../pics//5aa82b89-f266-44da-887d-18f31f01d8ef.png" width="600"/> </div><br>

@ -293,7 +293,7 @@ CSMA/CD 表示载波监听多点接入 / 碰撞检测。

 <div align="center"> <img src="../pics//ddcf2327-8d84-425d-8535-121a94bcb88d.jpg" width="600"/> </div><br>

-在 PPP 的帧中：
+PPP 的帧格式：

 - F 字段为帧的定界符
 - A 和 C 字段暂时没有意义
@ -304,15 +304,17 @@ CSMA/CD 表示载波监听多点接入 / 碰撞检测。

 ## MAC 地址

-MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。一台主机拥有多少个适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。
+MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。
+
+一台主机拥有多少个适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。

 ## 局域网

-局域网是典型的一种广播信道，主要特点是网络为一个单位所拥有，且地理范围和站点数目均有限。
+局域网是一种典型的广播信道，主要特点是网络为一个单位所拥有，且地理范围和站点数目均有限。

-主要有以太网、令牌环网、FDDI 和 ATM 等局域网技术，目前以太网占领着现有的有线局域网市场。
+主要有以太网、令牌环网、FDDI 和 ATM 等局域网技术，目前以太网占领着有线局域网市场。

-可以按照网络拓扑对局域网进行分类：
+可以按照网络拓结构扑对局域网进行分类：

 <div align="center"> <img src="../pics//a6026bb4-3daf-439f-b1ec-a5a24e19d2fb.jpg" width="600"/> </div><br>

@ -320,11 +322,11 @@ MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标

 以太网是一种星型拓扑结构局域网。

-早期使用集线器进行连接，它是一种物理层设备，作用于比特而不是帧，当一个比特到达接口时，集线器重新生成这个比特，并将其能量强度放大，从而扩大网络的传输距离。之后再将这个比特向其它所有接口。特别是，如果集线器同时收到同时从两个不同接口的帧，那么就发生了碰撞。
+早期使用集线器进行连接。集线器是一种物理层设备，作用于比特而不是帧，当一个比特到达接口时，集线器重新生成这个比特，并将其能量强度放大，从而扩大网络的传输距离。之后再将这个比特发送到其它所有接口。如果集线器同时收到同时从两个不同接口的帧，那么就发生了碰撞。

-目前以太网使用交换机替代了集线器，它不会发生碰撞，能根据 MAC 地址进行存储转发。
+目前以太网使用交换机替代了集线器。交换机是一种链路层设备，它不会发生碰撞，能根据 MAC 地址进行存储转发。

-以太网帧：
+以太网帧格式：

 -  **类型** ：标记上层使用的协议；
 -  **数据** ：长度在 46-1500 之间，如果太小则需要填充；
@ -335,17 +337,17 @@ MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标

 ## 交换机*

-交换机具有自学习能力，学习的是交换表的内容。交换表中存储着 MAC 地址到接口的映射。下图中，交换机有 4 个接口，主机 A 向主机 B 发送数据帧时，交换机把主机 A 到接口 1 的映射写入交换表中。为了发送数据帧到 B，先查交换表，此时没有主机 B 的表项，那么主机 A 就发送广播帧，主机 C 和主机 D 会丢弃该帧。主机 B 收下之后，查找交换表得到主机 A 映射的接口为 1，就发送数据帧到接口 1，同时交换机添加主机 B 到接口 3 的映射。
+交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。正是由于这种自学习能力，因此交换机是一种即插即可即用设备，不需要网络管理员手动配置交换表内容。
+
+下图中，交换机有 4 个接口，主机 A 向主机 B 发送数据帧时，交换机把主机 A 到接口 1 的映射写入交换表中。为了发送数据帧到 B，先查交换表，此时没有主机 B 的表项，那么主机 A 就发送广播帧，主机 C 和主机 D 会丢弃该帧。主机 B 收下之后，查找交换表得到主机 A 映射的接口为 1，就发送数据帧到接口 1，同时交换机添加主机 B 到接口 3 的映射。

 <div align="center"> <img src="../pics//c9cfcd20-c901-435f-9a07-3e46830c359f.jpg" width="800"/> </div><br>

-它是一种即插即用急用的设备，不需要网络管理员干预。
-
 ## 虚拟局域网

-虚拟局域网可以建立与物理位置无关的逻辑组，只有在同一个虚拟局域网中的成员才会收到链路层广播信息，例如下图中 (A1, A2, A3, A4) 属于一个虚拟局域网，A1 发送的广播会被 A2、A3、A4 收到，而其它站点收不到。
+虚拟局域网可以建立与物理位置无关的逻辑组，只有在同一个虚拟局域网中的成员才会收到链路层广播信息。例如下图中 (A1, A2, A3, A4) 属于一个虚拟局域网，A1 发送的广播会被 A2、A3、A4 收到，而其它站点收不到。

-使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊端口被设置为干线端口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式——802.1Q，用于跨 VLAN 干线的帧，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。
+使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊端口被设置为干线端口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式 802.1Q，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。

 <div align="center"> <img src="../pics//a74b70ac-323a-4b31-b4d5-90569b8a944b.png" width="500"/> </div><br>

@ -526,7 +528,7 @@ VPN 使用公用的互联网作为本机构各专用网之间的通信载体。

 ### 1. 内部网关协议 RIP

-RIP 是一种基于距离向量的路由选择协议。距离是指跳数，直接相连的路由器跳数为 1，跳数最多为 15，超过 15 表示不可达。
+RIP 是一种基于距离向量的路由选择协议。距离是指跳数，直接相连的路由器跳数为 1。跳数最多为 15，超过 15 表示不可达。

 RIP 按固定的时间间隔仅和相邻路由器交换自己的路由表，经过若干次交换之后，所有路由器最终会知道到达本自治系统中任何一个网络的最短距离和下一跳路由器地址。

@ -558,7 +560,11 @@ OSPF 具有以下特点：

 BGP（Border Gateway Protocol，边界网关协议）

-AS 之间的路由选择很困难，主要是因为互联网规模很大。并且各个 AS 内部使用不同的路由选择协议，就无法准确定义路径的度量。并且 AS 之间的路由选择必须考虑有关的策略，比如有些 AS 不愿意让其它 AS 经过。
+AS 之间的路由选择很困难，主要是由于：
+
+- 互联网规模很大；
+- 各个 AS 内部使用不同的路由选择协议，无法准确定义路径的度量；
+- AS 之间的路由选择必须考虑有关的策略，比如有些 AS 不愿意让其它 AS 经过。

 BGP 只能寻找一条比较好的路由，而不是最佳路由。

@ -620,7 +626,7 @@ BGP 只能寻找一条比较好的路由，而不是最佳路由。

 第三次握手是为了防止失效的连接请求到达服务器，让服务器错误打开连接。

-失效的连接请求是指，客户端发送的连接请求在网络中滞留，客户端因为没及时收到服务器端发送的连接确认，因此就重新发送了连接请求。滞留的连接请求并不是丢失，之后还是会到达服务器。如果不进行第三次握手，那么服务器会误认为客户端重新请求连接，然后打开了连接。但是并不是客户端真正打开这个连接，因此客户端不会给服务器发送数据，这个连接就白白浪费了。
+客户端发送的连接请求如果在网络中滞留，那么就会隔很长一段时间才能收到服务器端发回的连接确认。客户端等待一个超时重传时间之后，就会重新请求连接。但是这个滞留的连接请求最后还是会到达服务器，如果不进行三次握手，那么服务器就会打开两个连接。如果有第三次握手，客户端会忽略服务器之后发送的对滞留连接请求的连接确认，不进行第三次握手，因此就不会再次打开连接。

 ## TCP 的四次挥手

@ -634,7 +640,7 @@ BGP 只能寻找一条比较好的路由，而不是最佳路由。

 - 当 B 不再需要连接时，发送连接释放请求报文段，FIN=1。

- A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL 时间后释放连接。
+- A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL（最大报文存活时间）后释放连接。

 - B 收到 A 的确认后释放连接。

@ -658,7 +664,7 @@ BGP 只能寻找一条比较好的路由，而不是最佳路由。

 发送窗口内的字节都允许被发送，接收窗口内的字节都允许被接收。如果发送窗口左部的字节已经发送并且收到了确认，那么就将发送窗口向右滑动一定距离，直到左部第一个字节不是已发送并且已确认的状态；接收窗口的滑动类似，接收窗口左部字节已经发送确认并交付主机，就向右滑动接收窗口。

-接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {32, 33} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
+接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {34, 35} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。

 ## TCP 可靠传输

@ -682,7 +688,7 @@ TCP 使用超时重传来实现可靠传输：如果一个已经发送的报文

 ## TCP 拥塞控制

-如果网络出现拥塞，分组将会丢失，此时发送方会继续重传，从而导致网络拥塞程度更高。因此当出现拥塞时，应当控制发送方的速率。这一点和流量控制很像，但是出发点不同。流量控制是为了让接收方能来得及接受，而拥塞控制是为了降低整个网络的拥塞程度。
+如果网络出现拥塞，分组将会丢失，此时发送方会继续重传，从而导致网络拥塞程度更高。因此当出现拥塞时，应当控制发送方的速率。这一点和流量控制很像，但是出发点不同。流量控制是为了让接收方能来得及接收，而拥塞控制是为了降低整个网络的拥塞程度。

 <div align="center"> <img src="../pics//51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg" width="500"/> </div><br>

@ -707,11 +713,11 @@ TCP 主要通过四种算法来进行拥塞控制：慢开始、拥塞避免、

 ### 2. 快重传与快恢复

-在接收方，要求每次接收到报文段都应该发送对已收到有序报文段的确认，例如已经接收到 M<sub>1</sub> 和 M<sub>2</sub>，此时收到 M<sub>4</sub>，应当发送对 M<sub>2</sub> 的确认。
+在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M<sub>1</sub> 和 M<sub>2</sub>，此时收到 M<sub>4</sub>，应当发送对 M<sub>2</sub> 的确认。

-在发送方，如果收到三个重复确认，那么可以确认下一个报文段丢失，例如收到三个 M<sub>2</sub> ，则 M<sub>3</sub> 丢失。此时执行快重传，立即重传下一个报文段。
+在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M<sub>2</sub>，则 M<sub>3</sub> 丢失，立即重传 M<sub>3</sub>。

-在这种情况下，只是丢失个别报文段，而不是网络拥塞，因此执行快恢复，令 ssthresh = cwnd/2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。
+在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd/2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。

 <div align="center"> <img src="../pics//f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png" width="600"/> </div><br>

--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@ -151,6 +151,28 @@ uniqueInstance 采用 volatile 关键字修饰也是很有必要的。`uniqueIns

 使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

+（五）静态内部类实现
+
+当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例。
+
+这种方式不仅具有延迟初始化的好处，而且由虚拟机提供了对线程安全的支持。
+
+```source-java
+public class Singleton {
+
+    private Singleton() {
+    }
+
+    private static class SingletonHolder {
+        private static final Singleton INSTANCE = new Singleton();
+    }
+
+    public static Singleton getUniqueInstance() {
+        return SingletonHolder.INSTANCE;
+    }
+}
+```
+
 （五）枚举实现

 这是单例模式的最佳实践，它实现简单，并且在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次。
--- a/经典练习题.sql
+++ b/经典练习题.sql
@ -0,0 +1,432 @@
+use fuxi;
+
+CREATE TABLE STUDENT
+(
+  SNO       VARCHAR(3) NOT NULL,
+  SNAME     VARCHAR(4) NOT NULL,
+  SSEX      VARCHAR(2) NOT NULL,
+  SBIRTHDAY DATETIME,
+  CLASS     VARCHAR(5)
+);
+
+CREATE TABLE COURSE
+(
+  CNO   VARCHAR(5)  NOT NULL,
+  CNAME VARCHAR(10) NOT NULL,
+  TNO   VARCHAR(10) NOT NULL
+);
+
+CREATE TABLE SCORE
+(
+  SNO    VARCHAR(3)     NOT NULL,
+  CNO    VARCHAR(5)     NOT NULL,
+  DEGREE NUMERIC(10, 1) NOT NULL
+);
+
+CREATE TABLE TEACHER
+(
+  TNO       VARCHAR(3)  NOT NULL,
+  TNAME     VARCHAR(4)  NOT NULL,
+  TSEX      VARCHAR(2)  NOT NULL,
+  TBIRTHDAY DATETIME    NOT NULL,
+  PROF      VARCHAR(6),
+  DEPART    VARCHAR(10) NOT NULL
+);
+
+INSERT INTO STUDENT (SNO, SNAME, SSEX, SBIRTHDAY, CLASS) VALUES (108, '曾华'
+  , '男', '1977-09-01', 95033);
+INSERT INTO STUDENT (SNO, SNAME, SSEX, SBIRTHDAY, CLASS) VALUES (105, '匡明'
+  , '男', '1975-10-02', 95031);
+INSERT INTO STUDENT (SNO, SNAME, SSEX, SBIRTHDAY, CLASS) VALUES (107, '王丽'
+  , '女', '1976-01-23', 95033);
+INSERT INTO STUDENT (SNO, SNAME, SSEX, SBIRTHDAY, CLASS) VALUES (101, '李军'
+  , '男', '1976-02-20', 95033);
+INSERT INTO STUDENT (SNO, SNAME, SSEX, SBIRTHDAY, CLASS) VALUES (109, '王芳'
+  , '女', '1975-02-10', 95031);
+INSERT INTO STUDENT (SNO, SNAME, SSEX, SBIRTHDAY, CLASS) VALUES (103, '陆君'
+  , '男', '1974-06-03', 95031);
+
+INSERT INTO COURSE (CNO, CNAME, TNO) VALUES ('3-105', '计算机导论', 825);
+INSERT INTO COURSE (CNO, CNAME, TNO) VALUES ('3-245', '操作系统', 804);
+INSERT INTO COURSE (CNO, CNAME, TNO) VALUES ('6-166', '数据电路', 856);
+INSERT INTO COURSE (CNO, CNAME, TNO) VALUES ('9-888', '高等数学', 100);
+
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (103, '3-245', 86);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (105, '3-245', 75);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (109, '3-245', 68);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (103, '3-105', 92);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (105, '3-105', 88);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (109, '3-105', 76);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (101, '3-105', 64);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (107, '3-105', 91);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (101, '6-166', 85);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (107, '6-106', 79);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (108, '3-105', 78);
+INSERT INTO SCORE (SNO, CNO, DEGREE) VALUES (108, '6-166', 81);
+
+INSERT INTO TEACHER (TNO, TNAME, TSEX, TBIRTHDAY, PROF, DEPART)
+VALUES (804, '李诚', '男', '1958-12-02', '副教授', '计算机系');
+INSERT INTO TEACHER (TNO, TNAME, TSEX, TBIRTHDAY, PROF, DEPART)
+VALUES (856, '张旭', '男', '1969-03-12', '讲师', '电子工程系');
+INSERT INTO TEACHER (TNO, TNAME, TSEX, TBIRTHDAY, PROF, DEPART)
+VALUES (825, '王萍', '女', '1972-05-05', '助教', '计算机系');
+INSERT INTO TEACHER (TNO, TNAME, TSEX, TBIRTHDAY, PROF, DEPART)
+VALUES (831, '刘冰', '女', '1977-08-14', '助教', '电子工程系');
+
+-- 1、 查询Student表中的所有记录的Sname、Ssex和Class列。
+select
+  SNAME,
+  SSEX,
+  CLASS
+from STUDENT;
+
+-- 2、 查询教师所有的单位即不重复的Depart列。
+select distinct DEPART
+from TEACHER1;
+
+-- 3、 查询Student表的所有记录。
+select *
+from STUDENT;
+
+-- 4、 查询Score表中成绩在60到80之间的所有记录。
+select *
+from SCORE
+where DEGREE > 60 and DEGREE < 80;
+
+-- 5、 查询Score表中成绩为85，86或88的记录。
+select *
+from SCORE
+where DEGREE = 85 or DEGREE = 86 or DEGREE = 88;
+
+-- 6、 查询Student表中“95031”班或性别为“女”的同学记录。
+select *
+from STUDENT
+where CLASS = '95031' or SSEX = '女';
+
+-- 7、 以Class降序查询Student表的所有记录。
+select *
+from STUDENT
+order by CLASS desc;
+
+-- 8、 以Cno升序、Degree降序查询Score表的所有记录。
+select *
+from SCORE
+order by CNO asc, DEGREE desc;
+
+-- 9、 查询“95031”班的学生人数。
+select count(*)
+from STUDENT
+where CLASS = '95031';
+
+-- 10、查询Score表中的最高分的学生学号和课程号。
+select
+  sno,
+  CNO
+from SCORE
+where DEGREE = (
+  select max(DEGREE)
+  from SCORE
+);
+
+-- 11、查询‘3-105’号课程的平均分。
+select avg(DEGREE)
+from SCORE
+where CNO = '3-105';
+
+-- 12、查询Score表中至少有5名学生选修的并以3开头的课程的平均分数。
+select
+  avg(DEGREE),
+  CNO
+from SCORE
+where cno like '3%'
+group by CNO
+having count(*) > 5;
+
+-- 13、查询最低分大于70，最高分小于90的Sno列。
+select SNO
+from SCORE
+group by SNO
+having min(DEGREE) > 70 and max(DEGREE) < 90;
+
+-- 14、查询所有学生的Sname、Cno和Degree列。
+select
+  SNAME,
+  CNO,
+  DEGREE
+from STUDENT, SCORE
+where STUDENT.SNO = SCORE.SNO;
+
+-- 15、查询所有学生的Sno、Cname和Degree列。
+select
+  SCORE.SNO,
+  CNO,
+  DEGREE
+from STUDENT, SCORE
+where STUDENT.SNO = SCORE.SNO;
+
+-- 16、查询所有学生的Sname、Cname和Degree列。
+SELECT
+  A.SNAME,
+  B.CNAME,
+  C.DEGREE
+FROM STUDENT A
+  JOIN (COURSE B, SCORE C)
+    ON A.SNO = C.SNO AND B.CNO = C.CNO;
+
+-- 17、查询“95033”班所选课程的平均分。
+select avg(DEGREE)
+from SCORE
+where sno in (select SNO
+              from STUDENT
+              where CLASS = '95033');
+
+-- 18、假设使用如下命令建立了一个grade表：
+create table grade (
+  low  numeric(3, 0),
+  upp  numeric(3),
+  rank char(1)
+);
+insert into grade values (90, 100, 'A');
+insert into grade values (80, 89, 'B');
+insert into grade values (70, 79, 'C');
+insert into grade values (60, 69, 'D');
+insert into grade values (0, 59, 'E');
+-- 现查询所有同学的Sno、Cno和rank列。
+SELECT
+  A.SNO,
+  A.CNO,
+  B.RANK
+FROM SCORE A, grade B
+WHERE A.DEGREE BETWEEN B.LOW AND B.UPP
+ORDER BY RANK;
+
+-- 19、查询选修“3-105”课程的成绩高于“109”号同学成绩的所有同学的记录。
+select *
+from SCORE
+where CNO = '3-105' and DEGREE > ALL (
+  select DEGREE
+  from SCORE
+  where SNO = '109'
+);
+
+set @@global.sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION';
+set sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION';
+
+-- 20、查询score中选学一门以上课程的同学中分数为非最高分成绩的记录
+select *
+from SCORE
+where DEGREE < (select MAX(DEGREE)
+                from SCORE)
+group by SNO
+having count(*) > 1;
+
+-- 21、查询成绩高于学号为“109”、课程号为“3-105”的成绩的所有记录。
+-- 同19
+
+-- 22、查询和学号为108的同学同年出生的所有学生的Sno、Sname和Sbirthday列。
+select
+  SNO,
+  SNAME,
+  SBIRTHDAY
+from STUDENT
+where year(SBIRTHDAY) = (
+  select year(SBIRTHDAY)
+  from STUDENT
+  where SNO = '108'
+);
+
+-- 23、查询“张旭“教师任课的学生成绩。
+select *
+from SCORE
+where cno = (
+  select CNO
+  from COURSE
+    inner join TEACHER on COURSE.TNO = TEACHER.TNO and TNAME = '张旭'
+);
+
+-- 24、查询选修某课程的同学人数多于5人的教师姓名。
+select TNAME
+from TEACHER
+where TNO = (
+  select TNO
+  from COURSE
+  where CNO = (select CNO
+               from SCORE
+               group by CNO
+               having count(SNO) > 5)
+);
+
+-- 25、查询95033班和95031班全体学生的记录。
+select *
+from STUDENT
+where CLASS in ('95033', '95031');
+
+-- 26、查询存在有85分以上成绩的课程Cno.
+select cno
+from SCORE
+group by CNO
+having MAX(DEGREE) > 85;
+
+-- 27、查询出“计算机系“教师所教课程的成绩表。
+select *
+from SCORE
+where CNO in (select CNO
+              from TEACHER, COURSE
+              where DEPART = '计算机系' and COURSE.TNO = TEACHER.TNO);
+
+-- 28、查询“计算机系”与“电子工程系“不同职称的教师的Tname和Prof
+select
+  tname,
+  prof
+from TEACHER
+where depart = '计算机系' and prof not in (
+  select prof
+  from TEACHER
+  where depart = '电子工程系'
+);
+
+-- 29、查询选修编号为“3-105“课程且成绩至少高于选修编号为“3-245”的同学的Cno、Sno和Degree,并按Degree从高到低次序排序。
+select
+  CNO,
+  SNO,
+  DEGREE
+from SCORE
+where CNO = '3-105' and DEGREE > any (
+  select DEGREE
+  from SCORE
+  where CNO = '3-245'
+)
+order by DEGREE desc;
+
+-- 30、查询选修编号为“3-105”且成绩高于选修编号为“3-245”课程的同学的Cno、Sno和Degree.
+SELECT *
+FROM SCORE
+WHERE DEGREE > ALL (
+  SELECT DEGREE
+  FROM SCORE
+  WHERE CNO = '3-245'
+)
+ORDER by DEGREE desc;
+
+-- 31、查询所有教师和同学的name、sex和birthday.
+select
+  TNAME     name,
+  TSEX      sex,
+  TBIRTHDAY birthday
+from TEACHER
+union
+select
+  sname     name,
+  SSEX      sex,
+  SBIRTHDAY birthday
+from STUDENT;
+
+-- 32、查询所有“女”教师和“女”同学的name、sex和birthday.
+select
+  TNAME     name,
+  TSEX      sex,
+  TBIRTHDAY birthday
+from TEACHER
+where TSEX = '女'
+union
+select
+  sname     name,
+  SSEX      sex,
+  SBIRTHDAY birthday
+from STUDENT
+where SSEX = '女';
+
+-- 33、查询成绩比该课程平均成绩低的同学的成绩表。
+SELECT A.*
+FROM SCORE A
+WHERE DEGREE < (SELECT AVG(DEGREE)
+                FROM SCORE B
+                WHERE A.CNO = B.CNO);
+
+-- 34、查询所有任课教师的Tname和Depart.
+select
+  TNAME,
+  DEPART
+from TEACHER a
+where exists(select *
+             from COURSE b
+             where a.TNO = b.TNO);
+
+-- 35、查询所有未讲课的教师的Tname和Depart.
+select
+  TNAME,
+  DEPART
+from TEACHER a
+where tno not in (select tno
+                  from COURSE);
+
+-- 36、查询至少有2名男生的班号。
+select CLASS
+from STUDENT
+where SSEX = '男'
+group by CLASS
+having count(SSEX) > 1;
+
+-- 37、查询Student表中不姓“王”的同学记录。
+select *
+from STUDENT
+where SNAME not like "王%";
+
+-- 38、查询Student表中每个学生的姓名和年龄。
+select
+  SNAME,
+  year(now()) - year(SBIRTHDAY)
+from STUDENT;
+
+-- 39、查询Student表中最大和最小的Sbirthday日期值。
+select min(SBIRTHDAY) birthday
+from STUDENT
+union
+select max(SBIRTHDAY) birthday
+from STUDENT;
+
+-- 40、以班号和年龄从大到小的顺序查询Student表中的全部记录。
+select *
+from STUDENT
+order by CLASS desc, year(now()) - year(SBIRTHDAY) desc;
+
+-- 41、查询“男”教师及其所上的课程。
+select *
+from TEACHER, COURSE
+where TSEX = '男' and COURSE.TNO = TEACHER.TNO;
+
+-- 42、查询最高分同学的Sno、Cno和Degree列。
+select
+  sno,
+  CNO,
+  DEGREE
+from SCORE
+where DEGREE = (select max(DEGREE)
+                from SCORE);
+
+-- 43、查询和“李军”同性别的所有同学的Sname.
+select sname
+from STUDENT
+where SSEX = (select SSEX
+              from STUDENT
+              where SNAME = '李军');
+
+-- 44、查询和“李军”同性别并同班的同学Sname.
+select sname
+from STUDENT
+where (SSEX, CLASS) = (select
+                         SSEX,
+                         CLASS
+                       from STUDENT
+                       where SNAME = '李军');
+
+-- 45、查询所有选修“计算机导论”课程的“男”同学的成绩表
+select *
+from SCORE, STUDENT
+where SCORE.SNO = STUDENT.SNO and SSEX = '男' and CNO = (
+  select CNO
+  from COURSE
+  where CNAME = '计算机导论');
+
+
+
--- a/other/计算机网络脑图.png
+++ b/other/计算机网络脑图.png
--- a/pics/a0df8edc-581b-4977-95c2-d7025795b899.png
+++ b/pics/a0df8edc-581b-4977-95c2-d7025795b899.png