diff --git a/notes/HTTP.md b/notes/HTTP.md
index 7d64c901..915e19ee 100644
--- 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>
 
diff --git a/notes/Java IO.md b/notes/Java IO.md
index c41f7f05..08dc80f4 100644
--- a/notes/Java IO.md	
+++ b/notes/Java IO.md	
@@ -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 面向流
 
 # 八、参考资料
 
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index 842ebd84..bdd13aff 100644
--- a/notes/Java 基础.md	
+++ b/notes/Java 基础.md	
@@ -484,7 +484,7 @@ System.out.println(InterfaceExample.x);
 使用抽象类：
 
 - 需要在几个相关的类中共享代码。
-- 需要能控制继承来的方法和域的访问权限，而不是都为 public。
+- 需要能控制继承来的成员的访问权限，而不是都为 public。
 - 需要继承非静态（non-static）和非常量（non-final）字段。
 
 使用接口：
@@ -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 {
@@ -1112,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>
 
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index 55cffe2c..9e6e2ac3 100644
--- a/notes/Java 容器.md	
+++ b/notes/Java 容器.md	
@@ -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. 概览
diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 9c55c715..800796db 100644
--- a/notes/Java 并发.md	
+++ b/notes/Java 并发.md	
@@ -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），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
 
-可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
+可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
 
 **（二）栈封闭** 
 
diff --git a/notes/Java 虚拟机.md b/notes/Java 虚拟机.md
index 1d2b4f14..552a5e94 100644
--- a/notes/Java 虚拟机.md	
+++ b/notes/Java 虚拟机.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。
 
 # 三、类加载机制
 
diff --git a/notes/MySQL.md b/notes/MySQL.md
index e460d98a..d49fc952 100644
--- 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. 索引列的顺序
@@ -379,7 +379,7 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 
 垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。
 
-在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库 payDB、用户数据库 userBD 等。
+在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库 payDB、用户数据库 userDB 等。
 
 ## Sharding 策略
 
diff --git a/notes/SQL.md b/notes/SQL.md
index 3bbb121f..ca9b7b29 100644
--- a/notes/SQL.md
+++ b/notes/SQL.md
@@ -170,7 +170,6 @@ FROM mytable
 LIMIT 2, 3;
 ```
 
-
 # 八、排序
 
 -  **ASC** ：升序（默认）
diff --git a/notes/Socket.md b/notes/Socket.md
index 13f1eaf5..8e7c0b89 100644
--- 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-比较)
-    * [eopll 工作模式](#eopll-工作模式)
+    * [工作模式](#工作模式)
     * [应用场景](#应用场景)
 * [参考资料](#参考资料)
 <!-- 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。
-
-## eopll 工作模式
-
-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/)
diff --git a/notes/代码风格规范.md b/notes/代码风格规范.md
index b1ce8137..dedada7d 100644
--- 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)
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index c0c5412f..7ff73846 100644
--- a/notes/剑指 offer 题解.md	
+++ b/notes/剑指 offer 题解.md	
@@ -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) {
 
 ## 题目描述
 
-保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。
+需要保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。
 
 ## 解题思路
 
diff --git a/notes/数据库系统原理.md b/notes/数据库系统原理.md
index 4aaa9044..87d210a9 100644
--- 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)
 * [七、关系数据库设计理论](#七关系数据库设计理论)
     * [函数依赖](#函数依赖)
@@ -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
diff --git a/notes/计算机网络.md b/notes/计算机网络.md
index 1c38cc0a..8603393c 100644
--- a/notes/计算机网络.md
+++ b/notes/计算机网络.md
@@ -664,7 +664,7 @@ BGP 只能寻找一条比较好的路由，而不是最佳路由。
 
 发送窗口内的字节都允许被发送，接收窗口内的字节都允许被接收。如果发送窗口左部的字节已经发送并且收到了确认，那么就将发送窗口向右滑动一定距离，直到左部第一个字节不是已发送并且已确认的状态；接收窗口的滑动类似，接收窗口左部字节已经发送确认并交付主机，就向右滑动接收窗口。
 
-接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {32, 33} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
+接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {34, 35} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
 
 ## TCP 可靠传输
 
diff --git a/新建文本文档.txt b/新建文本文档.txt
new file mode 100644
index 00000000..8dcc8e7d
--- /dev/null
+++ b/新建文本文档.txt
@@ -0,0 +1,36 @@
+# Summary
+
+* 算法
+  * [剑指 Offer 题解](/notes/剑指%20offer%20题解.md) 
+  * [Leetcode 题解](/notes/Leetcode%20题解.md)
+  * [算法](/notes/算法.md)
+* 操作系统
+  * [计算机操作系统](/notes/计算机操作系统.md)
+  * [Linux](/notes/Linux.md)
+* 网络
+  * [计算机网络](/notes/计算机网络.md)
+  * [HTTP](/notes/HTTP.md)
+  * [Socket](/notes/Socket.md)
+* 面向对象
+  * [设计模式](/notes/设计模式.md)
+  * [面向对象思想](/notes/面向对象思想.md)
+* 数据库
+  * [数据库系统原理](/notes/数据库系统原理.md)
+  * [SQL](/notes/SQL.md)
+  * [Leetcode-Database 题解](/notes/Leetcode-Database%20题解.md)
+  * [MySQL](/notes/MySQL.md)
+  * [Redis](/notes/Redis.md)
+* Java
+  * [Java 基础](/notes/Java%20基础.md)
+  * [Java 虚拟机](/notes/Java%20虚拟机.md)
+  * [Java 并发](/notes/Java%20并发.md)
+  * [Java 容器](/notes/Java%20容器.md)
+  * [Java I/O](/notes/Java%20IO.md)
+* 分布式
+  * [一致性](/notes/一致性.md)
+  * [分布式问题分析](/notes/分布式问题分析.md)
+
+
+
+
+