Merge pull request #3 from CyC2018/master

5.6更新

.gitignore

@@ -1 +1,2 @@
-*.txt
+*.txt
+.idea/

README.md

@@ -2,13 +2,10 @@
 | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
 | 算法[: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) |
+
+本仓库不参与商业行为，不向读者收取任何费用。(This repository is not engaging in business activities, and does not charge readers any fee.)
 </br>
 
-:loudspeaker: 本仓库不参与商业行为，不向读者收取任何费用。
-
-:loudspeaker: This repository is not engaging in business activities, and does not charge readers any fee.
-</br></br>
-
 ## 算法 :pencil2:
 
 
@@ -147,9 +144,9 @@ Google 开源项目的代码风格规范。
 
 **关于贡献**
 
-因为大部分内容是笔者一个字一个字打上去的，所有难免会有一些笔误。如果发现，可以直接在相应的文档上编辑修改。
+因为大部分内容是笔者一个字一个字打上去的，所以难免会有一些笔误。如果发现，可以直接在相应的文档上编辑修改。
 
-笔者能力有限，很多内容还不够完善。如果您希望和笔者一起完善这个仓库，可以在发表一个 Issue，表明您想要添加的内容，笔者会及时查看。
+笔者能力有限，很多内容还不够完善。如果您希望和笔者一起完善这个仓库，可以发表一个 Issue，表明您想要添加的内容，笔者会及时查看。
 
 因为不打算将这个仓库做成一个大而全的面试宝典，只希望添加一些比较通用的基础知识，或者是与 Java 和分布式相关的内容，但是不添加 Java Web 相关的内容。
 
@@ -163,7 +160,7 @@ Google 开源项目的代码风格规范。
 
 **关于排版**
 
-笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/#%E4%B8%8D%E8%A6%81%E4%BD%BF%E7%94%A8%E4%B8%8D%E5%9C%B0%E9%81%93%E7%9A%84%E7%BC%A9%E5%86%99) 进行排版，以保证内容的可读性。这里提供了笔者实现的中英混排文档在线排版工具：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)，目前实现了加空格的功能，之后打算实现对英文专有名词提示首字母大写的功能。
+笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。这里提供了笔者实现的中英混排文档在线排版工具：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)，目前实现了加空格的功能，之后打算实现对英文专有名词提示首字母大写的功能。
 
 不使用 `![]()` 这种方式来引用图片是为了能够控制图片以合适的大小显示。而且 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` ，所以只能使用 img 标签来引用图片。
 

notes/HTTP.md

@@ -63,15 +63,15 @@
 
 ## Web 基础
 
-- HTTP（HyperText Transfer Protocol，超文本传输协议）。
+- HTTP（HyperText Transfer Protocol，超文本传输协议）
-- WWW（World Wide Web）的三种技术：HTML、HTTP、URL。
+- WWW（World Wide Web）的三种技术：HTML、HTTP、URL
 - RFC（Request for Comments，征求修正意见书），互联网的设计文档。
 
 ## URL
 
 - URI（Uniform Resource Indentifier，统一资源标识符）
 - URL（Uniform Resource Locator，统一资源定位符）
-- URN（Uniform Resource Name，统一资源名称），例如 urn:isbn:0-486-27557-4 。
+- URN（Uniform Resource Name，统一资源名称），例如 urn:isbn:0-486-27557-4。
 
 URI 包含 URL 和 URN，目前 WEB 只有 URL 比较流行，所以见到的基本都是 URL。
 

notes/Java 基础.md

@@ -269,7 +269,7 @@ set.add(e2);
 System.out.println(set.size()); // 2
 ```
 
-理想的散列函数应当具有均匀性，即不相等的实例应当均匀分不到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来，可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
+理想的散列函数应当具有均匀性，即不相等的实例应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来，可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
 
 一个数与 31 相乘可以转换成移位和减法：31\*x == (x<<5)-x。
 
@@ -506,9 +506,9 @@ protected 用于修饰成员，表示在继承体系中成员对于子类可见
 
 设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
 
-如果子类的方法覆盖了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里式替换原则。
+如果子类的方法覆盖了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
 
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。可以使用共有的 getter 和 setter 方法来替换共有字段。
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。可以使用公有的 getter 和 setter 方法来替换公有字段。
 
 ```java
 public class AccessExample {
@@ -634,14 +634,14 @@ System.out.println(InterfaceExample.x);
 
 - 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
 - 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
-- 接口的字段只能是 static 和 final 类型的，而抽象类的字段可以有多种访问权限。
+- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
 - 接口的方法只能是 public 的，而抽象类的方法可以由多种访问权限。
 
 **4. 使用选择** 
 
 使用抽象类：
 
-- 需要在几个相关的类中共享代码；
+- 需要在几个相关的类中共享代码。
 - 需要能控制继承来的方法和域的访问权限，而不是都为 public。
 - 需要继承非静态（non-static）和非常量（non-final）字段。
 
@@ -771,7 +771,7 @@ String s5 = "bbb";
 System.out.println(s4 == s5);  // true
 ```
 
-Java 虚拟机将堆划分成新生代、老年代和永久代（PermGen Space）。在 Java 7 之前，字符串常量池被放在永久代中，而在 Java 7，它被放在堆的其它位置。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
+在 Java 7 之前，字符串常量池被放在运行时常量池中，它属于永久代。而在 Java 7，字符串常量池被放在堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
 
 > [What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning) </br> [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
 

notes/Java 容器.md

@@ -212,7 +212,7 @@ private void writeObject(java.io.ObjectOutputStream s)
 
 ### 4. 和 LinkedList 的区别
 
-- ArrayList 基于动态数组实现，LinkedList 基于双向循环链表实现；
+- ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
 - ArrayList 支持随机访问，LinkedList 不支持；
 - LinkedList 在任意位置添加删除元素更快。
 

notes/Java 并发.md

@@ -43,6 +43,7 @@
     * [内存模型三大特性](#内存模型三大特性)
     * [先行发生原则](#先行发生原则)
 * [十一、线程安全](#十一线程安全)
+    * [线程安全定义](#线程安全定义)
     * [线程安全分类](#线程安全分类)
     * [线程安全的实现方法](#线程安全的实现方法)
 * [十二、锁优化](#十二锁优化)
@@ -86,7 +87,7 @@
 
 ## 限期等待（Timed Waiting）
 
-无需等待其它线程显示地唤醒，在一定时间之后会被系统自动唤醒。
+无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
 
 调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
 
@@ -188,7 +189,7 @@ public static void main(String[] args) {
 
 ## Executor
 
-Executor 管理多个异步任务的执行，而无需程序员显示地管理线程的生命周期。
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。
 
 主要有三种 Executor：
 
@@ -715,10 +716,10 @@ java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.
 public class CountdownLatchExample {
 
     public static void main(String[] args) throws InterruptedException {
-        final int totalTread = 10;
+        final int totalThread = 10;
-        CountDownLatch countDownLatch = new CountDownLatch(totalTread);
+        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
         ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalTread; i++) {
+        for (int i = 0; i < totalThread; i++) {
             executorService.execute(() -> {
                 System.out.print("run..");
                 countDownLatch.countDown();
@@ -747,12 +748,11 @@ run..run..run..run..run..run..run..run..run..run..end
 
 ```java
 public class CyclicBarrierExample {
-
     public static void main(String[] args) throws InterruptedException {
-        final int totalTread = 10;
+        final int totalThread = 10;
-        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalTread);
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
         ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalTread; i++) {
+        for (int i = 0; i < totalThread; i++) {
             executorService.execute(() -> {
                 System.out.print("before..");
                 try {
@@ -1235,6 +1235,10 @@ join() 方法返回先行发生于 Thread 对象的结束。
 
 # 十一、线程安全
 
+## 线程安全定义
+
+一个类在可以被多个线程安全调用时就是线程安全的。
+
 ## 线程安全分类
 
 线程安全不是一个非真即假的命题，可以将共享数据按照安全程度的强弱顺序分成以下五类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。
@@ -1507,7 +1511,7 @@ public class ThreadLocalExample1 {
 
 <div align="center"> <img src="../pics//3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/> </div><br>
 
-每个 Thread 都有一个 TreadLocal.ThreadLocalMap 对象，Thread 类中就定义了 ThreadLocal.ThreadLocalMap 成员。
+每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象，Thread 类中就定义了 ThreadLocal.ThreadLocalMap 成员。
 
 ```java
 /* ThreadLocal values pertaining to this thread. This map is maintained
@@ -1595,7 +1599,7 @@ public static String concatString(String s1, String s2, String s3) {
 
 ## 轻量级锁
 
-轻量级锁是 JDK 1.6 之中加入的新型锁机制，它名字中的“轻量级”是相对于使用操作系统互斥量来实现的传统锁而言的，因此传统的锁机制就称为“重量级”锁。首先需要强调一点的是，轻量级锁并不是用来代替重要级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
+轻量级锁是 JDK 1.6 之中加入的新型锁机制，它名字中的“轻量级”是相对于使用操作系统互斥量来实现的传统锁而言的，因此传统的锁机制就称为“重量级”锁。首先需要强调一点的是，轻量级锁并不是用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
 
 要理解轻量级锁，以及后面会讲到的偏向锁的原理和运作过程，必须从 HotSpot 虚拟机的对象（对象头部分）的内存布局开始介绍。HotSpot 虚拟机的对象头（Object Header）分为两部分信息，第一部分用于存储对象自身的运行时数据，如哈希码（HashCode）、GC 分代年龄（Generational GC Age）等，这部分数据是长度在 32 位和 64 位的虚拟机中分别为 32 bit 和 64 bit，官方称它为“Mark Word”，它是实现轻量级锁和偏向锁的关键。另外一部分用于存储指向方法区对象类型数据的指针，如果是数组对象的话，还会有一个额外的部分用于存储数组长度。
 

notes/Java 虚拟机.md

@@ -123,7 +123,7 @@ objB.instance = objA;
 
 ### 2. 可达性
 
-通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是都是可用的，不可达的对象可被回收。
+通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是可用的，不可达的对象可被回收。
 
 <div align="center"> <img src="../pics//0635cbe8.png" width=""/> </div><br>
 
@@ -142,7 +142,7 @@ Java 对引用的概念进行了扩充，引入四种强度不同的引用类型
 
 **（一）强引用** 
 
-只要强引用存在，垃圾回收器永远不会回收掉被引用的对象。
+只要强引用存在，垃圾回收器永远不会回收被引用的对象。
 
 使用 new 一个新对象的方式来创建强引用。
 

notes/MySQL.md

@@ -36,11 +36,11 @@ InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支
 
 内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够自动在内存中创建哈希索引以加速读操作的自适应哈希索引、能够加速插入操作的插入缓冲区等。
 
-通过一些机制和工具支持真正的热备份，其它存储引擎不支持热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
+通过一些机制和工具支持真正的热备份。其它存储引擎不支持热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
 
 ## MyISAM
 
-提供了大量的特性，包括全文索引、压缩表、空间数据索引等。应该注意的是，MySQL 5.6.4 添加了对 InnoDB 引擎的全文索引支持。
+MyISAM 提供了大量的特性，包括全文索引、压缩表、空间数据索引等。应该注意的是，MySQL 5.6.4 也添加了对 InnoDB 存储引擎的全文索引支持。
 
 不支持事务。
 
@@ -140,7 +140,12 @@ B+Tree 索引是大多数 MySQL 存储引擎的默认索引类型。
 
 InnoDB 引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
 
-限制：哈希索引只包含哈希值和行指针，而不存储字段值，所以不能使用索引中的值来避免读取行。不过，访问内存中的行的速度很快，所以大部分情况下这一点对性能影响并不明显；无法用于分组与排序；只支持精确查找，无法用于部分查找和范围查找；如果哈希冲突很多，查找速度会变得很慢。
+限制：
+
+- 哈希索引只包含哈希值和行指针，而不存储字段值，所以不能使用索引中的值来避免读取行。不过，访问内存中的行的速度很快，所以大部分情况下这一点对性能影响并不明显；
+- 无法用于分组与排序；
+- 只支持精确查找，无法用于部分查找和范围查找；
+- 如果哈希冲突很多，查找速度会变得很慢。
 
 ### 3. 空间数据索引（R-Tree）
 
@@ -162,7 +167,7 @@ MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而
 
 - 帮助服务器避免进行排序和创建临时表（B+Tree 索引是有序的，可以用来做 ORDER BY 和 GROUP BY 操作）；
 
-- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，也就将相关的列值都存储在一起）。
+- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，也就将相邻的列值都存储在一起）。
 
 ## 索引优化
 

notes/Redis.md

@@ -320,7 +320,7 @@ Redis Cluster。
 
 ### 2. 时间事件
 
-又分为两类：定时事件是让一段程序在指定的时间之内执行一次；周期性时间是让一段程序每隔指定时间就执行一次。
+又分为两类：定时事件是让一段程序在指定的时间之内执行一次；周期性事件是让一段程序每隔指定时间就执行一次。
 
 ## 事件的调度与执行
 
@@ -466,7 +466,7 @@ Redis 没有关系型数据库中的表这一概念来将同类型的数据存
 # 参考资料
 
 - Carlson J L. Redis in Action[J]. Media.johnwiley.com.au, 2013.
-- 黄健宏. Redis 设计与实现 [M]. 机械工业出版社, 2014.
+- [黄健宏. Redis 设计与实现 [M]. 机械工业出版社, 2014.](http://redisbook.com/index.html)
 - [REDIS IN ACTION](https://redislabs.com/ebook/foreword/)
 - [论述 Redis 和 Memcached 的差异](http://www.cnblogs.com/loveincode/p/7411911.html)
 - [Redis 3.0 中文版- 分片](http://wiki.jikexueyuan.com/project/redis-guide)

notes/分布式问题分析.md

@@ -95,7 +95,7 @@
 
 <div align="center"> <img src="../pics//2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg"/> </div><br>
 
-该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担多大的负载（下图的 Server 2）。
+该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担过大的负载（下图的 Server 2）。
 
 <div align="center"> <img src="../pics//f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg"/> </div><br>
 
@@ -107,7 +107,7 @@
 
 ### 3. 最少连接（least Connections）
 
-由于每个请求的连接时间不一样，使用轮询或者加权轮询算法的话，可能会让一台服务器当前连接数多大，而另一台服务器的连接多小，造成负载不均衡。例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开。该系统继续运行时，服务器 2 会承担多大的负载。
+由于每个请求的连接时间不一样，使用轮询或者加权轮询算法的话，可能会让一台服务器当前连接数过大，而另一台服务器的连接过小，造成负载不均衡。例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开。该系统继续运行时，服务器 2 会承担过大的负载。
 
 <div align="center"> <img src="../pics//3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg"/> </div><br>
 
@@ -257,7 +257,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 **（六）羊群效应** 
 
-在步骤二，一个节点未获得锁，需要监听监听自己的前一个子节点，这是因为如果监听所有的子节点，那么任意一个子节点状态改变，其它所有子节点都会收到通知（羊群效应），而我们只希望它的后一个子节点收到通知。
+在步骤二，一个节点未获得锁，需要监听自己的前一个子节点，这是因为如果监听所有的子节点，那么任意一个子节点状态改变，其它所有子节点都会收到通知（羊群效应），而我们只希望它的后一个子节点收到通知。
 
 # 五、分布式 Session
 

notes/数据库系统原理.md

@@ -86,7 +86,7 @@ T<sub>1</sub> 修改一个数据，T<sub>2</sub> 随后读取这个数据。如
 
 ### 3. 不可重复读
 
-T<sub>2</sub> 读取一个数据，T<sub>1</sub> 对该数据做了修改。如果 T<sub>2</sub> 再次读取这个数据，此时读取的结果和和第一次读取的结果不同。
+T<sub>2</sub> 读取一个数据，T<sub>1</sub> 对该数据做了修改。如果 T<sub>2</sub> 再次读取这个数据，此时读取的结果和第一次读取的结果不同。
 
 <div align="center"> <img src="../pics//c8d18ca9-0b09-441a-9a0c-fb063630d708.png"/> </div><br>
 
@@ -235,7 +235,7 @@ lock-x(A)...lock-s(B)...lock-s(C)...unlock(A)...unlock(C)...unlock(B)
 但不是必要条件，例如以下操作不满足两段锁协议，但是它还是可串行化调度。
 
 ```html
-lock-x(A)...unlock(A)...lock-s(B)...unlock(B)...lock-s(C)...unlock(C)...
+lock-x(A)...unlock(A)...lock-s(B)...unlock(B)...lock-s(C)...unlock(C)
 ```
 
 # 四、隔离级别
@@ -318,7 +318,7 @@ InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回
 读取快照中的数据，可以减少加锁所带来的开销。
 
 ```sql
-select * from table ....;
+select * from table ...;
 ```
 
 ### 2. 当前读
@@ -428,15 +428,13 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
 
 以上学生课程关系中，{Sno, Cname} 为键码，有如下函数依赖：
 
-- Sno, Cname -> Sname, Sdept, Mname
 - Sno -> Sname, Sdept
 - Sdept -> Mname
-- Sno -> Mname
 - Sno, Cname-> Grade
 
 Grade 完全函数依赖于键码，它没有任何冗余数据，每个学生的每门课都有特定的成绩。
 
-Sname, Sdept 和 Mname 都函数依赖于 Sno，而部分依赖于键码。当一个学生选修了多门课时，这些数据就会出现多次，造成大量冗余数据。
+Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门课时，这些数据就会出现多次，造成大量冗余数据。
 
 <font size=4> **分解后** </font><br>
 

notes/正则表达式.md

@@ -328,7 +328,7 @@ aBCd
 
 # 九、前后查找
 
-前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用  **?=**  来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义。
+前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用  **?=**  来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义（注: javaScript 不支持向后匹配, java 对其支持也不完善）。
 
 **应用** 
 

notes/计算机操作系统.md

@@ -1,5 +1,5 @@
 <!-- GFM-TOC -->
-* [一、 概述](#一-概述)
+* [一、概述](#一概述)
     * [操作系统基本特征](#操作系统基本特征)
     * [操作系统基本功能](#操作系统基本功能)
     * [系统调用](#系统调用)
@@ -31,13 +31,13 @@
 <!-- GFM-TOC -->
 
 
-# 一、 概述
+# 一、概述
 
 ## 操作系统基本特征
 
 ### 1. 并发
 
-并发性是指宏观上在一段时间内能同时运行多个程序，而并行性则指同一时刻能运行多个指令。
+并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
 
 并行需要硬件支持，如多流水线或者多处理器。
 
@@ -45,7 +45,7 @@
 
 ### 2. 共享
 
-共享是指系统中的资源可以供多个并发进程共同使用。
+共享是指系统中的资源可以被多个并发进程共同使用。
 
 有两种共享方式：互斥共享和同时共享。
 
@@ -69,15 +69,17 @@
 
 ### 2. 内存管理
 
-内存分配、地址映射、内存保护与共享和内存扩充等功能。
+内存分配、地址映射、内存保护与共享、内存扩充等。
 
 ### 3. 文件管理
 
-文件存储空间的管理、目录管理及文件读写管理和保护等。
+文件存储空间的管理、目录管理、文件读写管理和保护等。
 
 ### 4. 设备管理
 
-完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率，主要包括缓冲管理、设备分配、设备处理和虛拟设备等功能。
+完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率。
+
+主要包括缓冲管理、设备分配、设备处理、虛拟设备等。
 
 ## 系统调用
 

notes/计算机网络.md

@@ -61,19 +61,19 @@
 
 网络把主机连接起来，而互联网是把多种不同的网络连接起来，因此互联网是网络的网络。
 
-<div align="center"> <img src="../pics//network-of-networks.gif"/> </div><br>
+<div align="center"> <img src="../pics//network-of-networks.gif" width=""/> </div><br>
 
 ## ISP
 
 互联网服务提供商 ISP 可以从互联网管理机构获得许多 IP 地址，同时拥有通信线路以及路由器等联网设备，个人或机构向 ISP 缴纳一定的费用就可以接入互联网。
 
-<div align="center"> <img src="../pics//46cec213-3048-4a80-aded-fdd577542801.jpg"/> </div><br>
+<div align="center"> <img src="../pics//46cec213-3048-4a80-aded-fdd577542801.jpg" width=""/> </div><br>
 
-目前的互联网是一种多层次 ISP 结构，ISP 根据覆盖面积的大小分为主干 ISP、地区 ISP 和本地 ISP。
+目前的互联网是一种多层次 ISP 结构，ISP 根据覆盖面积的大小分为第一层 ISP、区域 ISP 和接入 ISP。
 
 互联网交换点 IXP 允许两个 ISP 直接相连而不用经过第三个 ISP。
 
-<div align="center"> <img src="../pics//Technology-ComputerNetworking-Internet-ISPs.png"/> </div><br>
+<div align="center"> <img src="../pics//Technology-ComputerNetworking-Internet-ISPs.png" width=""/> </div><br>
 
 
 ## 主机之间的通信方式
@@ -82,11 +82,11 @@
 
 2. 对等（P2P）：不区分客户和服务器。
 
-<div align="center"> <img src="../pics//2ad244f5-939c-49fa-9385-69bc688677ab.jpg"/> </div><br>
+<div align="center"> <img src="../pics//2ad244f5-939c-49fa-9385-69bc688677ab.jpg" width=""/> </div><br>
 
 ## 电路交换与分组交换
 
-<div align="center"> <img src="../pics//5e8d3c04-d93b-48a7-875e-41ababed00e0.jpg"/> </div><br>
+<div align="center"> <img src="../pics//5e8d3c04-d93b-48a7-875e-41ababed00e0.jpg" width=""/> </div><br>
 
 （以上分别为：电路交换、报文交换以及分组交换）
 
@@ -140,14 +140,7 @@
 
 <div align="center"> <img src="../pics//426df589-6f97-4622-b74d-4a81fcb1da8e.png" width="800"/> </div><br>
 
-### 1. 七层协议
+### 1. 五层协议
-
-如图 a 所示，其中表示层和会话层用途如下：
-
-1. 表示层：信息的语法、语义以及它们的关联，如加密解密、转换翻译、压缩解压缩；
-2. 会话层：不同机器上的用户之间建立及管理会话。
-
-### 2. 五层协议
 
 1. 应用层：为特定应用程序提供数据传输服务，例如 HTTP、DNS 等。数据单位为报文。
 
@@ -159,6 +152,15 @@
 
 5. 物理层：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
 
+### 2. 七层协议
+
+其中表示层和会话层用途如下：
+
+1. 表示层：数据压缩、加密以及数据描述。这使得应用程序不必担心在各台主机中表示/存储的内部格式不同的问题。
+2. 会话层：建立及管理会话。
+
+五层协议没有表示层和会话层，而是将这些功能留给应用程序开发者处理。
+
 ### 3. 数据在各层之间的传递过程
 
 在向下的过程中，需要添加下层协议所需要的首部或者尾部，而在向上的过程中不断拆开首部和尾部。

notes/设计模式.md

@@ -233,7 +233,7 @@ public class Client {
 ```java
 public abstract class Factory {
     abstract public Product factoryMethod();
-    public void doSomethind() {
+    public void doSomething() {
         Product product = factoryMethod();
         // do something with the product
     }