diff --git "a/Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" "b/Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md"
index 209c1fcf63359df1049a8ca738a2e0322e97100b..70164c135e4afe03064a8c06222711f9f610950b 100644
--- "a/Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md"
+++ "b/Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md"
@@ -5,10 +5,10 @@
 - [二 ConcurrentHashMap](#二-concurrenthashmap)
 - [三 CopyOnWriteArrayList](#三-copyonwritearraylist)
   - [3.1 CopyOnWriteArrayList 简介](#31-copyonwritearraylist-简介)
-  - [3.2 CopyOnWriteArravList 是如何做到的？](#32-copyonwritearravlist-是如何做到的？)
-  - [3.3 CopyOnWriteArravList 读取和写入源码简单分析](#33-copyonwritearravlist-读取和写入源码简单分析)
-    - [3.3.1 CopyOnWriteArravList 读取操作的实现](#331-copyonwritearravlist-读取操作的实现)
-    - [3.3.2 CopyOnWriteArravList 写入操作的实现](#332-copyonwritearravlist-写入操作的实现)
+  - [3.2 CopyOnWriteArrayList 是如何做到的？](#32-copyonwritearraylist-是如何做到的？)
+  - [3.3 CopyOnWriteArrayList 读取和写入源码简单分析](#33-copyonwritearraylist-读取和写入源码简单分析)
+    - [3.3.1 CopyOnWriteArrayList 读取操作的实现](#331-copyonwritearraylist-读取操作的实现)
+    - [3.3.2 CopyOnWriteArrayList 写入操作的实现](#332-copyonwritearraylist-写入操作的实现)
 - [四 ConcurrentLinkedQueue](#四-concurrentlinkedqueue)
 - [五 BlockingQueue](#五-blockingqueue)
   - [5.1 BlockingQueue 简单介绍](#51-blockingqueue-简单介绍)
@@ -56,17 +56,17 @@ implements List<E>, RandomAccess, Cloneable, Serializable
 
 在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，因此对于每次读取都进行加锁其实是一种资源浪费。我们应该允许多个线程同时访问List的内部数据，毕竟读取操作是安全的。
 
-这和我们之前在多线程章节讲过 `ReentrantReadWriteLock` 读写锁的思想非常类似，也就是读读共享、写写互斥、读写互斥、写读互斥。JDK中提供了 `CopyOnWriteArravList` 类比相比于在读写锁的思想又更进一步。为了将读取的性能发挥到极致，`CopyOnWriteArravList` 读取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作。只有写入和写入之间需要进行同步等待。这样一来，读操作的性能就会大幅度提升。**那它是怎么做的呢？**
+这和我们之前在多线程章节讲过 `ReentrantReadWriteLock` 读写锁的思想非常类似，也就是读读共享、写写互斥、读写互斥、写读互斥。JDK中提供了 `CopyOnWriteArrayList` 类比相比于在读写锁的思想又更进一步。为了将读取的性能发挥到极致，`CopyOnWriteArrayList` 读取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作。只有写入和写入之间需要进行同步等待。这样一来，读操作的性能就会大幅度提升。**那它是怎么做的呢？**
 
-### 3.2 CopyOnWriteArravList 是如何做到的？
+### 3.2 CopyOnWriteArrayList 是如何做到的？
 
- `CopyOnWriteArravList` 类的所有可变操作（add，set等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，我并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。
+ `CopyOnWriteArrayList` 类的所有可变操作（add，set等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，我并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。
 
-从 `CopyOnWriteArravList` 的名字就能看出`CopyOnWriteArravList` 是满足`CopyOnWrite` 的ArrayList，所谓`CopyOnWrite` 也就是说：在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了。
+从 `CopyOnWriteArrayList` 的名字就能看出`CopyOnWriteArrayList` 是满足`CopyOnWrite` 的ArrayList，所谓`CopyOnWrite` 也就是说：在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了。
 
-### 3.3 CopyOnWriteArravList 读取和写入源码简单分析
+### 3.3 CopyOnWriteArrayList 读取和写入源码简单分析
 
-#### 3.3.1 CopyOnWriteArravList 读取操作的实现
+#### 3.3.1 CopyOnWriteArrayList 读取操作的实现
 
 读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。
 
@@ -86,9 +86,9 @@ implements List<E>, RandomAccess, Cloneable, Serializable
 
 ```
 
-#### 3.3.2 CopyOnWriteArravList 写入操作的实现
+#### 3.3.2 CopyOnWriteArrayList 写入操作的实现
 
-CopyOnWriteArravList 写入操作 add() 方法在添加集合的时候加了锁，保证了同步，避免了多线程写的时候会 copy 出多个副本出来。
+CopyOnWriteArrayList 写入操作 add() 方法在添加集合的时候加了锁，保证了同步，避免了多线程写的时候会 copy 出多个副本出来。
 
 ```java
     /**
@@ -202,7 +202,7 @@ PriorityBlockingQueue 并发控制采用的是 **ReentrantLock**，队列为无
 
 ![2级索引跳表](http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-12-9/93666217.jpg)
 
-最低层的链表维护了跳表内所有的元素，每上面一层链表都是下面一层的了集。
+最低层的链表维护了跳表内所有的元素，每上面一层链表都是下面一层的子集。
 
 跳表内的所有链表的元素都是排序的。查找时，可以从顶级链表开始找。一旦发现被查找的元素大于当前链表中的取值，就会转入下一层链表继续找。这也就是说在查找过程中，搜索是跳跃式的。如上图所示，在跳表中查找元素18。