diff --git "a/01.\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271/\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271.md" "b/01.\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271/\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271.md"
index e45bdd2..a40bccf 100644
--- "a/01.\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271/\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271.md"
+++ "b/01.\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271/\345\271\266\345\217\221\347\274\226\347\250\213\347\232\204\344\274\230\347\274\272\347\202\271.md"
@@ -1,4 +1,4 @@
-一直以来并发编程对于刚入行的小白来说总是觉得高深莫测，于是乎，就诞生了想写点东西记录下，以提升理解和堆并发编程的认知。为什么需要用的并发？凡事总有好坏两面，之间的trade-off是什么，也就是说并发编程具有哪些缺点？以及在进行并发编程时应该了解和掌握的概念是什么？这篇文章主要以这三个问题来谈一谈。
+一直以来并发编程对于刚入行的小白来说总是觉得高深莫测，于是乎，就诞生了想写点东西记录下，以提升理解和对并发编程的认知。为什么需要用的并发？凡事总有好坏两面，之间的trade-off是什么，也就是说并发编程具有哪些缺点？以及在进行并发编程时应该了解和掌握的概念是什么？这篇文章主要以这三个问题来谈一谈。
 # 1. 为什么要用到并发 #
 一直以来，硬件的发展极其迅速，也有一个很著名的"摩尔定律"，可能会奇怪明明讨论的是并发编程为什么会扯到了硬件的发展，这其中的关系应该是多核CPU的发展为并发编程提供的硬件基础。摩尔定律并不是一种自然法则或者是物理定律，它只是基于认为观测数据后，对未来的一种预测。按照所预测的速度，我们的计算能力会按照指数级别的速度增长，不久以后会拥有超强的计算能力，正是在畅想未来的时候，2004年，Intel宣布4GHz芯片的计划推迟到2005年，然后在2004年秋季，Intel宣布彻底取消4GHz的计划，也就是说摩尔定律的有效性超过了半个世纪戛然而止。但是，聪明的硬件工程师并没有停止研发的脚步，他们为了进一步提升计算速度，而不是再追求单独的计算单元，而是将多个计算单元整合到了一起，也就是形成了多核CPU。短短十几年的时间，家用型CPU,比如Intel i7就可以达到4核心甚至8核心。而专业服务器则通常可以达到几个独立的CPU，每一个CPU甚至拥有多达8个以上的内核。因此，摩尔定律似乎在CPU核心扩展上继续得到体验。因此，多核的CPU的背景下，催生了并发编程的趋势，通过**并发编程的形式可以将多核CPU的计算能力发挥到极致，性能得到提升**。
 
diff --git "a/02.\347\272\277\347\250\213\347\232\204\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234/\347\272\277\347\250\213\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234.md" "b/02.\347\272\277\347\250\213\347\232\204\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234/\347\272\277\347\250\213\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234.md"
index 7458d85..3758274 100644
--- "a/02.\347\272\277\347\250\213\347\232\204\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234/\347\272\277\347\250\213\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234.md"
+++ "b/02.\347\272\277\347\250\213\347\232\204\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234/\347\272\277\347\250\213\347\212\266\346\200\201\350\275\254\346\215\242\344\273\245\345\217\212\345\237\272\346\234\254\346\223\215\344\275\234.md"
@@ -46,13 +46,13 @@
 		
 		}
 		
-三种新建线程的方式具体看以上注释，需要主要的是：
+三种新建线程的方式具体看以上注释，需要注意的是：
 
 
 - 由于java不能多继承可以实现多个接口，因此，在创建线程的时候尽量多考虑采用实现接口的形式；
 - 实现callable接口，提交给ExecutorService返回的是异步执行的结果，另外，通常也可以利用FutureTask(Callable<V> callable)将callable进行包装然后FeatureTask提交给ExecutorsService。如图，
 
-![FutureTask接口实现关系](https://github.com/CL0610/Java-concurrency/blob/master/2.%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2%E4%BB%A5%E5%8F%8A%E5%9F%BA%E6%9C%AC%E6%93%8D%E4%BD%9C/futureTask%E6%8E%A5%E5%8F%A3%E5%AE%9E%E7%8E%B0%E5%85%B3%E7%B3%BB.png)
+![FutureTask接口实现关系](futureTask%E6%8E%A5%E5%8F%A3%E5%AE%9E%E7%8E%B0%E5%85%B3%E7%B3%BB.png)
 
 
 另外由于FeatureTask也实现了Runable接口也可以利用上面第二种方式（实现Runable接口）来新建线程；
@@ -61,7 +61,7 @@
 # 2. 线程状态转换 #
 
 
-![线程状态转换图](https://github.com/CL0610/Java-concurrency/blob/master/2.%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2%E4%BB%A5%E5%8F%8A%E5%9F%BA%E6%9C%AC%E6%93%8D%E4%BD%9C/%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2%E5%85%B3%E7%B3%BB.png)
+![线程状态转换图](%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2%E5%85%B3%E7%B3%BB.png)
 
 
 
@@ -71,7 +71,7 @@
 
 用一个表格将上面六种状态进行一个总结归纳。
 
-![JAVA线程的状态](https://github.com/CL0610/Java-concurrency/blob/master/2.%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2%E4%BB%A5%E5%8F%8A%E5%9F%BA%E6%9C%AC%E6%93%8D%E4%BD%9C/%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81.png)
+![JAVA线程的状态](%E7%BA%BF%E7%A8%8B%E7%8A%B6%E6%80%81.png)
 
 
 # 3. 线程状态的基本操作 #
@@ -83,7 +83,7 @@
 isInterrupted（）来感知其他线程对其自身的中断操作，从而做出响应。另外，同样可以调用Thread的静态方法
 interrupted（）对当前线程进行中断操作，该方法会清除中断标志位。**需要注意的是，当抛出InterruptedException时候，会清除中断标志位，也就是说在调用isInterrupted会返回false。**
 
-![线程中断的方法](https://github.com/CL0610/Java-concurrency/blob/master/2.%E7%BA%BF%E7%A8%8B%E7%9A%84%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2%E4%BB%A5%E5%8F%8A%E5%9F%BA%E6%9C%AC%E6%93%8D%E4%BD%9C/%E4%B8%AD%E6%96%AD%E7%BA%BF%E7%A8%8B%E6%96%B9%E6%B3%95.png)
+![线程中断的方法](%E4%B8%AD%E6%96%AD%E7%BA%BF%E7%A8%8B%E6%96%B9%E6%B3%95.png)
 
 
 
@@ -200,7 +200,7 @@ public static native void sleep(long millis)方法显然是Thread的静态方法
 
 
 ## 3.4 yield ##
-public static native void yield();这是一个静态方法，一旦执行，它会是当前线程让出CPU，但是，需要注意的是，让出的CPU并不是代表当前线程不再运行了，如果在下一次竞争中，又获得了CPU时间片当前线程依然会继续运行。另外，让出的时间片只会分配**给当前线程相同优先级**的线程。什么是线程优先级了？下面就来具体聊一聊。
+public static native void yield();这是一个静态方法，一旦执行，它会使当前线程让出CPU，但是，需要注意的是，让出的CPU并不是代表当前线程不再运行了，如果在下一次竞争中，又获得了CPU时间片当前线程依然会继续运行。另外，让出的时间片只会分配**给当前线程相同优先级**的线程。什么是线程优先级了？下面就来具体聊一聊。
 
 现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当前时间片用完后就会发生线程调度，并等待这下次分配。线程分配到的时间多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要或多或少分配一些处理器资源的线程属性。
 
diff --git a/README.md b/README.md
index bcd95f6..9f5087f 100644
--- a/README.md
+++ b/README.md
@@ -151,4 +151,4 @@
 
 [知识图谱原图链接，如果有用，可克隆给自己使用](https://www.processon.com/view/5ab5a979e4b0a248b0e026b3?fromnew=1)
 
-![JAVA并发知识图谱.png](https://github.com/CL0610/Java-concurrency/blob/master/Java并发知识图谱.png)
+![JAVA并发知识图谱.png](Java并发知识图谱.png)
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..d98a959
--- /dev/null
+++ b/index.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Document</title>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    window.$docsify = {
+      loadSidebar: true,
+      subMaxLevel: 2,
+      alias: {
+      '/_sidebar.md': '/sidebar.md'
+      },
+      name: 'Java-concurrency',
+      repo: ''
+    }
+  </script>
+  <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
+</body>
+</html>
diff --git a/sidebar.md b/sidebar.md
new file mode 100644
index 0000000..98ddac3
--- /dev/null
+++ b/sidebar.md
@@ -0,0 +1,28 @@
+* [首页](/)
+* [1.并发编程的优缺点](01.并发编程的优缺点/并发编程的优缺点.md)
+* [2.线程的状态转换以及基本操作](02.线程的状态转换以及基本操作/线程状态转换以及基本操作.md)
+* [3.java内存模型以及happens-before规则](03.java内存模型以及happens-before规则/Java内存模型以及happens-before.md)
+* [4.彻底理解synchronized](04.彻底理解synchronized/java关键字---synchronized.md)
+* [5.彻底理解volatile](05.彻底理解volatile/java关键字---volatile.md)
+* [6.你以为你真的了解final吗？](06.你以为你真的了解final吗？/java关键字--final.md)
+* [7.三大性质总结：原子性、可见性以及有序性](07.三大性质总结：原子性、可见性以及有序性/三大性质总结：原子性、可见性以及有序性.md)
+* [8.初识Lock与AbstractQueuedSynchronizer(AQS)](08.初识Lock与AbstractQueuedSynchronizer(AQS)/初识Lock与AbstractQueuedSynchronizer(AQS).md)
+* [9.深入理解AbstractQueuedSynchronizer(AQS)](09.深入理解AbstractQueuedSynchronizer(AQS)/深入理解AbstractQueuedSynchronizer(AQS).md)
+* [10.彻底理解ReentrantLock](10.彻底理解ReentrantLock/彻底理解ReentrantLock.md)
+* [11.深入理解读写锁ReentrantReadWriteLock](11.深入理解读写锁ReentrantReadWriteLock/深入理解读写锁ReentrantReadWriteLock.md)
+* [12.详解Condition的await和signal等待通知机制](12.详解Condition的await和signal等待通知机制/详解Condition的await和signal等待通知机制.md)
+* [13.LockSupport工具](13.LockSupport工具/LockSupport工具.md)
+* [14.并发容器之ConcurrentHashMapJDK1.8版本](14.并发容器之ConcurrentHashMap(JDK%201.8版本)/并发容器之ConcurrentHashMap(JDK%201.8版本).md)
+* [15.并发容器之ConcurrentLinkedQueue](15.并发容器之ConcurrentLinkedQueue/并发容器之ConcurrentLinkedQueue.md)
+* [16.并发容器之CopyOnWriteArrayList](16.并发容器之CopyOnWriteArrayList/并发容器之CopyOnWriteArrayList.md)
+* [17.并发容器之ThreadLocal](17.并发容器之ThreadLocal/并发容器之ThreadLocal.md)
+* [18.一篇文章，从源码深入详解ThreadLocal内存泄漏问题](18.一篇文章，从源码深入详解ThreadLocal内存泄漏问题/一篇文章，从源码深入详解ThreadLocal内存泄漏问题.md)
+* [19.并发容器之BlockingQueue](19.并发容器之BlockingQueue/并发容器之BlockingQueue.md)
+* [20.并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解](20.并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解/并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解.md)
+* [21.线程池ThreadPoolExecutor实现原理](21.线程池ThreadPoolExecutor实现原理/线程池ThreadPoolExecutor实现原理.md)
+* [22.线程池之ScheduledThreadPoolExecutor](22.线程池之ScheduledThreadPoolExecutor/线程池之ScheduledThreadPoolExecutor.md)
+* [23.FutureTask基本操作总结](23.FutureTask基本操作总结/FutureTask基本操作总结.md)
+* [24.Java中atomic包中的原子操作类总结](24.Java中atomic包中的原子操作类总结/Java中atomic包中的原子操作类总结.md)
+* [25.大白话说java并发工具类-CountDownLatch，CyclicBarrier](25.大白话说java并发工具类-CountDownLatch，CyclicBarrier/大白话说java并发工具类-CountDownLatch，CyclicBarrier.md)
+* [26.大白话说java并发工具类-Semaphore，Exchanger](26.大白话说java并发工具类-Semaphore，Exchanger/大白话说java并发工具类-Semaphore，Exchanger.md)
+* [27.一篇文章，让你彻底弄懂生产者--消费者问题](27.一篇文章，让你彻底弄懂生产者--消费者问题/一篇文章，让你彻底弄懂生产者--消费者问题.md)