diff --git "a/000 - 1 Computer Basics/01 \346\223\215\344\275\234\347\263\273\347\273\237.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/01 \346\223\215\344\275\234\347\263\273\347\273\237.md"
similarity index 100%
rename from "000 - 1 Computer Basics/01 \346\223\215\344\275\234\347\263\273\347\273\237.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/01 \346\223\215\344\275\234\347\263\273\347\273\237.md"
diff --git "a/000 - 1 Computer Basics/02 \347\274\226\350\257\221\345\216\237\347\220\206.txt" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/02 \347\274\226\350\257\221\345\216\237\347\220\206.txt"
similarity index 100%
rename from "000 - 1 Computer Basics/02 \347\274\226\350\257\221\345\216\237\347\220\206.txt"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/02 \347\274\226\350\257\221\345\216\237\347\220\206.txt"
diff --git "a/000 - 1 Computer Basics/03 \350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/03 \350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
similarity index 99%
rename from "000 - 1 Computer Basics/03 \350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/03 \350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
index b37ef63b..bb6a0727 100644
--- "a/000 - 1 Computer Basics/03 \350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"	
+++ "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/03 \350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"	
@@ -1,486 +1,486 @@
-
-## OSI（开放系统互联参考模型）标准模型
-**物理层**
-负责为数据端设备透明地传输原始比特流，并且定义了数据终端设备和数据通信设备的物理和逻辑链接方法。传输单位是比特。
-协议：RJ45、CLOCK、IEEE802.3
-设备：（中继器，集线器）
-**数据链路层**
-将网络层传下来的IP数据报组装成帧，并检测和矫正物理层产生的传输差错，使得链路对网络层显示一条无差错、可靠的数据传输线路。功能可以概括为成帧，差错控制、流量控制和传输管理
-协议有：HDLC(高级数据链路控制协议),PPP,STP,SDLC,CSMA(载波监听多路访问)
-设备:（网桥，交换机）
-**网络层**
-负载在网络层上将数据封装成数据报，将数据报从源端传到目的端，同时进行路由选择，为分组交换网上的不同主机提供通信服务。关键问题是对分组进行选择，并实现流量控制、拥塞控制、差错控制和网际互联等功能。传输单位数据报。
-协议: IP,ICMP(因特网控制报文协议),IGMP(因特网组管理协议),ARP,RARP,OSPF(开放最短路径优先),IPX
-设备:路由器
-**传输层**
-负责主机中两个进程之间的通信，为端到端连接提供可靠的传输服务。为端到端连接提供流量控制、差错控制、服务质量、数据传输管理等服务。
-协议：TCP,UDP
-**会话层**
-会话层允许不同主机上各个进程之间的**会话**，会话层利用传输层提供的端到端的服务，向表示层提供它的增值服务。这种服务主要是为表示层实体或用户进程**建立连接**并在连接上提供**有序**地传输数据。
-协议：SQL、RPC(远程调用协议)
-**表示层**
-用于处理两个通信系统中交换信息的表示方式。如数据压缩，加密和解密等。
-协议：JPEG、MPEG、ASII
-**应用层**
-是TCP/IP的最高层，它是直接为应用进程服务的一层。当不同的应用进程数据通信或数据交换时，就去调用应用层的**不同协议实体**，让这些实体去调用TCP或者UDP层服务来进行网络传输。
-协议：FTP(21) TELNET(23) SMTP(25) DNS(53) TFTP(69) HTTP(80) SNMP(161),DHCP(动态主机配置协议)
-
-## TCP/IP 分层
-1）**网络接口层（接收和发送数据报）**
-负责将数据报发送到**网络介质**上，以及从网络上接收TCP/IP数据报，相当于OSI的物理层和数据层。
-2）**网际层（数据报封装和路由寻址功能）**
-主要负责寻址和对数据报的封装以及重要的路由选择功能。
-3)**传输层**
-**负责在应用进程之间的“端到端”的通信**，即从某个应用进程传输到另一个应用进程。
-4)应用层
-是TCP/IP的最高层，它是直接为应用进程服务的一层。当不同的应用进程数据通信或数据交换时，就去调用应用层的**不同协议实体**，让这些实体去调用TCP或者UDP层服务来进行网络传输。
-
-## 五层体系结构模型
-物理层，数据链路层，网络层，传输层，应用层
-
-## IP地址分类
-A类地址：以0开头， 第一个字节范围：1~126（1.0.0.0 - 126.255.255.255）；
-B类地址：以10开头， 第一个字节范围：128~191（128.0.0.0 - 191.255.255.255）；
-C类地址：以110开头， 第一个字节范围：192~223（192.0.0.0 - 223.255.255.255）；
-D类地址：1110开头， 224~239
-E类地址：11110开头， 240~255
-主机号全为0表示本网络本身
-主机号全为1表示本网络广播地址
-127.0.0.0 环路自检地址，表示任意主机本身
-32个0 表示本网络的本主机
-32个1表示整个TCP/IP网络的广播地址,等效本网络的广播地址。
-专用地址：
-10.0.0.0—10.255.255.255， 172.16.0.0—172.31.255.255， 192.168.0.0—192.168.255.255。（Internet上保留地址用于内部）
-IP地址与子网掩码相与得到网络号
-
-## ARP是地址解析协议，简单语言解释一下工作原理
-每个主机都存有一个ARP高速缓存，存放本局域网上各主机和路由器的IP地址到MAC地址的映射表，称为ARP表。使用ARP协议动态维护此表。
-ARP工作在网络层中，其工作原理是：当主机A欲向本局域网上的某个主机B发送IP数据报时，就先在其ARP高速缓存中查看有无主机B的IP地址。如果有可以查出其对应的硬件地址，再将此硬件地址写入**MAC帧**，然后通过局域网将该MAC帧发往此硬件地址。如果没有，就通过使用目的MAC地址为本网络的广播地址即32个1的帧来封装并广播ARP请求分组，可以使同一个局域网里的所有主机收到ARP请求。当主机B收到该ARP请求后，就会向主机A发出响应ARP分组，分组中包含主机B的IP与MAC地址的映射关系，主机A在收到后将此映射写入ARP缓存中，然后按查询到的硬件地址发送MAC帧。
-**ARP是解决同一个局域网上主机与路由器的IP地址和硬件地址的映射问题**。如果所要找的主机和源主机不在同一个局域网上，那么通过ARP协议找到一个位于本局域网上的某个路由器硬件地址，然后把分组发送给这个路由器，让这个路由器把分组转发给下一个网络。
-
-## 描述RARP协议
-RARP是逆地址解析协议，作用是完成硬件地址到IP地址的映射.(请求是广播，应答是单播)
-1)网络上的每台设备都会有一个独一无二的硬件地址，通常是由设备厂商分配的MAC地址。主机从网卡上读取MAC地址，然后在网络上发送一个RARP请求的广播数据包，请求的RARP服务器分配一个IP地址。
-2)本地网段上的RARP服务器收到此请求后，检查其RARP列表，查找该MAC地址对应的IP地址。
-3)如果存在，RARP服务器就给源主机发送一个响应数据包并将此IP地址提供给对方主机使用。
-4)如果不存在，RARP服务器对此不做任何的响应。
-5)源主机收到从RARP服务器的响应信息，就利用得到的IP地址进行通讯；如果一直没有收到RARP服务器的响应信息，表示初始化失败
-
-
-## 了解交换机、路由器、网关的概念，并知道各自的用途
-两者简介：
-**路由器**是具有多个输入输出端口的专用计算机，**其任务是连接不同的网络并完成路由转发**。当源主机向目标主机发送数据报时，路由器先检查源主机与目标主机是否连接在一个网络上。如果源主机和目标主机在一个网络上则直接交付而无需通过路由器。但如果源主机和目标主机不在同一个网络上，则路由器转发表指出路由将数据报转发给下一个路由器，即间接交付。路由器隔离了广播域。
-
-**交换机**：是多个端口的网桥，工作在数据链路上，**将两个或多个以太网连接起来成为更大的以太网。它能将网络分成小的冲突域，为每个工作站提供更高的带宽**。其原理是，检测从以太端口来的数据帧的源和目的地的MAC地址，然后与系统内部的动态查找表进行比较。若数据帧的MAC地址不在查找表中，则将该地址加入查找表中，并将数据帧发送给相应的端口。
-
-区别：
-**路由器**：工作在网络层，是能够连接不同的广域网形成更大的广域网。连接的是异构网络。根据IP地址转发。
-**交换机**：工作在数据链路层，是将以太网连接形成更大的以太网，同一个网络。根据MAC地址进行转发。
-
-**网关(Gateway)**又称网间连接器、协议转换器。网关在网络层以上实现网络互连，是最复杂的网络互连设备，**仅用于两个高层协议不同的网络互连**。网关既可以用于广域网互连，也可以用于局域网互连。 网关是一种充当转换重任的计算机系统或设备。使用在不同的通信协议、数据格式或语言，甚至体系结构完全不同的两种系统之间，网关是一个翻译器。
-
-## OSI 和TCP/IP的区别
-1. OSI精确定义了服务、协议和接口，符合面向对象程序设计思想。而TCP/IP在这些概念上没有明确区分。
-2. OSI在产生协议之前没有偏向任何特定的协议，通用性良好，但设计没有太多经验不知道将哪些功能放到哪一层。TCP/IP,首先出现协议，模型实际上是对已有协议的描述。因此不会出现协议不能匹配的模式。
-3. TCP/IP考虑了异构网的互联问题，而OSI只考虑用一种标准的公用数据网将各种不同系统互连。
-4. OSI在网络层支持无连接和面向连接的通信，但在传输层仅有面向连接通信。而TCP/IP则相反，在网际层仅有无连接服务，在传输层支持无连接和面向连接两种模式。
-
-## TCP与UDP的区别
-1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接
-2、TCP提供可靠全双功的通信服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP则是不可靠信道，尽最大努力交付，即不保证可靠交付
-3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的．
-4.TCP具有拥塞控制，UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
-5、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信
-6、TCP首部开销20字节;UDP的首部开销小，只有8个字节.
-
-### TCP应用场景
-：效率要求相对低，但对准确性要求相对高的场景。因为传输中需要对数据确认、重发、排序等操作，相比之下效率没有UDP高。举几个例子：文件传输（准确高要求高、但是速度可以相对慢）、接受邮件、远程登录。
-
-### UDP应用场景
-：效率要求相对高，对准确性要求相对低的场景。举几个例子：QQ聊天、在线视频、网络语音电话（即时通讯，速度要求高，但是出现偶尔断续不是太大问题，并且此处完全不可以使用重发机制）、广播通信（广播、多播）。
-
-## TCP对应的协议和UDP对应的协议
-**TCP对应的协议**：
-（1） FTP(21)：定义了文件传输协议，使用21端口。常说某某计算机开了FTP服务便是启动了文件传输服务。下载文件，上传主页，都要用到FTP服务。
-（2） Telnet(23)：(远程登陆协议)它是一种用于远程登陆的端口，用户可以以自己的身份远程连接到计算机上，通过这种端口可以提供一种基于DOS模式下的通信服务。如以前的BBS是-纯字符界面的，支持BBS的服务器将23端口打开，对外提供服务。
-（3） SMTP(25)：定义了简单邮件传送协议，现在很多邮件服务器都用的是这个协议，用于发送邮件。如常见的免费邮件服务中用的就是这个邮件服务端口，所以在电子邮件设置-中常看到有这么SMTP端口设置这个栏，服务器开放的是25号端口。
-（4） POP3(110)：它是和SMTP对应，POP3用于接收邮件。通常情况下，POP3协议所用的是110端口。也是说，只要你有相应的使用POP3协议的程序（例如Fo-xmail或Outlook），就可以不以Web方式登陆进邮箱界面，直接用邮件程序就可以收到邮件（如是163邮箱就没有必要先进入网易网站，再进入自己的邮-箱来收信）。
-（5）HTTP(80)协议：是从Web服务器传输超文本到本地浏览器的传送协议。
-**UDP对应的协议**：
-（1） DNS(53)：用于域名解析服务，将域名地址转换为IP地址。DNS用的是53号端口。
-(2) RIP:路由信息协议，端口520
-（2） SNMP(161)：简单网络管理协议，使用161号端口，是用来管理网络设备的。由于网络设备很多，无连接的服务就体现出其优势。
-（3） TFTP(69)(Trival File Transfer Protocal)，简单文件传输协议，该协议在熟知端口69上使用UDP服务。
-
-http://www.jianshu.com/p/8be9b3204864
-http://www.jianshu.com/p/eab86c0d1612
-## 常见的路由选择协议，以及它们的区别
-常见的路由选择协议有：RIP协议、OSPF协议。
-RIP协议（路由信息协议）：底层是贝尔曼福特算法，**基于距离向量的路由选择协议**，它选择路由的度量标准（metric)是**跳数**，最大跳数是15跳，如果大于15跳，它就会丢弃数据包。仅和相邻路由器交换当前路由器所知道的全部信息。是应用层协议,使用UDP传输数据,端口520
-OSPF协议（开放最短路由优先）：底层是迪杰斯特拉算法，**是链路状态路由选择协议**，它选择路由的度量标准是**带宽**，延迟。向本自治系统中所有路由器发送与本路由器相邻的所有路由器的链路状态，但这只是路由器知道的部分信息。网络层协议,直接IP数据报传输．
-
-## TCP报文首部
-源端口和目的端口，各占2个字节，分别写入源端口和目的端口；
-序号，占4个字节，TCP连接中传送的字节流中的每个字节都按顺序编号。例如，一段报文的序号字段值是 301 ，而携带的数据共有100字段，显然下一个报文段（如果还有的话）的数据序号应该从401开始；
-确认号，占4个字节，是期望收到对方下一个报文的第一个数据字节的序号。例如，B收到了A发送过来的报文，其序列号字段是501，而数据长度是200字节，这表明B正确的收到了A发送的到序号700为止的数据。因此，B期望收到A的下一个数据序号是701，于是B在发送给A的确认报文段中把确认号置为701；
-数据偏移，占4位，它指出TCP报文的数据距离TCP报文段的起始处有多远；
-保留，占6位，保留今后使用，但目前应都位0；
-紧急URG，当URG=1，表明紧急指针字段有效。告诉系统此报文段中有紧急数据；
-**确认ACK**，仅当ACK=1时，确认号字段才有效。TCP规定，在连接建立后所有报文的传输都必须把ACK置1；
-推送PSH，当两个应用进程进行交互式通信时，有时在一端的应用进程希望在键入一个命令后立即就能收到对方的响应，这时候就将PSH=1；
-复位RST，当RST=1，表明TCP连接中出现严重差错，必须释放连接，然后再重新建立连接；
-**同步SYN**，在连接建立时用来同步序号。当SYN=1，ACK=0，表明是连接请求报文，若同意连接，则响应报文中应该使SYN=1，ACK=1；
-**终止FIN**，用来释放连接。当FIN=1，表明此报文的发送方的数据已经发送完毕，并且要求释放；
-窗口，占2字节，指的是通知接收方，发送本报文你需要有多大的空间来接受；
-检验和，占2字节，校验首部和数据这两部分；
-紧急指针，占2字节，指出本报文段中的紧急数据的字节数；
-选项，长度可变，定义一些其他的可选的参数。
-
-## TCP的三次握手与四次挥手过程，各个状态名称与含义，TIMEWAIT的作用
-**三次握手**
-第一次握手：客户机首先向服务器的TCP发送一个连接请求报文段，这个特殊的报文段不含应用层数据，其首部中同步位 **SYN=1**。另外，客户机会随机选择一个起始序号 **seq=x**(连接请求报文不携带数据，但要消耗一个序号)；客户端进程进入了 **SYN-SENT（同步已发送状态）状态**
-第二次握手：服务器的TCP收到连接请求报文段后，如果同意建立连接，就向客户机发回确认，并为该TCP连接分配TCP缓存和变量。在确认报文段中，**SYN=1,ACK=1**，确认号字段值为 **ack=x+1**,并且服务器随机产生起始序号 **seq=y**. 确认包同样不包含应用层数据。 服务器进程进入了 **SYN-RCVD（同步收到）状态**
-第三次握手：当客户机收到确认报文段后，还要向服务器给出确认，并且也要给该连接**分配缓存和变量**。这个报文段的确认为 **ACK=1**，序号段被设置为 **seq=x+1**,确认号字段 **ack=y+1**. 该报文段可以携带数据，如果不携带数据则不消耗序号。客户端进入 **ESTABLISHED（已建立连接）状态**
-理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。因为TCP提供全双工通信，因此双方任何时候都可以发送数据。
-
-### 为什么TCP客户端最后还要发送一次确认呢？
-  一句话，主要 **防止已经失效的连接请求报文突然又传送到了服务器，从而产生错误**。
-
-  如果使用的是两次握手建立连接，假设有这样一种场景，**客户端发送了第一个请求连接并且没有丢失，只是因为在网络结点中滞留的时间太长了，由于TCP的客户端迟迟没有收到确认报文**，以为服务器没有收到，此时重新向服务器发送这条报文，此后客户端和服务器经过两次握手完成连接，传输数据，然后关闭连接。此时此前滞留的那一次请求连接，网络通畅了到达了服务器，这个报文本该是失效的，但是，两次握手的机制将会让客户端和服务器再次建立连接，这将导致不必要的错误和资源的浪费。
-
-  如果采用的是三次握手，就算是那一次失效的报文传送过来了，服务端接受到了那条失效报文并且回复了确认报文，但是客户端不会再次发出确认。由于服务器收不到确认，就知道客户端并没有请求连接。
-
-**四次挥手**
-第一次挥手：客户机打算关闭连接，就向其TCP发送一个连接释放报文，并停止再发送数据，主动关闭TCP连接。该报文段的 **FIN=1**，**seq=u**,它等于前面已经发送过的数据的最后一个字节的序号加1。 客户端进入 **FIN-WAIT-1（终止等待1）状态**
-第二次挥手：服务器收到连接释放报文段后即发出确认，确认号是ack=u+1,序号为v,等于它前面已经发送过的数据的最后一个字节序号加1.此时客户机到服务器这个方向的连接就释放了，TCP处于半关闭状态。**ACK=1，seq=v,ack=u+1**，服务端就进入了 **CLOSE-WAIT（关闭等待）状态**
-客户端收到第二次挥手 ，客户端进入 **FIN-WAIT-2（终止等待2）状态**
-第三次挥手：若服务器已经没有要向客户机发送的数据，就通知TCP释放连接，此时发出 **FIN=1**，确认号 **ack= u+1** ,序号 **seq =w**,已经发送过的数据最后一个字节加1。确认为ACK=1. 服务器就进入了 **LAST-ACK（最后确认）状态**
-(**FIN = 1, ACK=1,seq = w, ack =u+1**)
-第四次挥手：客户机收到连接释放报文段后，必须发出确认。在确认报文段中，确认位 **ACK=1**，序号 **seq=u+1**,确认号 **ack=w+1** . 此时连接还没有释放掉，**必须经过实践等待计时器设置的时间2MSL(Max Segment Lifetime),后**，客户机才进入连接关闭状态。
-(**ACK=1,seq=u+1,ack=w+1**)
-
-### 为什么客户端最后还要等待2MSL？
-  MSL（Maximum Segment Lifetime），TCP允许不同的实现可以设置不同的MSL值。
-
-  第一，保证客户端发送的最后一个ACK报文能够到达服务器，因为这个ACK报文可能丢失，**站在服务器的角度看来，我已经发送了FIN+ACK报文请求断开了，客户端还没有给我回应，应该是我发送的请求断开报文它没有收到，于是服务器又会重新发送一次，** 而客户端就能在这个2MSL时间段内收到这个重传的报文，接着给出回应报文，并且会重启2MSL计时器。
-
-  第二，防止类似与“三次握手”中提到了的“已经失效的连接请求报文段”出现在本连接中。客户端发送完最后一个确认报文后，在这个2MSL时间中，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样新的连接中不会出现旧连接的请求报文。
-
-### 为什么建立连接是三次握手，关闭连接确是四次挥手呢？
-
-  建立连接的时候， 服务器在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。
-  而关闭连接时，服务器收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，而 **自己也未必全部数据都发送给对方了**，所以己方可以立即关闭，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送，从而导致多了一次。
-
-### 如果已经建立了连接，但是客户端突然出现故障了怎么办？
-  TCP还设有一个保活计时器，显然，客户端如果出现故障，服务器不能一直等下去，白白浪费资源。服务器每收到一次客户端的请求后都会重新复位这个计时器，时间通常是设置为2小时，若两小时还没有收到客户端的任何数据，服务器就会发送一个探测报文段，以后每隔75分钟发送一次。若一连发送10个探测报文仍然没反应，服务器就认为客户端出了故障，接着就关闭连接。
-
-https://blog.csdn.net/qzcsu/article/details/72861891
-http://www.cnblogs.com/Jessy/p/3535612.html
-
-## 为什么会采用三次握手，若采用二次握手可以吗？
-采用三次握手是为了防止失效的连接请求报文段再次传到服务器，因而产生错误。如果由于网络不稳定，虽然客户端以前发送的连接请求以到达服务方，但服务方的同意连接的应答未能到达客户端。则客户方要重新发送连接请求，若采用二次握手，服务方收到客服端重传的请求连接后，会以为是新的请求，就会发送同意连接报文，并新开进程提供服务，这样会造成服务方资源的无谓浪费。
-如果只采用一次的话，客户端不知道服务端是否已经收到自己发送的数据，则会不断地发送数据。为了保证服务端能收接受到客户端的信息并能做出正确的应答而进行前两次(第一次和第二次)握手，为了保证客户端能够接收到服务端的信息并能做出正确的应答而进行后两次(第二次和第三次)握手
-
-
-## 为什么四次挥手，主动方要等待２MSL后才关闭连接．
-一、保证TCP协议的全双工连接能够可靠关闭．
-主要为了确保对方能受到ACK信息. 如果Client直接CLOSED了，那么由于IP协议的不可靠性或者是其它网络原因，导致Server没有收到Client最后回复的ACK。那么Server就会在超时之后继续发送FIN，此时由于Client已经CLOSED了，就找不到与重发的FIN对应的连接，最后Server就会收到RST而不是ACK，Server就会以为是连接错误把问题报告给高层。所以，Client不是直接进入CLOSED，而是要保持2MSL,如果在这个时间内又收到了server的关闭请求时可以进行重传，否则说明server已经受到确认包则可以关闭.
-
-
-https://www.zhihu.com/question/36930631
-## TCP拥塞控制
-为了更好对TCP进行拥塞控制，因特网建议标准定义了以下四种算法：慢开始，拥塞避免，快重传，快恢复。
-首先在TCP要求发送端维护两个窗口：
-1） 接收窗口rwnd，接收方根据当前缓存大小锁许诺的最新窗口值。
-2) 拥塞窗口 cwnd ,发送方根据自己估算的网络拥塞程度而设置的窗口值。
-发送窗口的上限是取这两者的最小值。
-慢开始： TCP刚连接好时，先令拥塞窗口cwnd =1 ,在每次收到一个对新报文段的确认时将cwnd加1. Cwnd的大小呈指数增长。
-拥塞避免算法： 当cwnd大于等于慢开始门限ssthresh时，cwnd窗口每次加1而不是加倍。当发送方检测到**超时事件**的发生时，就将慢开始门限设置为当前cwnd的一半，同时将cwnd设置为1. 这样的目的是迅速减少主机发送到网络的分组数，使得发生拥塞的路由器有足够的时间吧队列中积压的分组处理完毕。
-快重传：当发送方连续收到三个重复的ACK报文时，直接重传对方尚未收到的报文段，而不必等待那个报文段设置的重传计时器超时。
-快恢复：当发送端收到连续三个冗余的ACK时，就执行“乘法减小”算法，把慢开始门限ssthresh减半，cwnd设置为慢开始门限减半后的数值（与慢开始不同）。
-
-## TCP滑动窗口与回退N针协议
-滑动窗口：
-发送方都维持一组连续的允许发送的帧的序号称为发送窗口。同时接收方也维持一组连续的允许接收的帧序号，称为接收窗口。发送窗口是用来对发送方进行流量控制，接收窗口是用来控制接收那些数据帧不可以接收那些帧。
-在发送端，收到一个确认帧，发送窗口就向前滑动一个帧位置，当发送窗口没有可以发送的帧时，发送方就停止发送。直到接收方发送的确认帧使发送窗口向前移动。
-在接收端，只有收到数据帧的序号落在接收窗口内才将该帧收下，否则一律丢弃。每收到一个帧后就发送回确认帧。
-
-后退N帧协议
-发送窗口大于1，接收窗口等于1.在后退N帧中，发送方不需要收到上一帧的ACK后才能发送下一帧，而是可以连续发送帧。当接收方检测出失序信息帧后，要求发送方重发最后一个正确接收的帧之后的所有未被确认的帧。源站每发完一帧就要为该帧设置超时计时器，如果在超时时间内没有收到确认帧则进行重发。服务端会采用累积确认的方式，不是每个帧都发确认，可以连续收到好几个正确帧后发回一个确认信息。接收方因为窗口为1，所以必须按序接收数据帧，如果某个序大于当前所期望的序号时就会连续发送3个ACK确认帧，要求客户端重传失序帧。
-
-## TCP的可靠性如何保证
-在TCP的连接中，数据流必须以正确的顺序送达对方。TCP的可靠性是通过顺序编号和确认（ACK）来实现的。TCP在开始传送一个段时，为准备重传而首先将该段插入到发送队列之中，同时启动时钟。其后，如果收到了接受端对该段的ACK信息，就将该段从队列中删去。如果在时钟规定的时间内，ACK未返回，那么就从发送队列中再次送出这个段。TCP在协议中就对数据可靠传输做了保障，握手与断开都需要通讯双方确认，数据传输也需要双方确认成功，在协议中还规定了：分包、重组、重传等规则；而UDP主要是面向不可靠连接的，不能保证数据正确到达目的地。
-
-## Http的报文结构
-http请求由三部分组成，分别是：请求行、消息报头、请求正文
-方法 [空格] URL [空格] 版本
-首部字段名: [空格] 值
-…
-首部字段名: [空格] 值
-[空一行]
-实体主体
-
-HTTP响应也是由三个部分组成，分别是：状态行、消息报头、响应正文
-版本[空格] 状态码 [空格] 短语
-首部字段名: [空格] 值
-…
-首部字段名: [空格] 值
-[空一行]
-实体主体
-更多http内容参考：http://www.cnblogs.com/maanshancss/p/4503385.html
-
-## Http request的几种类型
-HTTP协议中共定义了八种方法或者叫“动作”来表明对Request-URI指定的资源的不同操作方式，具体介绍如下：
-GET：向特定的资源发出请求。
-POST：向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的创建和/或已有资源的修改。
-PUT：向指定资源位置上传其最新内容。
-DELETE：请求服务器删除Request-URI所标识的资源。
-HEAD：请求读取由URL所标志的信息的首部。
-OPTIONS：返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送' * '的请求来测试服务器的功能性。
-TRACE：回显服务器收到的请求，主要用于测试或诊断。
-CONNECT：HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
-
-##  Http1.1和Http1.0的区别
-1)HTTP1.0 是短连接，HTTP1.1是长连接。 HTTP 1.0规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个TCP连接，服务器完成请求处理后立即断开TCP连接，服务器不跟踪每个客户也不记录过去的请求。如果一个html包含多个图片或资源时需要多次与服务器建立连接。 HTTP 1.1支持持久连接，在一个TCP连接上可以传送多个HTTP请求和响应，减少了建立和关闭连接的消耗和延迟。一个包含有许多图像的网页文件的多个请求和应答可以在一个连接中传输，但每个单独的网页文件的请求和应答仍然需要使用各自的连接.HTTP 1.1采用了流水线的持久连接，即客户端不用等待上一次请求结果返回，就可以发出下一次请求，但服务器端必须按照接收到客户端请求的先后顺序依次回送响应结果，以保证客户端能够区分出每次请求的响应内容，这样也显著地减少了整个下载过程所需要的时间。
-2)HTTP 1.0不支持Host请求头字段，WEB浏览器无法使用主机头名来明确表示要访问服务器上的哪个WEB站点，这样就无法使用WEB服务器在同一个IP地址和端口号上配置多个虚拟WEB站点。在HTTP 1.1中增加Host请求头字段后，WEB浏览器可以使用主机头名来明确表示要访问服务器上的哪个WEB站点，这才实现了在一台WEB服务器上可以在同一个IP地址和端口号上使用不同的主机名来创建多个虚拟WEB站点。
-3)HTTP 1.1还提供了与身份认证、状态管理和Cache缓存等机制相关的请求头和响应头
-4)带宽优化。HTTP/1.0中，存在一些浪费带宽的现象，例如客户端只是需要某个对象的一部分，而服务器却将整个对象送过来了。例如，客户端只需要显示一个文档的部分内容，又比如下载大文件时需要支持断点续传功能，而不是在发生断连后不得不重新下载完整的包。
-HTTP/1.1中在请求消息中引入了range头域，它允许只请求资源的某个部分。
-5) HTTP/1.1增加了OPTIONS方法，它允许客户端获取一个服务器支持的方法列表
-
-http://blog.csdn.net/forgotaboutgirl/article/details/6936982
-
-## Http怎么处理长连接
-HTTP1.1和HTTP1.0相比较而言，最大的区别就是增加了持久连接支持。TCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了带宽。
-使用长连接的HTTP协议，会在响应头有加入这行代码：Connection:keep-alive 。在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的 TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立的连接。Keep-Alive不会永久保持连接，它有一个保持时间，可以在不同的服务器软件（如Apache）中设定这个时间。实现长连接要客户端和服务端都支持长连接。
-
-http://www.codeceo.com/article/http-long-connect.html
-
-## Cookie与Session的作用于原理
-会话跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。
-Cookie
-Cookie实际上是一小段的文本信息。客户端请求服务器，如果服务器需要记录该用户状态，就产生一个用户身份标识，然后在响应消息中将该标识号以Cookie的形式传递给浏览器.客户端浏览器会把Cookie保存起来。浏览器在以后每次访问该web服务器时，浏览器把请求的网址连同该Cookie一同提交给服务器。服务器检查该Cookie，以此来辨认用户状态。服务器还可以根据需要修改Cookie的内容. Cookie不能被浏览器共享
-Cookie具有不可跨域名性，例如浏览器访问Google只会携带Google的Cookie，而不会携带Baidu的Cookie。Cookie的maxAge决定着Cookie的有效期，单位为秒（Second）
-**默认情况下,cookie是一个会话级别的,用户退出浏览器后被删除**
-
-Session
-Session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而Session保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。
-如果说Cookie机制是通过检查客户身上的“通行证”来确定客户身份的话，那么Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。
-Session保存在服务器端。为了获得更高的存取速度，服务器一般把Session放在内存里。每个用户都会有一个独立的Session。如果Session内容过于复杂，当大量客户访问服务器时可能会导致内存溢出。因此，Session里的信息应该尽量精简。
-
-session工作原理
-(1)web不会在客户端开始访问它时创建session,在访问特殊的程序并且该程序(servlet)决定与客户端开启会话时,服务器生成一个唯一值,称为Session ID（好像是通过取进程ID的方式取得的）。服务器开辟一块内存，对应于该Session ID。
-(2)服务器再将该Session ID写入浏览器的cookie。
-(3)服务器内有一进程，监视所有Session的活动状况，如果有Session超时或是主动关闭，服务器就释放改内存块。
-(4)当浏览器连入服务器时并请求Session时，服务器就读浏览器Cookie中的Session ID。
-(5)然后，服务检查该Session ID所对应的内存是否有效。
-(6)如果有效，就读出内存中的值。
-(7)如果无效，就建立新的Session。
-
-**tomcat默认设置是30分钟**
-具体设置很简单，方法有三种：
-（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);
-参数900单位是秒，即在没有活动15分钟后，session将失效。设置为-1将永不关闭。
-这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所以如果是在调试程序，应该是修改服务器端时间来测试，而不是客户端。
-（2）也是比较通用的设置session失效时间的方法，就是在项目的web.xml中设置
-<session-config>
-<session-timeout>15</session-timeout>
-</session-config>
-这里的15也就是15分钟失效.
-（3）直接在应用服务器中设置，如果是tomcat，可以在tomcat目录下conf/web.xml中
-找到<session-config>元素，tomcat默认设置是30分钟，只要修改这个值就可以了。
-需要注意的是如果上述三个地方如果都设置了，有个优先级的问题，从高到低：
-（1）-->(2)--->(3)
-
-生命周期:
-1)tomcat默认是30分钟
-2)因为session和cookie有关系，客户端浏览器通过cookie维持该会话，cookie不支持跨浏览器共享，意味着如果把浏览器关该会闭的话该会话就会失效(但服务端还保存着)。因此同一机器的两个浏览器窗口访问服务器时，会生成两个不同的Session。
-
-http://qiusuoge.com/10576.html
-http://blog.csdn.net/colzer/article/details/8686966
-http://www.cnblogs.com/binger/archive/2013/03/19/2970171.html
-
-## 电脑上访问一个网页，整个过程是怎么样的：DNS、HTTP、TCP、OSPF、IP、ARP
-1) 浏览器分析连接指向的页面URL(http://www.baidu.com)
-2) 浏览器向DNS请求www.baidu.com.的IP地址
-3) 域名系统DNS解析出百度官网的服务器IP地址
-4) 浏览器与该服务器建立TCP连接（默认端口80）
-5) 浏览器发出HTTP请求获取指定页面。
-6) 服务器通过HTTP响应把文件对应页面发送给浏览器。
-7) TCP连接释放。
-8) 浏览器将文件进行解析，并将web网页显示给用户。
-
-## get提交和post提交的区别
-1.根据HTTP规范，GET用于信息获取，而且应该是安全的和幂等的。
-　　(1).所谓安全的意味着该操作用于获取信息而非修改信息。换句话说，GET 请求一般不应产生副作用。就是说，它仅仅是获取资源信息，就像数据库查询一样，不会修改，增加数据，不会影响资源的状态。
-　　(2).幂等的意味着对同一URL的多个请求应该返回同样的结果。
-2.根据HTTP规范，POST表示可能修改变服务器上的资源的请求。还是新闻以网站为例，读者对新闻发表自己的评论应该通过POST实现，因为在评论提交后站点的资源已经不同了，或者说资源被修改了。
-3.GET请求的数据会附在URL之后（就是把数据放置在HTTP协议头中），以?分割URL和传输数据，参数之间以&相连.POST把提交的数据则放置在是HTTP包的包体中。
-4.GET安全性较低，POST安全性较高。因为GET在传输过程，数据被放在请求的URL中，而如今现有的很多服务器、代理服务器或者用户代理都会将请求URL记录到日志文件中，然后放在某个地方，这样就可能会有一些隐私的信息被第三方看到。另外，用户也可以在浏览器上直接看到提交的数据，一些系统内部消息将会一同显示在用户面前。
-5.get传送的数据量较小，不能大于2KB。post传送的数据量较大，一般被默认为不受限制。
-6.在FORM（表单）中，Method默认为"GET"
-
-
-幂等（idempotent、idempotence）是一个数学或计算机学概念，常见于抽象代数中。
-　　幂等有一下几种定义：
-　　对于单目运算，如果一个运算对于在范围内的所有的一个数多次进行该运算所得的结果和进行一次该运算所得的结果是一样的，那么我们就称该运算是幂等的。比如绝对值运算就是一个例子，在实数集中，有abs(a)=abs(abs(a))。
-　　对于双目运算，则要求当参与运算的两个值是等值的情况下，如果满足运算结果与参与运算的两个值相等，则称该运算幂等，如求两个数的最大值的函数，有在在实数集中幂等，即max(x,x) = x。
-详见: http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html
-http://www.cnblogs.com/skynet/archive/2010/05/18/1738301.html
-
-## https如何加密的
-HTTPS介绍：
-HTTPS(Secure Hypertext Transfer Protocol)安全超文本传输协议 它是一个安全通信通道，它基于HTTP开发，用于在客户计算机和服务器之间交换信息。**它使用安全套接字层(SSL)进行信息交换**，简单来说它是HTTP的安全版。 它是由Netscape开发并内置于其浏览器中，使用SSL在发送方把原始数据进行加密，然后在接受方进行解密保证数据的安全性．然而，加密和解密过程需要耗费系统大量的开销，严重降低机器的性能.
-HTTPS实际上就是SSL over HTTP，它使用默认端口**443**，而不是像HTTP那样使用端口80来和TCP/IP进行通信。HTTPS协议使用SSL在发送方把原始数据进行加密，然 后在接受方进行解密，加密和解密需要发送方和接受方通过交换共知的密钥来实现，因此，所传送的数据不容易被网络黑客截获和解密.然而，加密和解密过程需要耗费系统大量的开销，严重降低机器的性能，相关测试数据表明使用HTTPS协议传输数据的工作效率只有使用HTTP协议传输的十分之一。
-
-如何实现加密：（其实就是sssl的交互过程）
-HTTPS其实是有两部分组成：HTTP + SSL / TLS，也就是在HTTP上又加了一层处理加密信息的模块。服务端和客户端的信息传输都会通过TLS进行加密，所以传输的数据都是加密后的数据。具体是如何进行加密，解密，验证的
-
-http://blog.csdn.net/binyao02123202/article/details/8049446
-http://www.codeceo.com/article/why-http-better-than-https.html
-
-## http和https的区别
-1. https协议需要到ca申请证书，一般免费证书很少，需要交费。
-2. http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议 http和https使用的是完全不同的连接方式用的端口也不一样：前者是80，后者是443。
-3. http的连接很简单，是无状态的 HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全 HTTPS解决的问题.
-http://www.admin5.com/article/20150708/608526.shtml
-
-## SSL协议及完整交互过程
-SSL是Netscape公司所提出的安全保密协议，在浏览器(如Internet Explorer、Netscape Navigator)和Web服务器(如Netscape的Netscape Enterprise Server、ColdFusion Server等等)之间构造安全通道来进行数据传输，SSL运行在TCP/IP层之上、应用层之下，为应用程序提供加密数据通道，它采用了RC4、MD5 以及RSA等加密算法，使用40 位的密钥，适用于商业信息的加密。
-
-开始加密通信之前，客户端和服务器首先必须建立连接和交换参数，这个过程叫做握手（handshake）。
-**1 客户端发出请求（ClientHello）**
-首先，客户端（通常是浏览器）先向服务器发出加密通信的请求，这被叫做ClientHello请求。在这一步，客户端主要向服务器提供以下信息。
-（1） 支持的协议版本，比如TLS 1.0版。
-（2） 一个客户端生成的随机数，稍后用于生成"对话密钥"。
-（3） 支持的加密方法，比如RSA公钥加密。
-（4） 支持的压缩方法。
-
-**4.2 服务器回应（SeverHello）**
-服务器收到客户端请求后，向客户端发出回应，这叫做SeverHello。服务器的回应包含以下内容：
-（1） 确认使用的加密通信协议版本，比如TLS 1.0版本。如果浏览器与服务器支持的版本不一致，服务器关闭加密通信。
-（2） 一个服务器生成的随机数，稍后用于生成"对话密钥"。
-（3） 确认使用的加密方法，比如RSA公钥加密。
-（4） 服务器证书。（公钥）
-**4.3 客户端回应**
-客户端收到服务器回应以后，首先验证服务器证书。如果证书不是可信机构颁布、或者证书中的域名与实际域名不一致、或者证书已经过期，就会向访问者显示一个警告，由其选择是否还要继续通信。
-如果证书没有问题，客户端就会从证书中取出服务器的公钥。然后，向服务器发送下面三项信息。
-（1） 一个随机数。该随机数用服务器公钥加密，防止被窃听。
-（2） 编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
-（3） 客户端握手结束通知，表示客户端的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供服务器校验。
-上面第一项的随机数，是整个握手阶段出现的第三个随机数，又称"pre-master key"。有了它以后，客户端和服务器就同时有了三个随机数，接着双方就用事先商定的加密方法，各自生成本次会话所用的同一把"会话密钥"。（会话秘钥是采用对称加密方式，而这里的公钥是采用非对称加密）
-**4 服务器的最后回应**
-服务器通过私钥解密收到客户端的第三个随机数pre-master key之后，计算生成本次会话所用的"会话密钥"。然后，向客户端最后发送下面信息。
-（1）编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
-（2）服务器握手结束通知，表示服务器的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供客户端校验。
-至此，整个握手阶段全部结束。接下来，客户端与服务器进入加密通信，就完全是使用普通的HTTP协议，只不过用"会话密钥"加密内容。
-
-至于为什么一定要用三个随机数，来生成"会话密钥"，dog250解释得很好：
-"不管是客户端还是服务器，都需要随机数，这样生成的密钥才不会每次都一样。由于SSL协议中证书是静态的，因此十分有必要引入一种随机因素来保证协商出来的密钥的随机性。
-对于RSA密钥交换算法来说，pre-master-key本身就是一个随机数，再加上hello消息中的随机，三个随机数通过一个密钥导出器最终导出一个对称密钥。
-pre master的存在在于SSL协议不信任每个主机都能产生完全随机的随机数，如果随机数不随机，那么pre master secret就有可能被猜出来，那么仅适用pre master secret作为密钥就不合适了，因此必须引入新的随机因素，那么客户端和服务器加上pre master secret三个随机数一同生成的密钥就不容易被猜出了，一个伪随机可能完全不随机，可是是三个伪随机就十分接近随机了，每增加一个自由度，随机性增加的可不是一。"
-
-http://limboy.me/tech/2011/02/19/https-workflow.html
-http://www.ruanyifeng.com/blog/2014/02/ssl_tls.html
-http://www.ruanyifeng.com/blog/2014/09/illustration-ssl.html
-http://kb.cnblogs.com/page/162080/
-
-## https处理的一个过程，对称加密和非对称加密（参考上一条，这一条就是通俗的表示）
-1. SSL原理很简单。当你的浏览器向服务器请求一个安全的网页(通常是 https://)
-2. 服务器就把它的证书和公匙发回来
-3. 浏览器检查证书是不是由可以信赖的机构颁发的，确认证书有效和此证书是此网站的。
-4. 浏览器使用公钥加密了一个随机对称密钥，包括加密的URL一起发送到服务器。
-5. 服务器用自己的私匙解密了你发送的钥匙。然后用这把对称加密的钥匙给你请求的URL链接解密。
-6. 服务器用你发的对称钥匙给你请求的网页加密。你也有相同的钥匙就可以解密发回来的网页了
-
-加密算法绝大部分都属于以下两种加密类型之一：
-对称加密：加密解密用的是同样的“钥匙”
-非对称加密：加密解密用的是不同的“钥匙”
-
-对称加密
-Alice 在盒子里放有信息，盒子上有挂锁，她有钥匙。通过邮局她把这个盒子寄给Bob。Bob收到盒子后，用相同的钥匙打开盒子（钥匙之前就得到了，可能是Alice面对面给他的）。然后Bob可以用同样的方法回复。
-
-非对称加密
-Bob和Alice各有自己的盒子。Alice要跟Bob秘密通信，她先让Bob把开着的盒子通过邮局发给她。Alice拿到盒子后放入信息锁上，然后发给Bob。Bob就可以用他自己的钥匙打开了。回复的话就用同样的方法。
-非对称算法在加密和解密时用的是不同的钥匙。信息接受者有两把钥匙：一把“公匙”，一把“私匙”。公匙是给信息发送者用来加密的，私匙是自己用来解密的。这样最大的好处是：不必通过不安全的渠道发送私密的东西。公匙本来就是给别人用的，不用藏好。你的私匙在你产生私匙的电脑里保存着。
-
-http://article.yeeyan.org/view/90729/174903/
-
-## Http和https的区别
- - http是HTTP协议运行在TCP之上。所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份
- - https是HTTP运行在SSL/TLS之上，SSL/TLS运行在TCP之上。所有传输的内容都经过加密，加密采用对
- - 加密，但对称加密的密钥用服务器方的证书进行了非对称加密。此外客户端可以验证服务器端的身份
- - 如果配置了客户端验证，服务器方也可以验证客户端的身份。
- - https协议需要到ca申请证书，一般免费证书很少，需要交费。
- - http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议
- - http和https使用的是完全不同的连接方式用的端口也不一样,前者是80,后者是443。
- - http的连接很简单,是无状态的
- - HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全
-
-https://github.com/Wl201314/MartinBlog/tree/master/Blog/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9F%BA%E7%A1%80
-## DNS域名系统，简单描述其工作原理。
-域名系统DNS是因特网使用的命名系统，用于把便于人们记忆的含有特定含义的主机名转换为便于机器处理的IP地址。DNS系统采用C/S模式，其协议运行在UDP上，使用53号端口。从概念上讲DNS可以分为3个部分：层次域名空间，域名服务器和解析器。
-
-域名解析是把域名映射成IP地址或者把IP地址映射成域名的过程。域名解析有两种方式：递归查询和迭代查询。
-递归查询：如果本地主机询问的本地域名服务器不知道被查询的域名IP地址，那么**本地域名服务器**就以DNS客户的身份，向**根域名服务器**继续发出查询请求报文，而不是自己进行下一步非查询。根域名服务器会继续向**顶级域名服务器**查询请求，如果存在则直接返回给根服务器，否则顶级域名服务器向对应的**权限域名服务器**查询。是一种递归的查询方式。
-
-迭代查询：如果本地主机询问的本地域名服务器不知道被查询的域名IP地址，那么本地域名服务器就以DNS客户的身份，向根域名服务器继续发出查询请求报文。跟服务器收到请求报文时，要么给出所有查询的IP地址，要么告诉本地域名服务器下一步需要查询的顶级域名服务器。然后本地服务器向这个顶级域名服务器进行后续的查询。同样的顶级域名服务器收到查询报文后，要么给出所要查询的IP地址，要么告诉本地域名服务器下一步应该查找那个权限域名服务器。
-
-## 面向连接和非面向连接的服务的特点是什么？
-面向连接的服务：通信双方进行通信之前，必须先建立连接，在通信过程中，整个连接情况一直都是被实时地监控和管理。当通信结束后，则应释放这个连接。
-无连接服务：两个实体之间的通信不需要先建立好连接，需要通信的时候，直接将信息发送到”网络”中，让该信息的传递在网上尽力而为地往目的地传送。
-
-## 端口及对应的服务？
-FTP 21    SSH 22    telnet 23    SMTP 25   Domain(域名服务器) 53    HTTP 80
-POP3 110   NTP（网络时间协议）123    MySQL数据库服务3306  https 443 SNMP(161) TFTP(69)
-Shell或 cmd 514     POP-2  109    SQL Server 1433
-
-## 各种协议
-ICMP协议： 因特网控制报文协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。
-TFTP协议： 是TCP/IP协议族中的一个用来在客户机与服务器之间进行简单文件传输的协议，提供不复杂、开销不大的文件传输服务。
-HTTP协议： 超文本传输协议，是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。
-DHCP协议： 动态主机配置协议，是一种让系统得以连接到网络上，并获取所需要的配置参数手段。
-NAT协议：网络地址转换属接入广域网(WAN)技术，是一种将私有（保留）地址转化为合法IP地址的转换技术，
-DHCP协议：一个局域网的网络协议，使用UDP协议工作，用途：给内部网络或网络服务供应商自动分配IP地址，给用户或者内部网络管理员作为对所有计算机作中央管理的手段。
-
-## Ping的整个过程
-同一个局域网中：
-1、Pc1在应用层发起个目标IP位IP2的Ping请求。
-2、传输层接到上层请求的数据，将数据分段并加上UDP报头。下传到Internet层。
-3、 网际层接收来处上层的数据后，根据ICMP协议进行封装，添加PC1的IP为源IP为和PC2IP为目标IP后封装成数据包。下传到网络接口层。
-4、网络接口层接收数据包后，进行封装，源MAC地址为PC1的MAC地址，目标MAC地址则查询自己的ARP缓存表获取。如果PC1 arp缓存表中没有目标IP对应的MAC地址，则PC1发出一个ARP广播报文。ARP报文中源MAC地址为Pc1mac地址，源IP地址为pc1 IP，所要请求的是PC2的IP对应的mac地址。
-5、PC2收到ARP广播后，进行解封装，发现所请求的MAC地址是自己的。则PC2将PC1的mac地址写入arp缓存表中。然后向PC1发送一个 ARP应答单播。该单播消息包括目标IP为PC1ip，目标Mac为pc1mac地址，源IP为PC2的IP，源Mac为pc2的Mac。
-6、Pc1接收到PC2的arp应答报文后，将Pc2的MAC地址存入arp缓存中，并将Pc2的Mac地址作为目标地址封装到数据帧中。发给下层进行网络传输。
-7、PC2接收这个帧后，在网络接口层查看目标mac地址是否指向自己。是，PC2则将帧头去掉，向上层传输。
-8、Pc2网际层接收到这个信息包，查看包头，发现目标IP和自己匹配，则解封装，将数据向上层传输。
-9、传输层接收来自下层的Ping请求的UDP报文，则去掉UDP报头，向应用层传送。
-10、应用层收到ping请求后，发送一个PIng回应报文给PC1
-http://blog.chinaunix.net/uid-26758209-id-3146224.html
-
-##  ICMP协议：
-1) ICMP允许主机或路由报告差错情况和提供有关异常情况。ICMP是因特网的标准协议，但ICMP不是高层协议，而是IP层的协议。通常ICMP报文被IP层或更高层协议（TCP或UDP）使用。一些ICMP报文把差错报文返回给用户进程。
-2) ICMP报文作为IP层数据报的数据，加上数据报的首部，组成数据报发送出去。
-3) ICMP报文的种类有两种，即ICMP差错报告报文和ICMP询问报文。
-
-差错报告
-ICMP差错报告报文共有5种：
- 终点不可达：终点不可达分为:网络不可达，主机不可达，协议不可达，端口不可达，需要分片但DF比特已置为1，以及源路由失败等六种情况，其代码字段分别置为0至5。当出现以上六种情况时就向源站发送终点不可达报文。
-说明：
-端口不可达：UDP的规则之一是：如果收到UDP数据报而且目的端口与某个正在使用的进程不相符，那么UDP返回一个ICMP不可达报文。
-源站抑制：当路由器或主机由于拥塞而丢弃数据报时，就向源站发送源站抑制报文，使源站知道应当将数据报的发送速率放慢。
-时间超过：当路由器收到生存时间为零的数据报时，除丢弃该数据报外，还要向源站发送时间超过报文。当目的站在预先规定的时间内不能收到一个数据报的全部数据报片时，就将已收到的数据报片都丢弃，并向源站发送时间超过报文。
-参数问题：当路由器或目的主机收到的数据报的首部中的字段的值不正确时，就丢弃该数据报，并向源站发送参数问题报文。
-改变路由（重定向）路由器将改变路由报文发送给主机，让主机知道下次应将数据报发送给另外的路由器。
-
-询问报文
-ICMP询问报文有四种
-**回送请求和回答**，ICMP回送请求报文是由主机或路由器向一个特定的目的主机发出的询问。收到此报文的机器必须给源主机发送ICMP回送应答报文。这种询问报文用来测试目的站是否可达以及了解其有关状态
-**时间戳请求和回答**：ICMP时间戳请求允许系统向另一个系统查询当前的时间。该ICMP报文的好处是它提供了毫秒级的分辨率，而利用其他方法从别的主机获取的时间只能提供秒级的分辨率。请求端填写发起时间，然后发送报文。应答系统收到请求报文时填写接收时间戳，在发送应答时填写发送时间戳。大多数的实现是把后面两个字段都设成相同的值。
-**掩码地址请求和回答**：主机使用ICMP地址掩码请求报文可向子网掩码服务器得到某个接口的地址掩码。
-**路由器询问和通过**：主机使用ICMP路由器询问和通过报文可了解连接在本网络上的路由器是否正常工作。主机将路由器询问报文进行广播（或多播）。收到询问报文的一个或几个路由器就使用路由器通过报文广播其路由选择信息
-
-## C/S模式下使用socket通信，几个关键函数
-
-## 知识点：
-1) SSP通过七号信令网实现与SAU的连接，而SCP与SAU之间通过TCP/IP协议连接。
-2) 重组发生在目的主机，分片发生在路由器上
+
+## OSI（开放系统互联参考模型）标准模型
+**物理层**
+负责为数据端设备透明地传输原始比特流，并且定义了数据终端设备和数据通信设备的物理和逻辑链接方法。传输单位是比特。
+协议：RJ45、CLOCK、IEEE802.3
+设备：（中继器，集线器）
+**数据链路层**
+将网络层传下来的IP数据报组装成帧，并检测和矫正物理层产生的传输差错，使得链路对网络层显示一条无差错、可靠的数据传输线路。功能可以概括为成帧，差错控制、流量控制和传输管理
+协议有：HDLC(高级数据链路控制协议),PPP,STP,SDLC,CSMA(载波监听多路访问)
+设备:（网桥，交换机）
+**网络层**
+负载在网络层上将数据封装成数据报，将数据报从源端传到目的端，同时进行路由选择，为分组交换网上的不同主机提供通信服务。关键问题是对分组进行选择，并实现流量控制、拥塞控制、差错控制和网际互联等功能。传输单位数据报。
+协议: IP,ICMP(因特网控制报文协议),IGMP(因特网组管理协议),ARP,RARP,OSPF(开放最短路径优先),IPX
+设备:路由器
+**传输层**
+负责主机中两个进程之间的通信，为端到端连接提供可靠的传输服务。为端到端连接提供流量控制、差错控制、服务质量、数据传输管理等服务。
+协议：TCP,UDP
+**会话层**
+会话层允许不同主机上各个进程之间的**会话**，会话层利用传输层提供的端到端的服务，向表示层提供它的增值服务。这种服务主要是为表示层实体或用户进程**建立连接**并在连接上提供**有序**地传输数据。
+协议：SQL、RPC(远程调用协议)
+**表示层**
+用于处理两个通信系统中交换信息的表示方式。如数据压缩，加密和解密等。
+协议：JPEG、MPEG、ASII
+**应用层**
+是TCP/IP的最高层，它是直接为应用进程服务的一层。当不同的应用进程数据通信或数据交换时，就去调用应用层的**不同协议实体**，让这些实体去调用TCP或者UDP层服务来进行网络传输。
+协议：FTP(21) TELNET(23) SMTP(25) DNS(53) TFTP(69) HTTP(80) SNMP(161),DHCP(动态主机配置协议)
+
+## TCP/IP 分层
+1）**网络接口层（接收和发送数据报）**
+负责将数据报发送到**网络介质**上，以及从网络上接收TCP/IP数据报，相当于OSI的物理层和数据层。
+2）**网际层（数据报封装和路由寻址功能）**
+主要负责寻址和对数据报的封装以及重要的路由选择功能。
+3)**传输层**
+**负责在应用进程之间的“端到端”的通信**，即从某个应用进程传输到另一个应用进程。
+4)应用层
+是TCP/IP的最高层，它是直接为应用进程服务的一层。当不同的应用进程数据通信或数据交换时，就去调用应用层的**不同协议实体**，让这些实体去调用TCP或者UDP层服务来进行网络传输。
+
+## 五层体系结构模型
+物理层，数据链路层，网络层，传输层，应用层
+
+## IP地址分类
+A类地址：以0开头， 第一个字节范围：1~126（1.0.0.0 - 126.255.255.255）；
+B类地址：以10开头， 第一个字节范围：128~191（128.0.0.0 - 191.255.255.255）；
+C类地址：以110开头， 第一个字节范围：192~223（192.0.0.0 - 223.255.255.255）；
+D类地址：1110开头， 224~239
+E类地址：11110开头， 240~255
+主机号全为0表示本网络本身
+主机号全为1表示本网络广播地址
+127.0.0.0 环路自检地址，表示任意主机本身
+32个0 表示本网络的本主机
+32个1表示整个TCP/IP网络的广播地址,等效本网络的广播地址。
+专用地址：
+10.0.0.0—10.255.255.255， 172.16.0.0—172.31.255.255， 192.168.0.0—192.168.255.255。（Internet上保留地址用于内部）
+IP地址与子网掩码相与得到网络号
+
+## ARP是地址解析协议，简单语言解释一下工作原理
+每个主机都存有一个ARP高速缓存，存放本局域网上各主机和路由器的IP地址到MAC地址的映射表，称为ARP表。使用ARP协议动态维护此表。
+ARP工作在网络层中，其工作原理是：当主机A欲向本局域网上的某个主机B发送IP数据报时，就先在其ARP高速缓存中查看有无主机B的IP地址。如果有可以查出其对应的硬件地址，再将此硬件地址写入**MAC帧**，然后通过局域网将该MAC帧发往此硬件地址。如果没有，就通过使用目的MAC地址为本网络的广播地址即32个1的帧来封装并广播ARP请求分组，可以使同一个局域网里的所有主机收到ARP请求。当主机B收到该ARP请求后，就会向主机A发出响应ARP分组，分组中包含主机B的IP与MAC地址的映射关系，主机A在收到后将此映射写入ARP缓存中，然后按查询到的硬件地址发送MAC帧。
+**ARP是解决同一个局域网上主机与路由器的IP地址和硬件地址的映射问题**。如果所要找的主机和源主机不在同一个局域网上，那么通过ARP协议找到一个位于本局域网上的某个路由器硬件地址，然后把分组发送给这个路由器，让这个路由器把分组转发给下一个网络。
+
+## 描述RARP协议
+RARP是逆地址解析协议，作用是完成硬件地址到IP地址的映射.(请求是广播，应答是单播)
+1)网络上的每台设备都会有一个独一无二的硬件地址，通常是由设备厂商分配的MAC地址。主机从网卡上读取MAC地址，然后在网络上发送一个RARP请求的广播数据包，请求的RARP服务器分配一个IP地址。
+2)本地网段上的RARP服务器收到此请求后，检查其RARP列表，查找该MAC地址对应的IP地址。
+3)如果存在，RARP服务器就给源主机发送一个响应数据包并将此IP地址提供给对方主机使用。
+4)如果不存在，RARP服务器对此不做任何的响应。
+5)源主机收到从RARP服务器的响应信息，就利用得到的IP地址进行通讯；如果一直没有收到RARP服务器的响应信息，表示初始化失败
+
+
+## 了解交换机、路由器、网关的概念，并知道各自的用途
+两者简介：
+**路由器**是具有多个输入输出端口的专用计算机，**其任务是连接不同的网络并完成路由转发**。当源主机向目标主机发送数据报时，路由器先检查源主机与目标主机是否连接在一个网络上。如果源主机和目标主机在一个网络上则直接交付而无需通过路由器。但如果源主机和目标主机不在同一个网络上，则路由器转发表指出路由将数据报转发给下一个路由器，即间接交付。路由器隔离了广播域。
+
+**交换机**：是多个端口的网桥，工作在数据链路上，**将两个或多个以太网连接起来成为更大的以太网。它能将网络分成小的冲突域，为每个工作站提供更高的带宽**。其原理是，检测从以太端口来的数据帧的源和目的地的MAC地址，然后与系统内部的动态查找表进行比较。若数据帧的MAC地址不在查找表中，则将该地址加入查找表中，并将数据帧发送给相应的端口。
+
+区别：
+**路由器**：工作在网络层，是能够连接不同的广域网形成更大的广域网。连接的是异构网络。根据IP地址转发。
+**交换机**：工作在数据链路层，是将以太网连接形成更大的以太网，同一个网络。根据MAC地址进行转发。
+
+**网关(Gateway)**又称网间连接器、协议转换器。网关在网络层以上实现网络互连，是最复杂的网络互连设备，**仅用于两个高层协议不同的网络互连**。网关既可以用于广域网互连，也可以用于局域网互连。 网关是一种充当转换重任的计算机系统或设备。使用在不同的通信协议、数据格式或语言，甚至体系结构完全不同的两种系统之间，网关是一个翻译器。
+
+## OSI 和TCP/IP的区别
+1. OSI精确定义了服务、协议和接口，符合面向对象程序设计思想。而TCP/IP在这些概念上没有明确区分。
+2. OSI在产生协议之前没有偏向任何特定的协议，通用性良好，但设计没有太多经验不知道将哪些功能放到哪一层。TCP/IP,首先出现协议，模型实际上是对已有协议的描述。因此不会出现协议不能匹配的模式。
+3. TCP/IP考虑了异构网的互联问题，而OSI只考虑用一种标准的公用数据网将各种不同系统互连。
+4. OSI在网络层支持无连接和面向连接的通信，但在传输层仅有面向连接通信。而TCP/IP则相反，在网际层仅有无连接服务，在传输层支持无连接和面向连接两种模式。
+
+## TCP与UDP的区别
+1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接
+2、TCP提供可靠全双功的通信服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP则是不可靠信道，尽最大努力交付，即不保证可靠交付
+3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的．
+4.TCP具有拥塞控制，UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
+5、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信
+6、TCP首部开销20字节;UDP的首部开销小，只有8个字节.
+
+### TCP应用场景
+：效率要求相对低，但对准确性要求相对高的场景。因为传输中需要对数据确认、重发、排序等操作，相比之下效率没有UDP高。举几个例子：文件传输（准确高要求高、但是速度可以相对慢）、接受邮件、远程登录。
+
+### UDP应用场景
+：效率要求相对高，对准确性要求相对低的场景。举几个例子：QQ聊天、在线视频、网络语音电话（即时通讯，速度要求高，但是出现偶尔断续不是太大问题，并且此处完全不可以使用重发机制）、广播通信（广播、多播）。
+
+## TCP对应的协议和UDP对应的协议
+**TCP对应的协议**：
+（1） FTP(21)：定义了文件传输协议，使用21端口。常说某某计算机开了FTP服务便是启动了文件传输服务。下载文件，上传主页，都要用到FTP服务。
+（2） Telnet(23)：(远程登陆协议)它是一种用于远程登陆的端口，用户可以以自己的身份远程连接到计算机上，通过这种端口可以提供一种基于DOS模式下的通信服务。如以前的BBS是-纯字符界面的，支持BBS的服务器将23端口打开，对外提供服务。
+（3） SMTP(25)：定义了简单邮件传送协议，现在很多邮件服务器都用的是这个协议，用于发送邮件。如常见的免费邮件服务中用的就是这个邮件服务端口，所以在电子邮件设置-中常看到有这么SMTP端口设置这个栏，服务器开放的是25号端口。
+（4） POP3(110)：它是和SMTP对应，POP3用于接收邮件。通常情况下，POP3协议所用的是110端口。也是说，只要你有相应的使用POP3协议的程序（例如Fo-xmail或Outlook），就可以不以Web方式登陆进邮箱界面，直接用邮件程序就可以收到邮件（如是163邮箱就没有必要先进入网易网站，再进入自己的邮-箱来收信）。
+（5）HTTP(80)协议：是从Web服务器传输超文本到本地浏览器的传送协议。
+**UDP对应的协议**：
+（1） DNS(53)：用于域名解析服务，将域名地址转换为IP地址。DNS用的是53号端口。
+(2) RIP:路由信息协议，端口520
+（2） SNMP(161)：简单网络管理协议，使用161号端口，是用来管理网络设备的。由于网络设备很多，无连接的服务就体现出其优势。
+（3） TFTP(69)(Trival File Transfer Protocal)，简单文件传输协议，该协议在熟知端口69上使用UDP服务。
+
+http://www.jianshu.com/p/8be9b3204864
+http://www.jianshu.com/p/eab86c0d1612
+## 常见的路由选择协议，以及它们的区别
+常见的路由选择协议有：RIP协议、OSPF协议。
+RIP协议（路由信息协议）：底层是贝尔曼福特算法，**基于距离向量的路由选择协议**，它选择路由的度量标准（metric)是**跳数**，最大跳数是15跳，如果大于15跳，它就会丢弃数据包。仅和相邻路由器交换当前路由器所知道的全部信息。是应用层协议,使用UDP传输数据,端口520
+OSPF协议（开放最短路由优先）：底层是迪杰斯特拉算法，**是链路状态路由选择协议**，它选择路由的度量标准是**带宽**，延迟。向本自治系统中所有路由器发送与本路由器相邻的所有路由器的链路状态，但这只是路由器知道的部分信息。网络层协议,直接IP数据报传输．
+
+## TCP报文首部
+源端口和目的端口，各占2个字节，分别写入源端口和目的端口；
+序号，占4个字节，TCP连接中传送的字节流中的每个字节都按顺序编号。例如，一段报文的序号字段值是 301 ，而携带的数据共有100字段，显然下一个报文段（如果还有的话）的数据序号应该从401开始；
+确认号，占4个字节，是期望收到对方下一个报文的第一个数据字节的序号。例如，B收到了A发送过来的报文，其序列号字段是501，而数据长度是200字节，这表明B正确的收到了A发送的到序号700为止的数据。因此，B期望收到A的下一个数据序号是701，于是B在发送给A的确认报文段中把确认号置为701；
+数据偏移，占4位，它指出TCP报文的数据距离TCP报文段的起始处有多远；
+保留，占6位，保留今后使用，但目前应都位0；
+紧急URG，当URG=1，表明紧急指针字段有效。告诉系统此报文段中有紧急数据；
+**确认ACK**，仅当ACK=1时，确认号字段才有效。TCP规定，在连接建立后所有报文的传输都必须把ACK置1；
+推送PSH，当两个应用进程进行交互式通信时，有时在一端的应用进程希望在键入一个命令后立即就能收到对方的响应，这时候就将PSH=1；
+复位RST，当RST=1，表明TCP连接中出现严重差错，必须释放连接，然后再重新建立连接；
+**同步SYN**，在连接建立时用来同步序号。当SYN=1，ACK=0，表明是连接请求报文，若同意连接，则响应报文中应该使SYN=1，ACK=1；
+**终止FIN**，用来释放连接。当FIN=1，表明此报文的发送方的数据已经发送完毕，并且要求释放；
+窗口，占2字节，指的是通知接收方，发送本报文你需要有多大的空间来接受；
+检验和，占2字节，校验首部和数据这两部分；
+紧急指针，占2字节，指出本报文段中的紧急数据的字节数；
+选项，长度可变，定义一些其他的可选的参数。
+
+## TCP的三次握手与四次挥手过程，各个状态名称与含义，TIMEWAIT的作用
+**三次握手**
+第一次握手：客户机首先向服务器的TCP发送一个连接请求报文段，这个特殊的报文段不含应用层数据，其首部中同步位 **SYN=1**。另外，客户机会随机选择一个起始序号 **seq=x**(连接请求报文不携带数据，但要消耗一个序号)；客户端进程进入了 **SYN-SENT（同步已发送状态）状态**
+第二次握手：服务器的TCP收到连接请求报文段后，如果同意建立连接，就向客户机发回确认，并为该TCP连接分配TCP缓存和变量。在确认报文段中，**SYN=1,ACK=1**，确认号字段值为 **ack=x+1**,并且服务器随机产生起始序号 **seq=y**. 确认包同样不包含应用层数据。 服务器进程进入了 **SYN-RCVD（同步收到）状态**
+第三次握手：当客户机收到确认报文段后，还要向服务器给出确认，并且也要给该连接**分配缓存和变量**。这个报文段的确认为 **ACK=1**，序号段被设置为 **seq=x+1**,确认号字段 **ack=y+1**. 该报文段可以携带数据，如果不携带数据则不消耗序号。客户端进入 **ESTABLISHED（已建立连接）状态**
+理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。因为TCP提供全双工通信，因此双方任何时候都可以发送数据。
+
+### 为什么TCP客户端最后还要发送一次确认呢？
+  一句话，主要 **防止已经失效的连接请求报文突然又传送到了服务器，从而产生错误**。
+
+  如果使用的是两次握手建立连接，假设有这样一种场景，**客户端发送了第一个请求连接并且没有丢失，只是因为在网络结点中滞留的时间太长了，由于TCP的客户端迟迟没有收到确认报文**，以为服务器没有收到，此时重新向服务器发送这条报文，此后客户端和服务器经过两次握手完成连接，传输数据，然后关闭连接。此时此前滞留的那一次请求连接，网络通畅了到达了服务器，这个报文本该是失效的，但是，两次握手的机制将会让客户端和服务器再次建立连接，这将导致不必要的错误和资源的浪费。
+
+  如果采用的是三次握手，就算是那一次失效的报文传送过来了，服务端接受到了那条失效报文并且回复了确认报文，但是客户端不会再次发出确认。由于服务器收不到确认，就知道客户端并没有请求连接。
+
+**四次挥手**
+第一次挥手：客户机打算关闭连接，就向其TCP发送一个连接释放报文，并停止再发送数据，主动关闭TCP连接。该报文段的 **FIN=1**，**seq=u**,它等于前面已经发送过的数据的最后一个字节的序号加1。 客户端进入 **FIN-WAIT-1（终止等待1）状态**
+第二次挥手：服务器收到连接释放报文段后即发出确认，确认号是ack=u+1,序号为v,等于它前面已经发送过的数据的最后一个字节序号加1.此时客户机到服务器这个方向的连接就释放了，TCP处于半关闭状态。**ACK=1，seq=v,ack=u+1**，服务端就进入了 **CLOSE-WAIT（关闭等待）状态**
+客户端收到第二次挥手 ，客户端进入 **FIN-WAIT-2（终止等待2）状态**
+第三次挥手：若服务器已经没有要向客户机发送的数据，就通知TCP释放连接，此时发出 **FIN=1**，确认号 **ack= u+1** ,序号 **seq =w**,已经发送过的数据最后一个字节加1。确认为ACK=1. 服务器就进入了 **LAST-ACK（最后确认）状态**
+(**FIN = 1, ACK=1,seq = w, ack =u+1**)
+第四次挥手：客户机收到连接释放报文段后，必须发出确认。在确认报文段中，确认位 **ACK=1**，序号 **seq=u+1**,确认号 **ack=w+1** . 此时连接还没有释放掉，**必须经过实践等待计时器设置的时间2MSL(Max Segment Lifetime),后**，客户机才进入连接关闭状态。
+(**ACK=1,seq=u+1,ack=w+1**)
+
+### 为什么客户端最后还要等待2MSL？
+  MSL（Maximum Segment Lifetime），TCP允许不同的实现可以设置不同的MSL值。
+
+  第一，保证客户端发送的最后一个ACK报文能够到达服务器，因为这个ACK报文可能丢失，**站在服务器的角度看来，我已经发送了FIN+ACK报文请求断开了，客户端还没有给我回应，应该是我发送的请求断开报文它没有收到，于是服务器又会重新发送一次，** 而客户端就能在这个2MSL时间段内收到这个重传的报文，接着给出回应报文，并且会重启2MSL计时器。
+
+  第二，防止类似与“三次握手”中提到了的“已经失效的连接请求报文段”出现在本连接中。客户端发送完最后一个确认报文后，在这个2MSL时间中，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样新的连接中不会出现旧连接的请求报文。
+
+### 为什么建立连接是三次握手，关闭连接确是四次挥手呢？
+
+  建立连接的时候， 服务器在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。
+  而关闭连接时，服务器收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，而 **自己也未必全部数据都发送给对方了**，所以己方可以立即关闭，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送，从而导致多了一次。
+
+### 如果已经建立了连接，但是客户端突然出现故障了怎么办？
+  TCP还设有一个保活计时器，显然，客户端如果出现故障，服务器不能一直等下去，白白浪费资源。服务器每收到一次客户端的请求后都会重新复位这个计时器，时间通常是设置为2小时，若两小时还没有收到客户端的任何数据，服务器就会发送一个探测报文段，以后每隔75分钟发送一次。若一连发送10个探测报文仍然没反应，服务器就认为客户端出了故障，接着就关闭连接。
+
+https://blog.csdn.net/qzcsu/article/details/72861891
+http://www.cnblogs.com/Jessy/p/3535612.html
+
+## 为什么会采用三次握手，若采用二次握手可以吗？
+采用三次握手是为了防止失效的连接请求报文段再次传到服务器，因而产生错误。如果由于网络不稳定，虽然客户端以前发送的连接请求以到达服务方，但服务方的同意连接的应答未能到达客户端。则客户方要重新发送连接请求，若采用二次握手，服务方收到客服端重传的请求连接后，会以为是新的请求，就会发送同意连接报文，并新开进程提供服务，这样会造成服务方资源的无谓浪费。
+如果只采用一次的话，客户端不知道服务端是否已经收到自己发送的数据，则会不断地发送数据。为了保证服务端能收接受到客户端的信息并能做出正确的应答而进行前两次(第一次和第二次)握手，为了保证客户端能够接收到服务端的信息并能做出正确的应答而进行后两次(第二次和第三次)握手
+
+
+## 为什么四次挥手，主动方要等待２MSL后才关闭连接．
+一、保证TCP协议的全双工连接能够可靠关闭．
+主要为了确保对方能受到ACK信息. 如果Client直接CLOSED了，那么由于IP协议的不可靠性或者是其它网络原因，导致Server没有收到Client最后回复的ACK。那么Server就会在超时之后继续发送FIN，此时由于Client已经CLOSED了，就找不到与重发的FIN对应的连接，最后Server就会收到RST而不是ACK，Server就会以为是连接错误把问题报告给高层。所以，Client不是直接进入CLOSED，而是要保持2MSL,如果在这个时间内又收到了server的关闭请求时可以进行重传，否则说明server已经受到确认包则可以关闭.
+
+
+https://www.zhihu.com/question/36930631
+## TCP拥塞控制
+为了更好对TCP进行拥塞控制，因特网建议标准定义了以下四种算法：慢开始，拥塞避免，快重传，快恢复。
+首先在TCP要求发送端维护两个窗口：
+1） 接收窗口rwnd，接收方根据当前缓存大小锁许诺的最新窗口值。
+2) 拥塞窗口 cwnd ,发送方根据自己估算的网络拥塞程度而设置的窗口值。
+发送窗口的上限是取这两者的最小值。
+慢开始： TCP刚连接好时，先令拥塞窗口cwnd =1 ,在每次收到一个对新报文段的确认时将cwnd加1. Cwnd的大小呈指数增长。
+拥塞避免算法： 当cwnd大于等于慢开始门限ssthresh时，cwnd窗口每次加1而不是加倍。当发送方检测到**超时事件**的发生时，就将慢开始门限设置为当前cwnd的一半，同时将cwnd设置为1. 这样的目的是迅速减少主机发送到网络的分组数，使得发生拥塞的路由器有足够的时间吧队列中积压的分组处理完毕。
+快重传：当发送方连续收到三个重复的ACK报文时，直接重传对方尚未收到的报文段，而不必等待那个报文段设置的重传计时器超时。
+快恢复：当发送端收到连续三个冗余的ACK时，就执行“乘法减小”算法，把慢开始门限ssthresh减半，cwnd设置为慢开始门限减半后的数值（与慢开始不同）。
+
+## TCP滑动窗口与回退N针协议
+滑动窗口：
+发送方都维持一组连续的允许发送的帧的序号称为发送窗口。同时接收方也维持一组连续的允许接收的帧序号，称为接收窗口。发送窗口是用来对发送方进行流量控制，接收窗口是用来控制接收那些数据帧不可以接收那些帧。
+在发送端，收到一个确认帧，发送窗口就向前滑动一个帧位置，当发送窗口没有可以发送的帧时，发送方就停止发送。直到接收方发送的确认帧使发送窗口向前移动。
+在接收端，只有收到数据帧的序号落在接收窗口内才将该帧收下，否则一律丢弃。每收到一个帧后就发送回确认帧。
+
+后退N帧协议
+发送窗口大于1，接收窗口等于1.在后退N帧中，发送方不需要收到上一帧的ACK后才能发送下一帧，而是可以连续发送帧。当接收方检测出失序信息帧后，要求发送方重发最后一个正确接收的帧之后的所有未被确认的帧。源站每发完一帧就要为该帧设置超时计时器，如果在超时时间内没有收到确认帧则进行重发。服务端会采用累积确认的方式，不是每个帧都发确认，可以连续收到好几个正确帧后发回一个确认信息。接收方因为窗口为1，所以必须按序接收数据帧，如果某个序大于当前所期望的序号时就会连续发送3个ACK确认帧，要求客户端重传失序帧。
+
+## TCP的可靠性如何保证
+在TCP的连接中，数据流必须以正确的顺序送达对方。TCP的可靠性是通过顺序编号和确认（ACK）来实现的。TCP在开始传送一个段时，为准备重传而首先将该段插入到发送队列之中，同时启动时钟。其后，如果收到了接受端对该段的ACK信息，就将该段从队列中删去。如果在时钟规定的时间内，ACK未返回，那么就从发送队列中再次送出这个段。TCP在协议中就对数据可靠传输做了保障，握手与断开都需要通讯双方确认，数据传输也需要双方确认成功，在协议中还规定了：分包、重组、重传等规则；而UDP主要是面向不可靠连接的，不能保证数据正确到达目的地。
+
+## Http的报文结构
+http请求由三部分组成，分别是：请求行、消息报头、请求正文
+方法 [空格] URL [空格] 版本
+首部字段名: [空格] 值
+…
+首部字段名: [空格] 值
+[空一行]
+实体主体
+
+HTTP响应也是由三个部分组成，分别是：状态行、消息报头、响应正文
+版本[空格] 状态码 [空格] 短语
+首部字段名: [空格] 值
+…
+首部字段名: [空格] 值
+[空一行]
+实体主体
+更多http内容参考：http://www.cnblogs.com/maanshancss/p/4503385.html
+
+## Http request的几种类型
+HTTP协议中共定义了八种方法或者叫“动作”来表明对Request-URI指定的资源的不同操作方式，具体介绍如下：
+GET：向特定的资源发出请求。
+POST：向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的创建和/或已有资源的修改。
+PUT：向指定资源位置上传其最新内容。
+DELETE：请求服务器删除Request-URI所标识的资源。
+HEAD：请求读取由URL所标志的信息的首部。
+OPTIONS：返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送' * '的请求来测试服务器的功能性。
+TRACE：回显服务器收到的请求，主要用于测试或诊断。
+CONNECT：HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
+
+##  Http1.1和Http1.0的区别
+1)HTTP1.0 是短连接，HTTP1.1是长连接。 HTTP 1.0规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个TCP连接，服务器完成请求处理后立即断开TCP连接，服务器不跟踪每个客户也不记录过去的请求。如果一个html包含多个图片或资源时需要多次与服务器建立连接。 HTTP 1.1支持持久连接，在一个TCP连接上可以传送多个HTTP请求和响应，减少了建立和关闭连接的消耗和延迟。一个包含有许多图像的网页文件的多个请求和应答可以在一个连接中传输，但每个单独的网页文件的请求和应答仍然需要使用各自的连接.HTTP 1.1采用了流水线的持久连接，即客户端不用等待上一次请求结果返回，就可以发出下一次请求，但服务器端必须按照接收到客户端请求的先后顺序依次回送响应结果，以保证客户端能够区分出每次请求的响应内容，这样也显著地减少了整个下载过程所需要的时间。
+2)HTTP 1.0不支持Host请求头字段，WEB浏览器无法使用主机头名来明确表示要访问服务器上的哪个WEB站点，这样就无法使用WEB服务器在同一个IP地址和端口号上配置多个虚拟WEB站点。在HTTP 1.1中增加Host请求头字段后，WEB浏览器可以使用主机头名来明确表示要访问服务器上的哪个WEB站点，这才实现了在一台WEB服务器上可以在同一个IP地址和端口号上使用不同的主机名来创建多个虚拟WEB站点。
+3)HTTP 1.1还提供了与身份认证、状态管理和Cache缓存等机制相关的请求头和响应头
+4)带宽优化。HTTP/1.0中，存在一些浪费带宽的现象，例如客户端只是需要某个对象的一部分，而服务器却将整个对象送过来了。例如，客户端只需要显示一个文档的部分内容，又比如下载大文件时需要支持断点续传功能，而不是在发生断连后不得不重新下载完整的包。
+HTTP/1.1中在请求消息中引入了range头域，它允许只请求资源的某个部分。
+5) HTTP/1.1增加了OPTIONS方法，它允许客户端获取一个服务器支持的方法列表
+
+http://blog.csdn.net/forgotaboutgirl/article/details/6936982
+
+## Http怎么处理长连接
+HTTP1.1和HTTP1.0相比较而言，最大的区别就是增加了持久连接支持。TCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了带宽。
+使用长连接的HTTP协议，会在响应头有加入这行代码：Connection:keep-alive 。在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的 TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立的连接。Keep-Alive不会永久保持连接，它有一个保持时间，可以在不同的服务器软件（如Apache）中设定这个时间。实现长连接要客户端和服务端都支持长连接。
+
+http://www.codeceo.com/article/http-long-connect.html
+
+## Cookie与Session的作用于原理
+会话跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。
+Cookie
+Cookie实际上是一小段的文本信息。客户端请求服务器，如果服务器需要记录该用户状态，就产生一个用户身份标识，然后在响应消息中将该标识号以Cookie的形式传递给浏览器.客户端浏览器会把Cookie保存起来。浏览器在以后每次访问该web服务器时，浏览器把请求的网址连同该Cookie一同提交给服务器。服务器检查该Cookie，以此来辨认用户状态。服务器还可以根据需要修改Cookie的内容. Cookie不能被浏览器共享
+Cookie具有不可跨域名性，例如浏览器访问Google只会携带Google的Cookie，而不会携带Baidu的Cookie。Cookie的maxAge决定着Cookie的有效期，单位为秒（Second）
+**默认情况下,cookie是一个会话级别的,用户退出浏览器后被删除**
+
+Session
+Session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而Session保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。
+如果说Cookie机制是通过检查客户身上的“通行证”来确定客户身份的话，那么Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。
+Session保存在服务器端。为了获得更高的存取速度，服务器一般把Session放在内存里。每个用户都会有一个独立的Session。如果Session内容过于复杂，当大量客户访问服务器时可能会导致内存溢出。因此，Session里的信息应该尽量精简。
+
+session工作原理
+(1)web不会在客户端开始访问它时创建session,在访问特殊的程序并且该程序(servlet)决定与客户端开启会话时,服务器生成一个唯一值,称为Session ID（好像是通过取进程ID的方式取得的）。服务器开辟一块内存，对应于该Session ID。
+(2)服务器再将该Session ID写入浏览器的cookie。
+(3)服务器内有一进程，监视所有Session的活动状况，如果有Session超时或是主动关闭，服务器就释放改内存块。
+(4)当浏览器连入服务器时并请求Session时，服务器就读浏览器Cookie中的Session ID。
+(5)然后，服务检查该Session ID所对应的内存是否有效。
+(6)如果有效，就读出内存中的值。
+(7)如果无效，就建立新的Session。
+
+**tomcat默认设置是30分钟**
+具体设置很简单，方法有三种：
+（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);
+参数900单位是秒，即在没有活动15分钟后，session将失效。设置为-1将永不关闭。
+这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所以如果是在调试程序，应该是修改服务器端时间来测试，而不是客户端。
+（2）也是比较通用的设置session失效时间的方法，就是在项目的web.xml中设置
+<session-config>
+<session-timeout>15</session-timeout>
+</session-config>
+这里的15也就是15分钟失效.
+（3）直接在应用服务器中设置，如果是tomcat，可以在tomcat目录下conf/web.xml中
+找到<session-config>元素，tomcat默认设置是30分钟，只要修改这个值就可以了。
+需要注意的是如果上述三个地方如果都设置了，有个优先级的问题，从高到低：
+（1）-->(2)--->(3)
+
+生命周期:
+1)tomcat默认是30分钟
+2)因为session和cookie有关系，客户端浏览器通过cookie维持该会话，cookie不支持跨浏览器共享，意味着如果把浏览器关该会闭的话该会话就会失效(但服务端还保存着)。因此同一机器的两个浏览器窗口访问服务器时，会生成两个不同的Session。
+
+http://qiusuoge.com/10576.html
+http://blog.csdn.net/colzer/article/details/8686966
+http://www.cnblogs.com/binger/archive/2013/03/19/2970171.html
+
+## 电脑上访问一个网页，整个过程是怎么样的：DNS、HTTP、TCP、OSPF、IP、ARP
+1) 浏览器分析连接指向的页面URL(http://www.baidu.com)
+2) 浏览器向DNS请求www.baidu.com.的IP地址
+3) 域名系统DNS解析出百度官网的服务器IP地址
+4) 浏览器与该服务器建立TCP连接（默认端口80）
+5) 浏览器发出HTTP请求获取指定页面。
+6) 服务器通过HTTP响应把文件对应页面发送给浏览器。
+7) TCP连接释放。
+8) 浏览器将文件进行解析，并将web网页显示给用户。
+
+## get提交和post提交的区别
+1.根据HTTP规范，GET用于信息获取，而且应该是安全的和幂等的。
+　　(1).所谓安全的意味着该操作用于获取信息而非修改信息。换句话说，GET 请求一般不应产生副作用。就是说，它仅仅是获取资源信息，就像数据库查询一样，不会修改，增加数据，不会影响资源的状态。
+　　(2).幂等的意味着对同一URL的多个请求应该返回同样的结果。
+2.根据HTTP规范，POST表示可能修改变服务器上的资源的请求。还是新闻以网站为例，读者对新闻发表自己的评论应该通过POST实现，因为在评论提交后站点的资源已经不同了，或者说资源被修改了。
+3.GET请求的数据会附在URL之后（就是把数据放置在HTTP协议头中），以?分割URL和传输数据，参数之间以&相连.POST把提交的数据则放置在是HTTP包的包体中。
+4.GET安全性较低，POST安全性较高。因为GET在传输过程，数据被放在请求的URL中，而如今现有的很多服务器、代理服务器或者用户代理都会将请求URL记录到日志文件中，然后放在某个地方，这样就可能会有一些隐私的信息被第三方看到。另外，用户也可以在浏览器上直接看到提交的数据，一些系统内部消息将会一同显示在用户面前。
+5.get传送的数据量较小，不能大于2KB。post传送的数据量较大，一般被默认为不受限制。
+6.在FORM（表单）中，Method默认为"GET"
+
+
+幂等（idempotent、idempotence）是一个数学或计算机学概念，常见于抽象代数中。
+　　幂等有一下几种定义：
+　　对于单目运算，如果一个运算对于在范围内的所有的一个数多次进行该运算所得的结果和进行一次该运算所得的结果是一样的，那么我们就称该运算是幂等的。比如绝对值运算就是一个例子，在实数集中，有abs(a)=abs(abs(a))。
+　　对于双目运算，则要求当参与运算的两个值是等值的情况下，如果满足运算结果与参与运算的两个值相等，则称该运算幂等，如求两个数的最大值的函数，有在在实数集中幂等，即max(x,x) = x。
+详见: http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html
+http://www.cnblogs.com/skynet/archive/2010/05/18/1738301.html
+
+## https如何加密的
+HTTPS介绍：
+HTTPS(Secure Hypertext Transfer Protocol)安全超文本传输协议 它是一个安全通信通道，它基于HTTP开发，用于在客户计算机和服务器之间交换信息。**它使用安全套接字层(SSL)进行信息交换**，简单来说它是HTTP的安全版。 它是由Netscape开发并内置于其浏览器中，使用SSL在发送方把原始数据进行加密，然后在接受方进行解密保证数据的安全性．然而，加密和解密过程需要耗费系统大量的开销，严重降低机器的性能.
+HTTPS实际上就是SSL over HTTP，它使用默认端口**443**，而不是像HTTP那样使用端口80来和TCP/IP进行通信。HTTPS协议使用SSL在发送方把原始数据进行加密，然 后在接受方进行解密，加密和解密需要发送方和接受方通过交换共知的密钥来实现，因此，所传送的数据不容易被网络黑客截获和解密.然而，加密和解密过程需要耗费系统大量的开销，严重降低机器的性能，相关测试数据表明使用HTTPS协议传输数据的工作效率只有使用HTTP协议传输的十分之一。
+
+如何实现加密：（其实就是sssl的交互过程）
+HTTPS其实是有两部分组成：HTTP + SSL / TLS，也就是在HTTP上又加了一层处理加密信息的模块。服务端和客户端的信息传输都会通过TLS进行加密，所以传输的数据都是加密后的数据。具体是如何进行加密，解密，验证的
+
+http://blog.csdn.net/binyao02123202/article/details/8049446
+http://www.codeceo.com/article/why-http-better-than-https.html
+
+## http和https的区别
+1. https协议需要到ca申请证书，一般免费证书很少，需要交费。
+2. http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议 http和https使用的是完全不同的连接方式用的端口也不一样：前者是80，后者是443。
+3. http的连接很简单，是无状态的 HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全 HTTPS解决的问题.
+http://www.admin5.com/article/20150708/608526.shtml
+
+## SSL协议及完整交互过程
+SSL是Netscape公司所提出的安全保密协议，在浏览器(如Internet Explorer、Netscape Navigator)和Web服务器(如Netscape的Netscape Enterprise Server、ColdFusion Server等等)之间构造安全通道来进行数据传输，SSL运行在TCP/IP层之上、应用层之下，为应用程序提供加密数据通道，它采用了RC4、MD5 以及RSA等加密算法，使用40 位的密钥，适用于商业信息的加密。
+
+开始加密通信之前，客户端和服务器首先必须建立连接和交换参数，这个过程叫做握手（handshake）。
+**1 客户端发出请求（ClientHello）**
+首先，客户端（通常是浏览器）先向服务器发出加密通信的请求，这被叫做ClientHello请求。在这一步，客户端主要向服务器提供以下信息。
+（1） 支持的协议版本，比如TLS 1.0版。
+（2） 一个客户端生成的随机数，稍后用于生成"对话密钥"。
+（3） 支持的加密方法，比如RSA公钥加密。
+（4） 支持的压缩方法。
+
+**4.2 服务器回应（SeverHello）**
+服务器收到客户端请求后，向客户端发出回应，这叫做SeverHello。服务器的回应包含以下内容：
+（1） 确认使用的加密通信协议版本，比如TLS 1.0版本。如果浏览器与服务器支持的版本不一致，服务器关闭加密通信。
+（2） 一个服务器生成的随机数，稍后用于生成"对话密钥"。
+（3） 确认使用的加密方法，比如RSA公钥加密。
+（4） 服务器证书。（公钥）
+**4.3 客户端回应**
+客户端收到服务器回应以后，首先验证服务器证书。如果证书不是可信机构颁布、或者证书中的域名与实际域名不一致、或者证书已经过期，就会向访问者显示一个警告，由其选择是否还要继续通信。
+如果证书没有问题，客户端就会从证书中取出服务器的公钥。然后，向服务器发送下面三项信息。
+（1） 一个随机数。该随机数用服务器公钥加密，防止被窃听。
+（2） 编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
+（3） 客户端握手结束通知，表示客户端的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供服务器校验。
+上面第一项的随机数，是整个握手阶段出现的第三个随机数，又称"pre-master key"。有了它以后，客户端和服务器就同时有了三个随机数，接着双方就用事先商定的加密方法，各自生成本次会话所用的同一把"会话密钥"。（会话秘钥是采用对称加密方式，而这里的公钥是采用非对称加密）
+**4 服务器的最后回应**
+服务器通过私钥解密收到客户端的第三个随机数pre-master key之后，计算生成本次会话所用的"会话密钥"。然后，向客户端最后发送下面信息。
+（1）编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
+（2）服务器握手结束通知，表示服务器的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供客户端校验。
+至此，整个握手阶段全部结束。接下来，客户端与服务器进入加密通信，就完全是使用普通的HTTP协议，只不过用"会话密钥"加密内容。
+
+至于为什么一定要用三个随机数，来生成"会话密钥"，dog250解释得很好：
+"不管是客户端还是服务器，都需要随机数，这样生成的密钥才不会每次都一样。由于SSL协议中证书是静态的，因此十分有必要引入一种随机因素来保证协商出来的密钥的随机性。
+对于RSA密钥交换算法来说，pre-master-key本身就是一个随机数，再加上hello消息中的随机，三个随机数通过一个密钥导出器最终导出一个对称密钥。
+pre master的存在在于SSL协议不信任每个主机都能产生完全随机的随机数，如果随机数不随机，那么pre master secret就有可能被猜出来，那么仅适用pre master secret作为密钥就不合适了，因此必须引入新的随机因素，那么客户端和服务器加上pre master secret三个随机数一同生成的密钥就不容易被猜出了，一个伪随机可能完全不随机，可是是三个伪随机就十分接近随机了，每增加一个自由度，随机性增加的可不是一。"
+
+http://limboy.me/tech/2011/02/19/https-workflow.html
+http://www.ruanyifeng.com/blog/2014/02/ssl_tls.html
+http://www.ruanyifeng.com/blog/2014/09/illustration-ssl.html
+http://kb.cnblogs.com/page/162080/
+
+## https处理的一个过程，对称加密和非对称加密（参考上一条，这一条就是通俗的表示）
+1. SSL原理很简单。当你的浏览器向服务器请求一个安全的网页(通常是 https://)
+2. 服务器就把它的证书和公匙发回来
+3. 浏览器检查证书是不是由可以信赖的机构颁发的，确认证书有效和此证书是此网站的。
+4. 浏览器使用公钥加密了一个随机对称密钥，包括加密的URL一起发送到服务器。
+5. 服务器用自己的私匙解密了你发送的钥匙。然后用这把对称加密的钥匙给你请求的URL链接解密。
+6. 服务器用你发的对称钥匙给你请求的网页加密。你也有相同的钥匙就可以解密发回来的网页了
+
+加密算法绝大部分都属于以下两种加密类型之一：
+对称加密：加密解密用的是同样的“钥匙”
+非对称加密：加密解密用的是不同的“钥匙”
+
+对称加密
+Alice 在盒子里放有信息，盒子上有挂锁，她有钥匙。通过邮局她把这个盒子寄给Bob。Bob收到盒子后，用相同的钥匙打开盒子（钥匙之前就得到了，可能是Alice面对面给他的）。然后Bob可以用同样的方法回复。
+
+非对称加密
+Bob和Alice各有自己的盒子。Alice要跟Bob秘密通信，她先让Bob把开着的盒子通过邮局发给她。Alice拿到盒子后放入信息锁上，然后发给Bob。Bob就可以用他自己的钥匙打开了。回复的话就用同样的方法。
+非对称算法在加密和解密时用的是不同的钥匙。信息接受者有两把钥匙：一把“公匙”，一把“私匙”。公匙是给信息发送者用来加密的，私匙是自己用来解密的。这样最大的好处是：不必通过不安全的渠道发送私密的东西。公匙本来就是给别人用的，不用藏好。你的私匙在你产生私匙的电脑里保存着。
+
+http://article.yeeyan.org/view/90729/174903/
+
+## Http和https的区别
+ - http是HTTP协议运行在TCP之上。所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份
+ - https是HTTP运行在SSL/TLS之上，SSL/TLS运行在TCP之上。所有传输的内容都经过加密，加密采用对
+ - 加密，但对称加密的密钥用服务器方的证书进行了非对称加密。此外客户端可以验证服务器端的身份
+ - 如果配置了客户端验证，服务器方也可以验证客户端的身份。
+ - https协议需要到ca申请证书，一般免费证书很少，需要交费。
+ - http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议
+ - http和https使用的是完全不同的连接方式用的端口也不一样,前者是80,后者是443。
+ - http的连接很简单,是无状态的
+ - HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议 要比http协议安全
+
+https://github.com/Wl201314/MartinBlog/tree/master/Blog/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9F%BA%E7%A1%80
+## DNS域名系统，简单描述其工作原理。
+域名系统DNS是因特网使用的命名系统，用于把便于人们记忆的含有特定含义的主机名转换为便于机器处理的IP地址。DNS系统采用C/S模式，其协议运行在UDP上，使用53号端口。从概念上讲DNS可以分为3个部分：层次域名空间，域名服务器和解析器。
+
+域名解析是把域名映射成IP地址或者把IP地址映射成域名的过程。域名解析有两种方式：递归查询和迭代查询。
+递归查询：如果本地主机询问的本地域名服务器不知道被查询的域名IP地址，那么**本地域名服务器**就以DNS客户的身份，向**根域名服务器**继续发出查询请求报文，而不是自己进行下一步非查询。根域名服务器会继续向**顶级域名服务器**查询请求，如果存在则直接返回给根服务器，否则顶级域名服务器向对应的**权限域名服务器**查询。是一种递归的查询方式。
+
+迭代查询：如果本地主机询问的本地域名服务器不知道被查询的域名IP地址，那么本地域名服务器就以DNS客户的身份，向根域名服务器继续发出查询请求报文。跟服务器收到请求报文时，要么给出所有查询的IP地址，要么告诉本地域名服务器下一步需要查询的顶级域名服务器。然后本地服务器向这个顶级域名服务器进行后续的查询。同样的顶级域名服务器收到查询报文后，要么给出所要查询的IP地址，要么告诉本地域名服务器下一步应该查找那个权限域名服务器。
+
+## 面向连接和非面向连接的服务的特点是什么？
+面向连接的服务：通信双方进行通信之前，必须先建立连接，在通信过程中，整个连接情况一直都是被实时地监控和管理。当通信结束后，则应释放这个连接。
+无连接服务：两个实体之间的通信不需要先建立好连接，需要通信的时候，直接将信息发送到”网络”中，让该信息的传递在网上尽力而为地往目的地传送。
+
+## 端口及对应的服务？
+FTP 21    SSH 22    telnet 23    SMTP 25   Domain(域名服务器) 53    HTTP 80
+POP3 110   NTP（网络时间协议）123    MySQL数据库服务3306  https 443 SNMP(161) TFTP(69)
+Shell或 cmd 514     POP-2  109    SQL Server 1433
+
+## 各种协议
+ICMP协议： 因特网控制报文协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。
+TFTP协议： 是TCP/IP协议族中的一个用来在客户机与服务器之间进行简单文件传输的协议，提供不复杂、开销不大的文件传输服务。
+HTTP协议： 超文本传输协议，是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。
+DHCP协议： 动态主机配置协议，是一种让系统得以连接到网络上，并获取所需要的配置参数手段。
+NAT协议：网络地址转换属接入广域网(WAN)技术，是一种将私有（保留）地址转化为合法IP地址的转换技术，
+DHCP协议：一个局域网的网络协议，使用UDP协议工作，用途：给内部网络或网络服务供应商自动分配IP地址，给用户或者内部网络管理员作为对所有计算机作中央管理的手段。
+
+## Ping的整个过程
+同一个局域网中：
+1、Pc1在应用层发起个目标IP位IP2的Ping请求。
+2、传输层接到上层请求的数据，将数据分段并加上UDP报头。下传到Internet层。
+3、 网际层接收来处上层的数据后，根据ICMP协议进行封装，添加PC1的IP为源IP为和PC2IP为目标IP后封装成数据包。下传到网络接口层。
+4、网络接口层接收数据包后，进行封装，源MAC地址为PC1的MAC地址，目标MAC地址则查询自己的ARP缓存表获取。如果PC1 arp缓存表中没有目标IP对应的MAC地址，则PC1发出一个ARP广播报文。ARP报文中源MAC地址为Pc1mac地址，源IP地址为pc1 IP，所要请求的是PC2的IP对应的mac地址。
+5、PC2收到ARP广播后，进行解封装，发现所请求的MAC地址是自己的。则PC2将PC1的mac地址写入arp缓存表中。然后向PC1发送一个 ARP应答单播。该单播消息包括目标IP为PC1ip，目标Mac为pc1mac地址，源IP为PC2的IP，源Mac为pc2的Mac。
+6、Pc1接收到PC2的arp应答报文后，将Pc2的MAC地址存入arp缓存中，并将Pc2的Mac地址作为目标地址封装到数据帧中。发给下层进行网络传输。
+7、PC2接收这个帧后，在网络接口层查看目标mac地址是否指向自己。是，PC2则将帧头去掉，向上层传输。
+8、Pc2网际层接收到这个信息包，查看包头，发现目标IP和自己匹配，则解封装，将数据向上层传输。
+9、传输层接收来自下层的Ping请求的UDP报文，则去掉UDP报头，向应用层传送。
+10、应用层收到ping请求后，发送一个PIng回应报文给PC1
+http://blog.chinaunix.net/uid-26758209-id-3146224.html
+
+##  ICMP协议：
+1) ICMP允许主机或路由报告差错情况和提供有关异常情况。ICMP是因特网的标准协议，但ICMP不是高层协议，而是IP层的协议。通常ICMP报文被IP层或更高层协议（TCP或UDP）使用。一些ICMP报文把差错报文返回给用户进程。
+2) ICMP报文作为IP层数据报的数据，加上数据报的首部，组成数据报发送出去。
+3) ICMP报文的种类有两种，即ICMP差错报告报文和ICMP询问报文。
+
+差错报告
+ICMP差错报告报文共有5种：
+ 终点不可达：终点不可达分为:网络不可达，主机不可达，协议不可达，端口不可达，需要分片但DF比特已置为1，以及源路由失败等六种情况，其代码字段分别置为0至5。当出现以上六种情况时就向源站发送终点不可达报文。
+说明：
+端口不可达：UDP的规则之一是：如果收到UDP数据报而且目的端口与某个正在使用的进程不相符，那么UDP返回一个ICMP不可达报文。
+源站抑制：当路由器或主机由于拥塞而丢弃数据报时，就向源站发送源站抑制报文，使源站知道应当将数据报的发送速率放慢。
+时间超过：当路由器收到生存时间为零的数据报时，除丢弃该数据报外，还要向源站发送时间超过报文。当目的站在预先规定的时间内不能收到一个数据报的全部数据报片时，就将已收到的数据报片都丢弃，并向源站发送时间超过报文。
+参数问题：当路由器或目的主机收到的数据报的首部中的字段的值不正确时，就丢弃该数据报，并向源站发送参数问题报文。
+改变路由（重定向）路由器将改变路由报文发送给主机，让主机知道下次应将数据报发送给另外的路由器。
+
+询问报文
+ICMP询问报文有四种
+**回送请求和回答**，ICMP回送请求报文是由主机或路由器向一个特定的目的主机发出的询问。收到此报文的机器必须给源主机发送ICMP回送应答报文。这种询问报文用来测试目的站是否可达以及了解其有关状态
+**时间戳请求和回答**：ICMP时间戳请求允许系统向另一个系统查询当前的时间。该ICMP报文的好处是它提供了毫秒级的分辨率，而利用其他方法从别的主机获取的时间只能提供秒级的分辨率。请求端填写发起时间，然后发送报文。应答系统收到请求报文时填写接收时间戳，在发送应答时填写发送时间戳。大多数的实现是把后面两个字段都设成相同的值。
+**掩码地址请求和回答**：主机使用ICMP地址掩码请求报文可向子网掩码服务器得到某个接口的地址掩码。
+**路由器询问和通过**：主机使用ICMP路由器询问和通过报文可了解连接在本网络上的路由器是否正常工作。主机将路由器询问报文进行广播（或多播）。收到询问报文的一个或几个路由器就使用路由器通过报文广播其路由选择信息
+
+## C/S模式下使用socket通信，几个关键函数
+
+## 知识点：
+1) SSP通过七号信令网实现与SAU的连接，而SCP与SAU之间通过TCP/IP协议连接。
+2) 重组发生在目的主机，分片发生在路由器上
diff --git "a/000 - 1 Computer Basics/04 \344\272\222\350\201\224\347\275\221\345\215\217\350\256\256.txt" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/04 \344\272\222\350\201\224\347\275\221\345\215\217\350\256\256.txt"
similarity index 100%
rename from "000 - 1 Computer Basics/04 \344\272\222\350\201\224\347\275\221\345\215\217\350\256\256.txt"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/04 \344\272\222\350\201\224\347\275\221\345\215\217\350\256\256.txt"
diff --git a/000 - 1 Computer Basics/Network/Http_Code.md "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/Http_Code.md"
similarity index 100%
rename from 000 - 1 Computer Basics/Network/Http_Code.md
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/Http_Code.md"
diff --git "a/000 - 1 Computer Basics/Network/Http\345\215\217\350\256\256.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/Http\345\215\217\350\256\256.md"
similarity index 100%
rename from "000 - 1 Computer Basics/Network/Http\345\215\217\350\256\256.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/Http\345\215\217\350\256\256.md"
diff --git a/000 - 1 Computer Basics/Network/Socket.md "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/Socket.md"
similarity index 100%
rename from 000 - 1 Computer Basics/Network/Socket.md
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/Socket.md"
diff --git "a/000 - 1 Computer Basics/Network/TCP\344\270\216UDP.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/TCP\344\270\216UDP.md"
similarity index 100%
rename from "000 - 1 Computer Basics/Network/TCP\344\270\216UDP.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/TCP\344\270\216UDP.md"
diff --git "a/000 - 1 Computer Basics/Network/\344\273\200\344\271\210\346\230\257SSL.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\344\273\200\344\271\210\346\230\257SSL.md"
similarity index 100%
rename from "000 - 1 Computer Basics/Network/\344\273\200\344\271\210\346\230\257SSL.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\344\273\200\344\271\210\346\230\257SSL.md"
diff --git "a/000 - 1 Computer Basics/Network/\345\257\271\344\272\216Ping\347\232\204\350\277\207\347\250\213\357\274\214\344\275\240\347\234\237\347\232\204\344\272\206\350\247\243\345\220\227\357\274\237.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\345\257\271\344\272\216Ping\347\232\204\350\277\207\347\250\213\357\274\214\344\275\240\347\234\237\347\232\204\344\272\206\350\247\243\345\220\227\357\274\237.md"
similarity index 100%
rename from "000 - 1 Computer Basics/Network/\345\257\271\344\272\216Ping\347\232\204\350\277\207\347\250\213\357\274\214\344\275\240\347\234\237\347\232\204\344\272\206\350\247\243\345\220\227\357\274\237.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\345\257\271\344\272\216Ping\347\232\204\350\277\207\347\250\213\357\274\214\344\275\240\347\234\237\347\232\204\344\272\206\350\247\243\345\220\227\357\274\237.md"
diff --git "a/000 - 1 Computer Basics/Network/\347\275\221\351\241\265\350\257\267\346\261\202\350\277\207\347\250\213.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\347\275\221\351\241\265\350\257\267\346\261\202\350\277\207\347\250\213.md"
similarity index 97%
rename from "000 - 1 Computer Basics/Network/\347\275\221\351\241\265\350\257\267\346\261\202\350\277\207\347\250\213.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\347\275\221\351\241\265\350\257\267\346\261\202\350\277\207\347\250\213.md"
index 0821e039..e810c0b0 100644
--- "a/000 - 1 Computer Basics/Network/\347\275\221\351\241\265\350\257\267\346\261\202\350\277\207\347\250\213.md"	
+++ "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\347\275\221\351\241\265\350\257\267\346\261\202\350\277\207\347\250\213.md"	
@@ -1,9 +1,9 @@
-1 查询域名对应的IP地址 （**DNS** Domain Name System）
-2 向目标IP TCP三次握手建立连接
-3 发送Http请求
-4 服务器处理请求（**CDN** Content Delivery Network）
-5 响应
-6 浏览器渲染显示
-
-ARP  地址解析协议   IP MAC对应关系表
-RARP 反地址解析协议
+1 查询域名对应的IP地址 （**DNS** Domain Name System）
+2 向目标IP TCP三次握手建立连接
+3 发送Http请求
+4 服务器处理请求（**CDN** Content Delivery Network）
+5 响应
+6 浏览器渲染显示
+
+ARP  地址解析协议   IP MAC对应关系表
+RARP 反地址解析协议
diff --git "a/000 - 1 Computer Basics/Network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\237\272\347\241\200\346\261\207\346\200\273.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\237\272\347\241\200\346\261\207\346\200\273.md"
similarity index 100%
rename from "000 - 1 Computer Basics/Network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\237\272\347\241\200\346\261\207\346\200\273.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/Network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\237\272\347\241\200\346\261\207\346\200\273.md"
diff --git "a/000 - 1 Computer Basics/OperatingSystem/Linux\347\263\273\347\273\237\347\232\204IPC.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/OperatingSystem/Linux\347\263\273\347\273\237\347\232\204IPC.md"
similarity index 100%
rename from "000 - 1 Computer Basics/OperatingSystem/Linux\347\263\273\347\273\237\347\232\204IPC.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/OperatingSystem/Linux\347\263\273\347\273\237\347\232\204IPC.md"
diff --git "a/000 - 1 Computer Basics/OperatingSystem/\346\223\215\344\275\234\347\263\273\347\273\237.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/OperatingSystem/\346\223\215\344\275\234\347\263\273\347\273\237.md"
similarity index 100%
rename from "000 - 1 Computer Basics/OperatingSystem/\346\223\215\344\275\234\347\263\273\347\273\237.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/OperatingSystem/\346\223\215\344\275\234\347\263\273\347\273\237.md"
diff --git a/000 - 1 Computer Basics/img/2843224-46fb935cd31addbd.png "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/img/2843224-46fb935cd31addbd.png"
similarity index 100%
rename from 000 - 1 Computer Basics/img/2843224-46fb935cd31addbd.png
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/img/2843224-46fb935cd31addbd.png"
diff --git a/000 - 1 Computer Basics/img/2843224-56f2056f0b36009f.png "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/img/2843224-56f2056f0b36009f.png"
similarity index 100%
rename from 000 - 1 Computer Basics/img/2843224-56f2056f0b36009f.png
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/img/2843224-56f2056f0b36009f.png"
diff --git a/000 - 1 Computer Basics/img/2843224-e0854f19c817c83c.png "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/img/2843224-e0854f19c817c83c.png"
similarity index 100%
rename from 000 - 1 Computer Basics/img/2843224-e0854f19c817c83c.png
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/img/2843224-e0854f19c817c83c.png"
diff --git a/000 - 1 Computer Basics/product.md "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/product.md"
similarity index 100%
rename from 000 - 1 Computer Basics/product.md
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/product.md"
diff --git "a/000 - 1 Computer Basics/\345\237\272\347\241\200.txt" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\345\237\272\347\241\200.txt"
similarity index 100%
rename from "000 - 1 Computer Basics/\345\237\272\347\241\200.txt"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\345\237\272\347\241\200.txt"
diff --git "a/000 - 1 Computer Basics/\347\241\254\347\233\230\345\237\272\346\234\254\347\237\245\350\257\206\357\274\210\347\243\201\345\244\264\343\200\201\347\243\201\351\201\223\343\200\201\346\211\207\345\214\272\343\200\201\346\237\261\351\235\242\357\274\211.md" "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\347\241\254\347\233\230\345\237\272\346\234\254\347\237\245\350\257\206\357\274\210\347\243\201\345\244\264\343\200\201\347\243\201\351\201\223\343\200\201\346\211\207\345\214\272\343\200\201\346\237\261\351\235\242\357\274\211.md"
similarity index 98%
rename from "000 - 1 Computer Basics/\347\241\254\347\233\230\345\237\272\346\234\254\347\237\245\350\257\206\357\274\210\347\243\201\345\244\264\343\200\201\347\243\201\351\201\223\343\200\201\346\211\207\345\214\272\343\200\201\346\237\261\351\235\242\357\274\211.md"
rename to "000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\347\241\254\347\233\230\345\237\272\346\234\254\347\237\245\350\257\206\357\274\210\347\243\201\345\244\264\343\200\201\347\243\201\351\201\223\343\200\201\346\211\207\345\214\272\343\200\201\346\237\261\351\235\242\357\274\211.md"
index ef03ef16..64fe6aae 100644
--- "a/000 - 1 Computer Basics/\347\241\254\347\233\230\345\237\272\346\234\254\347\237\245\350\257\206\357\274\210\347\243\201\345\244\264\343\200\201\347\243\201\351\201\223\343\200\201\346\211\207\345\214\272\343\200\201\346\237\261\351\235\242\357\274\211.md"	
+++ "b/000 - 1 Computer Basics \350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\347\241\254\347\233\230\345\237\272\346\234\254\347\237\245\350\257\206\357\274\210\347\243\201\345\244\264\343\200\201\347\243\201\351\201\223\343\200\201\346\211\207\345\214\272\343\200\201\346\237\261\351\235\242\357\274\211.md"	
@@ -1,64 +1,64 @@
-https://www.jianshu.com/p/9aa66f634ed6
-### 概述
-盘片（platter）
-磁头（head）
-磁道（track）
-扇区（sector）
-柱面（cylinder）
-
-### 盘片 片面 和 磁头
-硬盘中一般会有多个盘片组成，每个盘片包含两个面，每个盘面都对应地有一个读/写磁头。受到硬盘整体体积和生产成本的限制，盘片数量都受到限制，一般都在5片以内。盘片的编号自下向上从0开始，如最下边的盘片有0面和1面，再上一个盘片就编号为2面和3面。
-如下图：
-
-<img src="img/2843224-46fb935cd31addbd.png">
-
-
-### 扇区 和 磁道
-下图显示的是一个盘面，盘面中一圈圈灰色同心圆为一条条磁道，从圆心向外画直线，可以将磁道划分为若干个弧段，每个磁道上一个弧段被称之为一个扇区（图践绿色部分）。扇区是磁盘的最小组成单元，通常是512字节。（由于不断提高磁盘的大小，部分厂商设定每个扇区的大小是4096字节）
-
-<img src="img/2843224-56f2056f0b36009f.png">
-
-
-### 磁头 和 柱面
-硬盘通常由重叠的一组盘片构成，每个盘面都被划分为数目相等的磁道，并从外缘的“0”开始编号，具有相同编号的磁道形成一个圆柱，称之为磁盘的柱面。磁盘的柱面数与一个盘面上的磁道数是相等的。由于每个盘面都有自己的磁头，因此，盘面数等于总的磁头数。 如下图
-
-<img src="img/2843224-e0854f19c817c83c.png">
-
-
-### 磁盘容量计算
-
-存储容量 ＝ 磁头数 × 磁道(柱面)数 × 每道扇区数 × 每扇区字节数
-
-图3中磁盘是一个 3个圆盘6个磁头，7个柱面（每个盘片7个磁道） 的磁盘，图3中每条磁道有12个扇区，所以此磁盘的容量为：
-
-存储容量 6 * 7 * 12 * 512 = 258048
-
-    **每个磁道的扇区数一样是说的老的硬盘，外圈的密度小，内圈的密度大，每圈可存储的数据量是一样的。新的硬盘数据的密度都一致，这样磁道的周长越长，扇区就越多，存储的数据量就越大。**
-
-### 磁盘读取响应时间
-寻道时间：磁头从开始移动到数据所在磁道所需要的时间，寻道时间越短，I/O操作越快，目前磁盘的平均寻道时间一般在3－15ms，一般都在10ms左右。
-旋转延迟：盘片旋转将请求数据所在扇区移至读写磁头下方所需要的时间，旋转延迟取决于磁盘转速。普通硬盘一般都是7200rpm，慢的5400rpm。
-数据传输时间：完成传输所请求的数据所需要的时间。
-小结一下：从上面的指标来看、其实最重要的、或者说、我们最关心的应该只有两个：寻道时间；旋转延迟。
-读写一次磁盘信息所需的时间可分解为：寻道时间、延迟时间、传输时间。为提高磁盘传输效率，软件应着重考虑减少寻道时间和延迟时间。
-
-### 块/簇
-概述
-磁盘块/簇（虚拟出来的）。 块是操作系统中最小的逻辑存储单位。操作系统与磁盘打交道的最小单位是磁盘块。
-通俗的来讲，在Windows下如NTFS等文件系统中叫做簇；在Linux下如Ext4等文件系统中叫做块（block）。每个簇或者块可以包括2、4、8、16、32、64…2的n次方个扇区。
-
-### 为什么存在磁盘块？
-读取方便：由于扇区的数量比较小，数目众多在寻址时比较困难，所以操作系统就将相邻的扇区组合在一起，形成一个块，再对块进行整体的操作。
-
-分离对底层的依赖：操作系统忽略对底层物理存储结构的设计。通过虚拟出来磁盘块的概念，在系统中认为块是最小的单位。
-
-### page
-操作系统经常与内存和硬盘这两种存储设备进行通信，类似于“块”的概念，都需要一种虚拟的基本单位。所以，与内存操作，是虚拟一个页的概念来作为最小单位。与硬盘打交道，就是以块为最小单位。
-
-### 扇区、块/簇、page的关系
-
-扇区： 硬盘的最小读写单元
-块/簇： 是操作系统针对硬盘读写的最小单元
-page： 是内存与操作系统之间操作的最小单元。
-
-扇区 <= 块/簇 <= page
+https://www.jianshu.com/p/9aa66f634ed6
+### 概述
+盘片（platter）
+磁头（head）
+磁道（track）
+扇区（sector）
+柱面（cylinder）
+
+### 盘片 片面 和 磁头
+硬盘中一般会有多个盘片组成，每个盘片包含两个面，每个盘面都对应地有一个读/写磁头。受到硬盘整体体积和生产成本的限制，盘片数量都受到限制，一般都在5片以内。盘片的编号自下向上从0开始，如最下边的盘片有0面和1面，再上一个盘片就编号为2面和3面。
+如下图：
+
+<img src="img/2843224-46fb935cd31addbd.png">
+
+
+### 扇区 和 磁道
+下图显示的是一个盘面，盘面中一圈圈灰色同心圆为一条条磁道，从圆心向外画直线，可以将磁道划分为若干个弧段，每个磁道上一个弧段被称之为一个扇区（图践绿色部分）。扇区是磁盘的最小组成单元，通常是512字节。（由于不断提高磁盘的大小，部分厂商设定每个扇区的大小是4096字节）
+
+<img src="img/2843224-56f2056f0b36009f.png">
+
+
+### 磁头 和 柱面
+硬盘通常由重叠的一组盘片构成，每个盘面都被划分为数目相等的磁道，并从外缘的“0”开始编号，具有相同编号的磁道形成一个圆柱，称之为磁盘的柱面。磁盘的柱面数与一个盘面上的磁道数是相等的。由于每个盘面都有自己的磁头，因此，盘面数等于总的磁头数。 如下图
+
+<img src="img/2843224-e0854f19c817c83c.png">
+
+
+### 磁盘容量计算
+
+存储容量 ＝ 磁头数 × 磁道(柱面)数 × 每道扇区数 × 每扇区字节数
+
+图3中磁盘是一个 3个圆盘6个磁头，7个柱面（每个盘片7个磁道） 的磁盘，图3中每条磁道有12个扇区，所以此磁盘的容量为：
+
+存储容量 6 * 7 * 12 * 512 = 258048
+
+    **每个磁道的扇区数一样是说的老的硬盘，外圈的密度小，内圈的密度大，每圈可存储的数据量是一样的。新的硬盘数据的密度都一致，这样磁道的周长越长，扇区就越多，存储的数据量就越大。**
+
+### 磁盘读取响应时间
+寻道时间：磁头从开始移动到数据所在磁道所需要的时间，寻道时间越短，I/O操作越快，目前磁盘的平均寻道时间一般在3－15ms，一般都在10ms左右。
+旋转延迟：盘片旋转将请求数据所在扇区移至读写磁头下方所需要的时间，旋转延迟取决于磁盘转速。普通硬盘一般都是7200rpm，慢的5400rpm。
+数据传输时间：完成传输所请求的数据所需要的时间。
+小结一下：从上面的指标来看、其实最重要的、或者说、我们最关心的应该只有两个：寻道时间；旋转延迟。
+读写一次磁盘信息所需的时间可分解为：寻道时间、延迟时间、传输时间。为提高磁盘传输效率，软件应着重考虑减少寻道时间和延迟时间。
+
+### 块/簇
+概述
+磁盘块/簇（虚拟出来的）。 块是操作系统中最小的逻辑存储单位。操作系统与磁盘打交道的最小单位是磁盘块。
+通俗的来讲，在Windows下如NTFS等文件系统中叫做簇；在Linux下如Ext4等文件系统中叫做块（block）。每个簇或者块可以包括2、4、8、16、32、64…2的n次方个扇区。
+
+### 为什么存在磁盘块？
+读取方便：由于扇区的数量比较小，数目众多在寻址时比较困难，所以操作系统就将相邻的扇区组合在一起，形成一个块，再对块进行整体的操作。
+
+分离对底层的依赖：操作系统忽略对底层物理存储结构的设计。通过虚拟出来磁盘块的概念，在系统中认为块是最小的单位。
+
+### page
+操作系统经常与内存和硬盘这两种存储设备进行通信，类似于“块”的概念，都需要一种虚拟的基本单位。所以，与内存操作，是虚拟一个页的概念来作为最小单位。与硬盘打交道，就是以块为最小单位。
+
+### 扇区、块/簇、page的关系
+
+扇区： 硬盘的最小读写单元
+块/簇： 是操作系统针对硬盘读写的最小单元
+page： 是内存与操作系统之间操作的最小单元。
+
+扇区 <= 块/簇 <= page
diff --git a/000 - 2 Data & Algorithm/Algorithm/LeetCode/two-sum.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/LeetCode/two-sum.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Algorithm/LeetCode/two-sum.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/LeetCode/two-sum.md"
diff --git a/000 - 2 Data & Algorithm/Algorithm/LeetCode/zigzag-conversion.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/LeetCode/zigzag-conversion.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Algorithm/LeetCode/zigzag-conversion.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/LeetCode/zigzag-conversion.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Lookup/\346\212\230\345\215\212\346\237\245\346\211\276.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Lookup/\346\212\230\345\215\212\346\237\245\346\211\276.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Lookup/\346\212\230\345\215\212\346\237\245\346\211\276.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Lookup/\346\212\230\345\215\212\346\237\245\346\211\276.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Lookup/\351\241\272\345\272\217\346\237\245\346\211\276.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Lookup/\351\241\272\345\272\217\346\237\245\346\211\276.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Lookup/\351\241\272\345\272\217\346\237\245\346\211\276.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Lookup/\351\241\272\345\272\217\346\237\245\346\211\276.md"
diff --git a/000 - 2 Data & Algorithm/Algorithm/README.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/README.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Algorithm/README.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/README.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Sort/\345\206\222\346\263\241\346\216\222\345\272\217.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\345\206\222\346\263\241\346\216\222\345\272\217.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Sort/\345\206\222\346\263\241\346\216\222\345\272\217.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\345\206\222\346\263\241\346\216\222\345\272\217.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Sort/\345\275\222\345\271\266\346\216\222\345\272\217.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\345\275\222\345\271\266\346\216\222\345\272\217.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Sort/\345\275\222\345\271\266\346\216\222\345\272\217.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\345\275\222\345\271\266\346\216\222\345\272\217.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Sort/\345\277\253\351\200\237\346\216\222\345\272\217.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\345\277\253\351\200\237\346\216\222\345\272\217.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Sort/\345\277\253\351\200\237\346\216\222\345\272\217.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\345\277\253\351\200\237\346\216\222\345\272\217.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Sort/\346\216\222\345\272\217.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\346\216\222\345\272\217.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Sort/\346\216\222\345\272\217.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\346\216\222\345\272\217.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Sort/\351\200\211\346\213\251\346\216\222\345\272\217.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\351\200\211\346\213\251\346\216\222\345\272\217.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Sort/\351\200\211\346\213\251\346\216\222\345\272\217.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\351\200\211\346\213\251\346\216\222\345\272\217.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/Sort/\351\235\242\350\257\225\344\270\255\347\232\204 10 \345\244\247\346\216\222\345\272\217\347\256\227\346\263\225\346\200\273\347\273\223.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\351\235\242\350\257\225\344\270\255\347\232\204 10 \345\244\247\346\216\222\345\272\217\347\256\227\346\263\225\346\200\273\347\273\223.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/Sort/\351\235\242\350\257\225\344\270\255\347\232\204 10 \345\244\247\346\216\222\345\272\217\347\256\227\346\263\225\346\200\273\347\273\223.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/Sort/\351\235\242\350\257\225\344\270\255\347\232\204 10 \345\244\247\346\216\222\345\272\217\347\256\227\346\263\225\346\200\273\347\273\223.md"
diff --git a/000 - 2 Data & Algorithm/Algorithm/section01.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/section01.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Algorithm/section01.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/section01.md"
diff --git a/000 - 2 Data & Algorithm/Algorithm/section02.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/section02.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Algorithm/section02.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/section02.md"
diff --git a/000 - 2 Data & Algorithm/Algorithm/string.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/string.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Algorithm/string.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/string.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/1.\344\270\203\347\247\215\346\226\271\345\274\217\345\256\236\347\216\260singleton\346\250\241\345\274\217.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/1.\344\270\203\347\247\215\346\226\271\345\274\217\345\256\236\347\216\260singleton\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/1.\344\270\203\347\247\215\346\226\271\345\274\217\345\256\236\347\216\260singleton\346\250\241\345\274\217.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/1.\344\270\203\347\247\215\346\226\271\345\274\217\345\256\236\347\216\260singleton\346\250\241\345\274\217.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/2.\344\272\214\347\273\264\346\225\260\347\273\204\344\270\255\347\232\204\346\237\245\346\211\276.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/2.\344\272\214\347\273\264\346\225\260\347\273\204\344\270\255\347\232\204\346\237\245\346\211\276.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/2.\344\272\214\347\273\264\346\225\260\347\273\204\344\270\255\347\232\204\346\237\245\346\211\276.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/2.\344\272\214\347\273\264\346\225\260\347\273\204\344\270\255\347\232\204\346\237\245\346\211\276.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\347\232\204\351\223\276\350\241\250.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\347\232\204\351\223\276\350\241\250.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\347\232\204\351\223\276\350\241\250.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\347\232\204\351\223\276\350\241\250.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23011\357\274\232\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23011\357\274\232\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23011\357\274\232\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23011\357\274\232\346\225\260\345\200\274\347\232\204\346\225\264\346\225\260\346\254\241\346\226\271.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23012\357\274\232\346\211\223\345\215\2601\345\210\260\346\234\200\345\244\247\347\232\204n\344\275\215\346\225\260.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23012\357\274\232\346\211\223\345\215\2601\345\210\260\346\234\200\345\244\247\347\232\204n\344\275\215\346\225\260.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23012\357\274\232\346\211\223\345\215\2601\345\210\260\346\234\200\345\244\247\347\232\204n\344\275\215\346\225\260.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23012\357\274\232\346\211\223\345\215\2601\345\210\260\346\234\200\345\244\247\347\232\204n\344\275\215\346\225\260.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23044\357\274\232\346\211\221\345\205\213\347\211\214\347\232\204\351\241\272\345\255\220.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23044\357\274\232\346\211\221\345\205\213\347\211\214\347\232\204\351\241\272\345\255\220.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23044\357\274\232\346\211\221\345\205\213\347\211\214\347\232\204\351\241\272\345\255\220.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23044\357\274\232\346\211\221\345\205\213\347\211\214\347\232\204\351\241\272\345\255\220.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23045\357\274\232\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260\345\255\227.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23045\357\274\232\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260\345\255\227.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23045\357\274\232\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260\345\255\227.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\23045\357\274\232\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260\345\255\227.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\2306\357\274\232\351\207\215\345\273\272\344\272\214\345\217\211\346\240\221.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\2306\357\274\232\351\207\215\345\273\272\344\272\214\345\217\211\346\240\221.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\2306\357\274\232\351\207\215\345\273\272\344\272\214\345\217\211\346\240\221.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\345\211\221\346\214\207Offer/\351\235\242\350\257\225\351\242\2306\357\274\232\351\207\215\345\273\272\344\272\214\345\217\211\346\240\221.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/1.\350\256\276\350\256\241\344\270\200\344\270\252\346\234\211getMin\345\212\237\350\203\275\347\232\204\346\240\210.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/1.\350\256\276\350\256\241\344\270\200\344\270\252\346\234\211getMin\345\212\237\350\203\275\347\232\204\346\240\210.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/1.\350\256\276\350\256\241\344\270\200\344\270\252\346\234\211getMin\345\212\237\350\203\275\347\232\204\346\240\210.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/1.\350\256\276\350\256\241\344\270\200\344\270\252\346\234\211getMin\345\212\237\350\203\275\347\232\204\346\240\210.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/2.\347\224\261\344\270\244\344\270\252\346\240\210\347\273\204\346\210\220\347\232\204\351\230\237\345\210\227.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/2.\347\224\261\344\270\244\344\270\252\346\240\210\347\273\204\346\210\220\347\232\204\351\230\237\345\210\227.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/2.\347\224\261\344\270\244\344\270\252\346\240\210\347\273\204\346\210\220\347\232\204\351\230\237\345\210\227.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/2.\347\224\261\344\270\244\344\270\252\346\240\210\347\273\204\346\210\220\347\232\204\351\230\237\345\210\227.md"
diff --git "a/000 - 2 Data & Algorithm/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/3.\345\246\202\344\275\225\344\273\205\347\224\250\351\200\222\345\275\222\345\207\275\346\225\260\345\222\214\346\240\210\346\223\215\344\275\234\351\200\206\345\272\217\344\270\200\344\270\252\346\240\210.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/3.\345\246\202\344\275\225\344\273\205\347\224\250\351\200\222\345\275\222\345\207\275\346\225\260\345\222\214\346\240\210\346\223\215\344\275\234\351\200\206\345\272\217\344\270\200\344\270\252\346\240\210.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/3.\345\246\202\344\275\225\344\273\205\347\224\250\351\200\222\345\275\222\345\207\275\346\225\260\345\222\214\346\240\210\346\223\215\344\275\234\351\200\206\345\272\217\344\270\200\344\270\252\346\240\210.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Algorithm/\347\250\213\345\272\217\345\221\230\344\273\243\347\240\201\351\235\242\350\257\225\346\214\207\345\215\227(\345\267\246\347\250\213\344\272\221)/3.\345\246\202\344\275\225\344\273\205\347\224\250\351\200\222\345\275\222\345\207\275\346\225\260\345\222\214\346\240\210\346\223\215\344\275\234\351\200\206\345\272\217\344\270\200\344\270\252\346\240\210.md"
diff --git a/000 - 2 Data & Algorithm/Btree.txt "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Btree.txt"
similarity index 100%
rename from 000 - 2 Data & Algorithm/Btree.txt
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/Btree.txt"
diff --git "a/000 - 2 Data & Algorithm/DataStructure/B\346\240\221.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/B\346\240\221.md"
similarity index 98%
rename from "000 - 2 Data & Algorithm/DataStructure/B\346\240\221.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/B\346\240\221.md"
index 01604c32..14947fd8 100644
--- "a/000 - 2 Data & Algorithm/DataStructure/B\346\240\221.md"	
+++ "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/B\346\240\221.md"	
@@ -1,66 +1,66 @@
-https://blog.csdn.net/v_JULY_v/article/details/6530142
-
-外存储器 磁盘
-
-磁盘的构造
-
-磁盘是一个扁平的 **圆盘**(与电唱机的唱片类似)。
-盘面上有许多称为 **磁道** 的圆圈，数据就记录在这些磁道上。
-磁盘可以是单片的，也可以是由若干 **盘片** 组成的盘组，每一盘片上有 **两个面**。
-如下图11.3中所示的6片盘组为例，除去最顶端和最底端的外侧面不存储数据之外，一共有10个面可以用来保存信息。
-
-
-
-当磁盘驱动器执行读/写功能时。盘片装在一个主轴上，并绕主轴高速旋转，当磁道在读/写头(又叫磁头) 下通过时，就可以进行数据的读 / 写了。
-
-一般磁盘分为固定头盘(磁头固定)和活动头盘。固定头盘的每一个磁道上都有独立的磁头，它是固定不动的，专门负责这一磁道上数据的读/写。
-
-活动头盘 (如上图)的磁头是可移动的。每一个盘面上只有一个磁头(磁头是双向的，因此正反盘面都能读写)。它可以从该面的一个磁道移动到另一个磁道。所有磁头都装在同一个动臂上，因此不同盘面上的所有磁头都是同时移动的(行动整齐划一)。当盘片绕主轴旋转的时候，磁头与旋转的盘片形成一个圆柱体。各个盘面上半径相同的磁道组成了一个圆柱面，我们称为柱面 。因此，柱面的个数也就是盘面上的磁道数。
-
-
-2.2磁盘的读/写原理和效率
-
-磁盘上数据必须用一个三维地址唯一标示：柱面号、盘面号、块号(磁道上的盘块)。
-
-读/写磁盘上某一指定数据需要下面3个步骤：
-
-(1)  首先移动臂根据柱面号使磁头移动到所需要的柱面上，这一过程被称为定位或查找 。
-
-(2)  如上图11.3中所示的6盘组示意图中，所有磁头都定位到了10个盘面的10条磁道上(磁头都是双向的)。这时根据盘面号来确定指定盘面上的磁道。
-
-(3) 盘面确定以后，盘片开始旋转，将指定块号的磁道段移动至磁头下。
-
-经过上面三个步骤，指定数据的存储位置就被找到。这时就可以开始读/写操作了。
-
-访问某一具体信息，由3部分时间组成：
-
-● 查找时间(seek time) Ts: 完成上述步骤(1)所需要的时间。这部分时间代价最高，最大可达到0.1s左右。
-
-● 等待时间(latency time) Tl: 完成上述步骤(3)所需要的时间。由于盘片绕主轴旋转速度很快，一般为7200转/分(电脑硬盘的性能指标之一, 家用的普通硬盘的转速一般有5400rpm(笔记本)、7200rpm几种)。因此一般旋转一圈大约0.0083s。
-
-● 传输时间(transmission time) Tt: 数据通过系统总线传送到内存的时间，一般传输一个字节(byte)大概0.02us=2*10^(-8)s
-
-磁盘读取数据是以盘块(block)为基本单位的。位于同一盘块中的所有数据都能被一次性全部读取出来。而磁盘IO代价主要花费在查找时间Ts上。因此我们应该尽量将相关信息存放在同一盘块，同一磁道中。或者至少放在同一柱面或相邻柱面上，以求在读/写信息时尽量减少磁头来回移动的次数，避免过多的查找时间Ts。
-
-所以，在大规模数据存储方面，大量数据存储在外存磁盘中，而在外存磁盘中读取/写入块(block)中某数据时，首先需要定位到磁盘中的某块，如何有效地查找磁盘中的数据，需要一种合理高效的外存数据结构，就是下面所要重点阐述的B-tree结构
-
-
-## B树
-  B树 就是 B-Tree B 树又叫平衡多路查找树
-
-  B树与红黑树最大的不同在于，B树的结点可以有许多子女，从几个到几千个。那为什么又说B树与红黑树很相似呢?
-  因为与红黑树一样，一棵含n个结点的B树的高度也为O（lgn），但可能比一棵红黑树的高度小许多，应为它的分支因子比较大。所以，B树可以在O（logn）时间内，实现各种如插入（insert），删除（delete）等动态集合操作。
-
-  一个内结点x若含有n[x]个关键字，那么x将含有n[x]+1个子女。
-
-  B树的类型
-  keyNum 关键字个数
-  parent 指向父结点
-  *ptr  子树指针向量
-  *key  关键字向量*
-
-  B-树：多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键字范围的子结点；所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；
-
-  B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引；B+树总是到叶子结点才命中；
-
-  B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3；
+https://blog.csdn.net/v_JULY_v/article/details/6530142
+
+外存储器 磁盘
+
+磁盘的构造
+
+磁盘是一个扁平的 **圆盘**(与电唱机的唱片类似)。
+盘面上有许多称为 **磁道** 的圆圈，数据就记录在这些磁道上。
+磁盘可以是单片的，也可以是由若干 **盘片** 组成的盘组，每一盘片上有 **两个面**。
+如下图11.3中所示的6片盘组为例，除去最顶端和最底端的外侧面不存储数据之外，一共有10个面可以用来保存信息。
+
+
+
+当磁盘驱动器执行读/写功能时。盘片装在一个主轴上，并绕主轴高速旋转，当磁道在读/写头(又叫磁头) 下通过时，就可以进行数据的读 / 写了。
+
+一般磁盘分为固定头盘(磁头固定)和活动头盘。固定头盘的每一个磁道上都有独立的磁头，它是固定不动的，专门负责这一磁道上数据的读/写。
+
+活动头盘 (如上图)的磁头是可移动的。每一个盘面上只有一个磁头(磁头是双向的，因此正反盘面都能读写)。它可以从该面的一个磁道移动到另一个磁道。所有磁头都装在同一个动臂上，因此不同盘面上的所有磁头都是同时移动的(行动整齐划一)。当盘片绕主轴旋转的时候，磁头与旋转的盘片形成一个圆柱体。各个盘面上半径相同的磁道组成了一个圆柱面，我们称为柱面 。因此，柱面的个数也就是盘面上的磁道数。
+
+
+2.2磁盘的读/写原理和效率
+
+磁盘上数据必须用一个三维地址唯一标示：柱面号、盘面号、块号(磁道上的盘块)。
+
+读/写磁盘上某一指定数据需要下面3个步骤：
+
+(1)  首先移动臂根据柱面号使磁头移动到所需要的柱面上，这一过程被称为定位或查找 。
+
+(2)  如上图11.3中所示的6盘组示意图中，所有磁头都定位到了10个盘面的10条磁道上(磁头都是双向的)。这时根据盘面号来确定指定盘面上的磁道。
+
+(3) 盘面确定以后，盘片开始旋转，将指定块号的磁道段移动至磁头下。
+
+经过上面三个步骤，指定数据的存储位置就被找到。这时就可以开始读/写操作了。
+
+访问某一具体信息，由3部分时间组成：
+
+● 查找时间(seek time) Ts: 完成上述步骤(1)所需要的时间。这部分时间代价最高，最大可达到0.1s左右。
+
+● 等待时间(latency time) Tl: 完成上述步骤(3)所需要的时间。由于盘片绕主轴旋转速度很快，一般为7200转/分(电脑硬盘的性能指标之一, 家用的普通硬盘的转速一般有5400rpm(笔记本)、7200rpm几种)。因此一般旋转一圈大约0.0083s。
+
+● 传输时间(transmission time) Tt: 数据通过系统总线传送到内存的时间，一般传输一个字节(byte)大概0.02us=2*10^(-8)s
+
+磁盘读取数据是以盘块(block)为基本单位的。位于同一盘块中的所有数据都能被一次性全部读取出来。而磁盘IO代价主要花费在查找时间Ts上。因此我们应该尽量将相关信息存放在同一盘块，同一磁道中。或者至少放在同一柱面或相邻柱面上，以求在读/写信息时尽量减少磁头来回移动的次数，避免过多的查找时间Ts。
+
+所以，在大规模数据存储方面，大量数据存储在外存磁盘中，而在外存磁盘中读取/写入块(block)中某数据时，首先需要定位到磁盘中的某块，如何有效地查找磁盘中的数据，需要一种合理高效的外存数据结构，就是下面所要重点阐述的B-tree结构
+
+
+## B树
+  B树 就是 B-Tree B 树又叫平衡多路查找树
+
+  B树与红黑树最大的不同在于，B树的结点可以有许多子女，从几个到几千个。那为什么又说B树与红黑树很相似呢?
+  因为与红黑树一样，一棵含n个结点的B树的高度也为O（lgn），但可能比一棵红黑树的高度小许多，应为它的分支因子比较大。所以，B树可以在O（logn）时间内，实现各种如插入（insert），删除（delete）等动态集合操作。
+
+  一个内结点x若含有n[x]个关键字，那么x将含有n[x]+1个子女。
+
+  B树的类型
+  keyNum 关键字个数
+  parent 指向父结点
+  *ptr  子树指针向量
+  *key  关键字向量*
+
+  B-树：多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键字范围的子结点；所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；
+
+  B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引；B+树总是到叶子结点才命中；
+
+  B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3；
diff --git a/000 - 2 Data & Algorithm/DataStructure/all.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/all.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/DataStructure/all.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/all.md"
diff --git "a/000 - 2 Data & Algorithm/DataStructure/\346\225\260\346\215\256\347\273\223\346\236\204(Java).md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\225\260\346\215\256\347\273\223\346\236\204(Java).md"
similarity index 97%
rename from "000 - 2 Data & Algorithm/DataStructure/\346\225\260\346\215\256\347\273\223\346\236\204(Java).md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\225\260\346\215\256\347\273\223\346\236\204(Java).md"
index a9736ad4..34b5c39b 100644
--- "a/000 - 2 Data & Algorithm/DataStructure/\346\225\260\346\215\256\347\273\223\346\236\204(Java).md"	
+++ "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\225\260\346\215\256\347\273\223\346\236\204(Java).md"	
@@ -8,35 +8,35 @@
 
 创建
 
-```
+```java
 int c[] = {2,3,6,10,99};
 int[] d = new int[10];
 ```
 
 
 
-```
+```java
 	/**
 	 * 数组检索
 	 * @param args
 	 */
 	public static void main(String[] args) {
 		String name[];
-		
+
 		name = new String[5];
 		name[0] = "egg";
 		name[1] = "erqing";
 		name[2] = "baby";
-		
+
 		for(int i = 0; i < name.length; i++){
 			System.out.println(name[i]);
 		}
 	}
 ```
-```
+```java
 /**
 	 * 插入
-	 * 
+	 *
 	 * @param old
 	 * @param value
 	 * @param index
@@ -51,7 +51,7 @@ int[] d = new int[10];
 
 	/**
 	 * 遍历
-	 * 
+	 *
 	 * @param data
 	 */
 	public static void traverse(int data[]) {
@@ -62,7 +62,7 @@ int[] d = new int[10];
 
 	/**
 	 * 删除
-	 * 
+	 *
 	 * @param old
 	 * @param index
 	 * @return
@@ -119,4 +119,4 @@ Tips:数组中删除和增加元素的原理：增加元素，需要将index后
 
 **动态规划、贪心算法、分治算法。（一般不会问到）**
 
-**大数据处理：类似10亿条数据找出最大的1000个数.........等等**
\ No newline at end of file
+**大数据处理：类似10亿条数据找出最大的1000个数.........等等**
diff --git "a/000 - 2 Data & Algorithm/DataStructure/\346\225\260\347\273\204.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\225\260\347\273\204.md"
similarity index 98%
rename from "000 - 2 Data & Algorithm/DataStructure/\346\225\260\347\273\204.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\225\260\347\273\204.md"
index b83f81ae..298adce0 100644
--- "a/000 - 2 Data & Algorithm/DataStructure/\346\225\260\347\273\204.md"	
+++ "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\225\260\347\273\204.md"	
@@ -1,7 +1,7 @@
 #数组
 ---
 
-```
+```java
 /**
  * 普通数组的Java代码
  * @author dream
@@ -12,13 +12,13 @@ public class GeneralArray {
 	private int[] a;
 	private int size;   //数组的大小
 	private int nElem;   //数组中有多少项
-	
+
 	public GeneralArray(int max){
 		this.a = new int[max];
 		this.size = max;
 		this.nElem = 0;
 	}
-	
+
 	public boolean find(int searchNum){   //查找某个值
 		int j;
 		for(j = 0; j < nElem; j++){
@@ -32,8 +32,8 @@ public class GeneralArray {
 			return true;
 		}
 	}
-	
-	
+
+
 	public boolean insert(int value){   //插入某个值
 		if(nElem == size){
 			System.out.println("数组已满");
@@ -43,7 +43,7 @@ public class GeneralArray {
 		nElem++;
 		return true;
 	}
-	
+
 	public boolean delete(int value){   //删除某个值
 		int j;
 		for(j = 0; j < nElem; j++){
@@ -66,7 +66,7 @@ public class GeneralArray {
 		nElem--;
 		return true;
 	}
-	
+
 	public void display(){   //打印整个数组
 		for(int i = 0; i < nElem; i++){
 			System.out.println(a[i] + " ");
@@ -77,7 +77,7 @@ public class GeneralArray {
 
 ```
 
-```
+```java
 /**
  * 有序数组的Java代码
  * @author dream
@@ -99,17 +99,17 @@ public class OrderedArray {
 	private long[] a;
 	private int size;   //数组的大小
 	private int nElem;  //数组中有多少项
-	
+
 	public OrderedArray(int max){   //初始化数组
 		this.a = new long[max];
 		this.size = max;
 		this.nElem = 0;
 	}
-	
+
 	public int size(){   //返回数组实际有多少值
 		return this.nElem;
 	}
-	
+
 	/**
 	 * 二分查找
 	 * @param searchNum
@@ -134,8 +134,8 @@ public class OrderedArray {
 			}
 		}
 	}
-	
-	
+
+
 	public boolean insert(long value){   //插入某个值
 		if(nElem == size){
 			System.out.println("数组已满!");
@@ -147,7 +147,7 @@ public class OrderedArray {
 				break;
 			}
 		}
-		
+
 		for(int k = nElem; k > j; k++){
 			a[k] = a[k-1];
 		}
@@ -155,16 +155,16 @@ public class OrderedArray {
 		nElem++;
 		return true;
 	}
-	
-	
-	
+
+
+
 	public boolean delete(long value){   //删除某个值
 		int j = find(value);
 		if(j == -1){
 			System.out.println("没有该元素!");
 			return false;
 		}
-		
+
 		if(nElem == size){
 			for(int k = j; k < nElem - 1; k++){
 				a[k] = a[k+1];
@@ -178,8 +178,8 @@ public class OrderedArray {
 		nElem--;
 		return true;
 	}
-	
-	
+
+
 	public void display(){   //打印整个数组
 		for(int i = 0; i < nElem; i++){
 			System.out.println(a[i] + " ");
@@ -188,4 +188,4 @@ public class OrderedArray {
 	}
 }
 
-```
\ No newline at end of file
+```
diff --git "a/000 - 2 Data & Algorithm/DataStructure/\346\240\210\345\222\214\351\230\237\345\210\227.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\240\210\345\222\214\351\230\237\345\210\227.md"
similarity index 97%
rename from "000 - 2 Data & Algorithm/DataStructure/\346\240\210\345\222\214\351\230\237\345\210\227.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\240\210\345\222\214\351\230\237\345\210\227.md"
index 2847248d..f541bd7b 100644
--- "a/000 - 2 Data & Algorithm/DataStructure/\346\240\210\345\222\214\351\230\237\345\210\227.md"	
+++ "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\346\240\210\345\222\214\351\230\237\345\210\227.md"	
@@ -7,7 +7,7 @@
 
 栈最基本的操作是出栈(Pop)、入栈(Push)，还有其他扩展操作，如查看栈顶元素，判断栈是否为空、是否已满，读取栈的大小等。
 
-```
+```java
 /**
  * 栈是先进后出
  * 只能访问栈顶的数据
@@ -26,13 +26,13 @@ public class ArrayStack {
 	private long[] a;
 	private int size;   //栈数组的大小
 	private int top;   //栈顶
-	
+
 	public ArrayStack(int maxSize){
 		this.size = maxSize;
 		this.a = new long[size];
 		this.top = -1;   //表示空栈
 	}
-	
+
 	public void push(long value){   //入栈
 		if(isFull()){
 			System.out.println("栈已满!");
@@ -40,7 +40,7 @@ public class ArrayStack {
 		}
 		a[++top] = value;
 	}
-	
+
 	public long peek(){   //返回栈顶内容，但不删除
 		if(isEmpty()){
 			System.out.println("栈中没有数据");
@@ -48,8 +48,8 @@ public class ArrayStack {
 		}
 		return a[top];
 	}
-	
-	
+
+
 	public long pop(){   //弹出栈顶内容
 		if(isEmpty()){
 			System.out.println("栈中没有数据!");
@@ -57,11 +57,11 @@ public class ArrayStack {
 		}
 		return a[top--];
 	}
-	
+
 	public int size(){
 		return top + 1;
 	}
-	
+
 	/**
 	 * 判断是否满了
 	 * @return
@@ -69,7 +69,7 @@ public class ArrayStack {
 	public boolean isFull(){
 		return (top == size - 1);
 	}
-	
+
 	/**
 	 * 是否为空
 	 * @return
@@ -77,15 +77,15 @@ public class ArrayStack {
 	public boolean isEmpty(){
 		return (top == -1);
 	}
-	
-	
+
+
 	public void display(){
 		for (int i = top; i >= 0; i--) {
 			System.out.println(a[i] + " ");
 		}
 		System.out.println("");
 	}
-	
+
 }
 
 ```
@@ -95,7 +95,7 @@ public class ArrayStack {
 
 依然使用数组作为底层容器来实现一个队列的封装
 
-```
+```java
 /**
  * 队列也可以用数组来实现，不过这里有个问题，当数组下标满了后就不能再添加了，
  * 但是数组前面由于已经删除队列头的数据了，导致空。所以队列我们可以用循环数组来实现，
@@ -109,7 +109,7 @@ public class RoundQueue {
 	private int nItems;    //实际存储数量
 	private int front;     //头
 	private int rear;       //尾
-	
+
 	public RoundQueue(int maxSize){
 		this.size = maxSize;
 		a = new long[size];
@@ -117,7 +117,7 @@ public class RoundQueue {
 		rear = -1;
 		nItems = 0;
 	}
-	
+
 	public void insert(long value){
 		if(isFull()){
 			System.out.println("队列已满");
@@ -127,7 +127,7 @@ public class RoundQueue {
 		a[rear] = value;  //尾指针满了就循环到0处，这句相当于下面注释内容
 		nItems++;
 	}
-	
+
 	public long remove(){
 		if(isEmpty()){
 			System.out.println("队列为空!");
@@ -137,7 +137,7 @@ public class RoundQueue {
 		front = front % size;
 		return a[front++];
 	}
-	
+
 	public void display(){
 		if(isEmpty()){
 			System.out.println("队列为空!");
@@ -149,7 +149,7 @@ public class RoundQueue {
 		}
 		System.out.println("");
 	}
-	
+
 	public long peek(){
 		if(isEmpty()){
 			System.out.println("队列为空！");
@@ -157,20 +157,20 @@ public class RoundQueue {
 		}
 		return a[front];
 	}
-	
+
 	public boolean isFull(){
 		return (nItems == size);
 	}
-	
+
 	public boolean isEmpty(){
 		return (nItems == 0);
 	}
-	
+
 	public int size(){
 		return nItems;
 	}
-	
-	
+
+
 }
 
 ```
@@ -178,21 +178,21 @@ public class RoundQueue {
 和栈一样，队列中插入数据项和删除数据项的时间复杂度均为O(1)
 
  还有个优先级队列，优先级队列是比栈和队列更专用的数据结构。优先级队列与上面普通的队列相比，主要区别在于队列中的元素是有序的，关键字最小（或者最大）的数据项总在队头。数据项插入的时候会按照顺序插入到合适的位置以确保队列的顺序。优先级队列的内部实现可以用数组或者一种特别的树——堆来实现。这里用数组实现优先级队列。
- 
- ```
- 
+
+ ```java
+
 public class PriorityQueue {
 
 	private long[] a;
 	private int size;
 	private int nItems;  //元素个数
-	
+
 	public PriorityQueue(int maxSize){
 		size = maxSize;
 		nItems = 0;
 		a = new long[size];
 	}
-	
+
 	public void insert(long value){
 		if(isFull()){
 			System.out.println("队列已满！");
@@ -209,13 +209,13 @@ public class PriorityQueue {
                 }  
                 else {  
                     break;  
-                } 
+                }
 			}
 			a[j+1] = value;
 			nItems++;
 		}
 	}
-	
+
 	public long remove(){
 		if(isFull()){
 			System.out.println("队列为空!");
@@ -223,23 +223,23 @@ public class PriorityQueue {
 		}
 		return a[--nItems];
 	}
-	
+
 	public long peekMin(){
 		return a[nItems - 1];
 	}
-	
+
 	public boolean isFull(){
 		return (nItems == size);
 	}
-	
+
 	public boolean isEmpty(){
 		return (nItems == 0);
 	}
-	
+
 	public int size(){
 		return nItems;
 	}
-	
+
 	public void display(){
 		for(int i = nItems - 1;i >= 0; i--){
 			System.out.println(a[i] + " ");
@@ -249,9 +249,5 @@ public class PriorityQueue {
 }
 
  ```
- 
- 优先级队列中，插入操作需要O(N)的时间，而删除操作则需要O(1)的时间。
- 
- 
- 
 
+ 优先级队列中，插入操作需要O(N)的时间，而删除操作则需要O(1)的时间。
diff --git "a/000 - 2 Data & Algorithm/DataStructure/\351\200\222\345\275\222\345\222\214\351\235\236\351\200\222\345\275\222\346\226\271\345\274\217\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\345\205\210\343\200\201\344\270\255\343\200\201\345\220\216\345\272\217\351\201\215\345\216\206.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\351\200\222\345\275\222\345\222\214\351\235\236\351\200\222\345\275\222\346\226\271\345\274\217\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\345\205\210\343\200\201\344\270\255\343\200\201\345\220\216\345\272\217\351\201\215\345\216\206.md"
similarity index 98%
rename from "000 - 2 Data & Algorithm/DataStructure/\351\200\222\345\275\222\345\222\214\351\235\236\351\200\222\345\275\222\346\226\271\345\274\217\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\345\205\210\343\200\201\344\270\255\343\200\201\345\220\216\345\272\217\351\201\215\345\216\206.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\351\200\222\345\275\222\345\222\214\351\235\236\351\200\222\345\275\222\346\226\271\345\274\217\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\345\205\210\343\200\201\344\270\255\343\200\201\345\220\216\345\272\217\351\201\215\345\216\206.md"
index 20ea8852..e657934e 100644
--- "a/000 - 2 Data & Algorithm/DataStructure/\351\200\222\345\275\222\345\222\214\351\235\236\351\200\222\345\275\222\346\226\271\345\274\217\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\345\205\210\343\200\201\344\270\255\343\200\201\345\220\216\345\272\217\351\201\215\345\216\206.md"	
+++ "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/DataStructure/\351\200\222\345\275\222\345\222\214\351\235\236\351\200\222\345\275\222\346\226\271\345\274\217\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\345\205\210\343\200\201\344\270\255\343\200\201\345\220\216\345\272\217\351\201\215\345\216\206.md"	
@@ -5,20 +5,20 @@
 递归实现：
 
 
-```
+```java
 public class Node {
 
 	public int value;
 	public Node left;
 	public Node right;
-	
+
 	public Node(int data){
 		this.value = data;
 	}
 }
 ```
 
-```
+```java
 	/**
 	 * 前序遍历
 	 * @param head
@@ -31,7 +31,7 @@ public class Node {
 		preOrderRecur(head.left);
 		preOrderRecur(head.right);
 	}
-	
+
 	/**
 	 * 中序遍历
 	 * @param head
@@ -44,7 +44,7 @@ public class Node {
 		System.out.println(head.value + " ");
 		inOderRecur(head.right);
 	}
-	
+
 	/**
 	 * 后序遍历
 	 * @param head
@@ -62,4 +62,3 @@ public class Node {
 
 
 非递归遍历
-
diff --git a/000 - 2 Data & Algorithm/HashMap.md "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/HashMap.md"
similarity index 100%
rename from 000 - 2 Data & Algorithm/HashMap.md
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/HashMap.md"
diff --git a/000 - 2 Data & Algorithm/img/rbt1.png "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/img/rbt1.png"
similarity index 100%
rename from 000 - 2 Data & Algorithm/img/rbt1.png
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/img/rbt1.png"
diff --git a/000 - 2 Data & Algorithm/img/rbt2.png "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/img/rbt2.png"
similarity index 100%
rename from 000 - 2 Data & Algorithm/img/rbt2.png
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/img/rbt2.png"
diff --git "a/000 - 2 Data & Algorithm/\345\211\221\346\214\207offer.txt" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\345\211\221\346\214\207offer.txt"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\345\211\221\346\214\207offer.txt"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\345\211\221\346\214\207offer.txt"
diff --git "a/000 - 2 Data & Algorithm/\345\212\250\346\200\201\350\247\204\345\210\222.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\345\212\250\346\200\201\350\247\204\345\210\222.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\345\212\250\346\200\201\350\247\204\345\210\222.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\345\212\250\346\200\201\350\247\204\345\210\222.md"
diff --git "a/000 - 2 Data & Algorithm/\345\246\202\344\275\225\345\210\244\346\226\255\351\223\276\350\241\250\346\234\211\347\216\257.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\345\246\202\344\275\225\345\210\244\346\226\255\351\223\276\350\241\250\346\234\211\347\216\257.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\345\246\202\344\275\225\345\210\244\346\226\255\351\223\276\350\241\250\346\234\211\347\216\257.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\345\246\202\344\275\225\345\210\244\346\226\255\351\223\276\350\241\250\346\234\211\347\216\257.md"
diff --git "a/000 - 2 Data & Algorithm/\346\211\276\345\207\272\347\274\272\345\244\261\347\232\204\346\225\264\346\225\260.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\346\211\276\345\207\272\347\274\272\345\244\261\347\232\204\346\225\264\346\225\260.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\346\211\276\345\207\272\347\274\272\345\244\261\347\232\204\346\225\264\346\225\260.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\346\211\276\345\207\272\347\274\272\345\244\261\347\232\204\346\225\264\346\225\260.md"
diff --git "a/000 - 2 Data & Algorithm/\346\234\200\345\260\217\346\240\210\347\232\204\345\256\236\347\216\260.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\346\234\200\345\260\217\346\240\210\347\232\204\345\256\236\347\216\260.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\346\234\200\345\260\217\346\240\210\347\232\204\345\256\236\347\216\260.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\346\234\200\345\260\217\346\240\210\347\232\204\345\256\236\347\216\260.md"
diff --git "a/000 - 2 Data & Algorithm/\347\250\213\345\272\217\345\221\230\345\277\205\351\241\273\347\237\245\351\201\223\347\232\20410\345\244\247\345\237\272\347\241\200\345\256\236\347\224\250\347\256\227\346\263\225\345\217\212\345\205\266\350\256\262\350\247\243.txt" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\347\250\213\345\272\217\345\221\230\345\277\205\351\241\273\347\237\245\351\201\223\347\232\20410\345\244\247\345\237\272\347\241\200\345\256\236\347\224\250\347\256\227\346\263\225\345\217\212\345\205\266\350\256\262\350\247\243.txt"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\347\250\213\345\272\217\345\221\230\345\277\205\351\241\273\347\237\245\351\201\223\347\232\20410\345\244\247\345\237\272\347\241\200\345\256\236\347\224\250\347\256\227\346\263\225\345\217\212\345\205\266\350\256\262\350\247\243.txt"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\347\250\213\345\272\217\345\221\230\345\277\205\351\241\273\347\237\245\351\201\223\347\232\20410\345\244\247\345\237\272\347\241\200\345\256\236\347\224\250\347\256\227\346\263\225\345\217\212\345\205\266\350\256\262\350\247\243.txt"
diff --git "a/000 - 2 Data & Algorithm/\347\272\242\351\273\221\346\240\221.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\347\272\242\351\273\221\346\240\221.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\347\272\242\351\273\221\346\240\221.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\347\272\242\351\273\221\346\240\221.md"
diff --git "a/000 - 2 Data & Algorithm/\350\276\227\350\275\254\347\233\270\351\231\244\346\263\225.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\350\276\227\350\275\254\347\233\270\351\231\244\346\263\225.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\350\276\227\350\275\254\347\233\270\351\231\244\346\263\225.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\350\276\227\350\275\254\347\233\270\351\231\244\346\263\225.md"
diff --git "a/000 - 2 Data & Algorithm/\351\253\230\345\271\266\345\217\221\344\270\213\347\232\204HashMap.md" "b/000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\351\253\230\345\271\266\345\217\221\344\270\213\347\232\204HashMap.md"
similarity index 100%
rename from "000 - 2 Data & Algorithm/\351\253\230\345\271\266\345\217\221\344\270\213\347\232\204HashMap.md"
rename to "000 - 2 Data & Algorithm \346\225\260\346\215\256\347\273\223\346\236\204&\347\256\227\346\263\225/\351\253\230\345\271\266\345\217\221\344\270\213\347\232\204HashMap.md"
diff --git "a/000 - 3 Design Patterns/Builder\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/Builder\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/Builder\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/Builder\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
diff --git a/000 - 3 Design Patterns/all.md "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/all.md"
similarity index 98%
rename from 000 - 3 Design Patterns/all.md
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/all.md"
index 7f65b313..d597e696 100644
--- a/000 - 3 Design Patterns/all.md	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/all.md"	
@@ -1,13 +1,13 @@
-**工厂方法模式**：适合 出现了大量的产品需要创建，并且有公共的接口，可以通过工厂方法模式进行创建，一个工厂里，不同方法创建不同的类。
-
-**抽象工厂** ：工厂方法模式有一个问题就是类的创建依赖于工厂，也就是说想要扩展程序，必须对工厂类进行修改，用抽象工厂，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不用改以前的代码，一个工厂生产一个具体对象
-
-**建造者模式**：工厂模式提供的是创建单个对象的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象。
-
-**原型模式**：讲一个对象作为原型，对其进行赋值克隆，产生一个和元对象类似的新对象。
-
-**适配器模式**：将某个类的接口转换为客户端期望的另一个接口表示。
-
-**外观模式 facade**：为了解决类与类之间的依赖关系，将他们的关系放在facade类中。
-
-**组合模式**：在处理类似树形结构的问题时很方便。
+**工厂方法模式**：适合 出现了大量的产品需要创建，并且有公共的接口，可以通过工厂方法模式进行创建，一个工厂里，不同方法创建不同的类。
+
+**抽象工厂** ：工厂方法模式有一个问题就是类的创建依赖于工厂，也就是说想要扩展程序，必须对工厂类进行修改，用抽象工厂，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不用改以前的代码，一个工厂生产一个具体对象
+
+**建造者模式**：工厂模式提供的是创建单个对象的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象。
+
+**原型模式**：讲一个对象作为原型，对其进行赋值克隆，产生一个和元对象类似的新对象。
+
+**适配器模式**：将某个类的接口转换为客户端期望的另一个接口表示。
+
+**外观模式 facade**：为了解决类与类之间的依赖关系，将他们的关系放在facade类中。
+
+**组合模式**：在处理类似树形结构的问题时很方便。
diff --git "a/000 - 3 Design Patterns/\344\273\243\347\220\206\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\344\273\243\347\220\206\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\344\273\243\347\220\206\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\344\273\243\347\220\206\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\345\215\225\344\276\213\344\270\203\347\247\215\345\206\231\346\263\225.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\344\270\203\347\247\215\345\206\231\346\263\225.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\215\225\344\276\213\344\270\203\347\247\215\345\206\231\346\263\225.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\344\270\203\347\247\215\345\206\231\346\263\225.md"
diff --git "a/000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217 \346\207\222\346\261\211 \345\217\214\351\207\215\346\243\200\346\265\213\346\234\272\345\210\266.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217 \346\207\222\346\261\211 \345\217\214\351\207\215\346\243\200\346\265\213\346\234\272\345\210\266.md"
similarity index 97%
rename from "000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217 \346\207\222\346\261\211 \345\217\214\351\207\215\346\243\200\346\265\213\346\234\272\345\210\266.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217 \346\207\222\346\261\211 \345\217\214\351\207\215\346\243\200\346\265\213\346\234\272\345\210\266.md"
index 593b3207..ab875033 100644
--- "a/000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217 \346\207\222\346\261\211 \345\217\214\351\207\215\346\243\200\346\265\213\346\234\272\345\210\266.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217 \346\207\222\346\261\211 \345\217\214\351\207\215\346\243\200\346\265\213\346\234\272\345\210\266.md"	
@@ -1,67 +1,67 @@
-``` java
-public class Singleton {
-    private Singleton() {}  //私有构造函数
-    private static Singleton instance = null;  //单例对象
-    //静态工厂方法
-    public static Singleton getInstance() {
-        if (instance == null) {
-            instance = new Singleton();
-        }
-        return instance;
-    }
-}
-```
-两个线程同时进入 `instance = new Singleton();` 则会构建了两次
-
-```java
-public class Singleton {
-    private Singleton() {}  //私有构造函数
-    private static Singleton instance = null;  //单例对象
-    //静态工厂方法
-    public static Singleton getInstance() {
-        if (instance == null) {      //双重检测机制
-           synchronized (Singleton.class){  //同步锁
-               if (instance == null) {     //双重检测机制
-                   instance = new Singleton();
-               }
-           }
-        }
-        return instance;
-    }
-}
-```
-* 防止new Singleton() 被执行多次
-* 进入Synchronized 临界区以后，还要再做一次判空。因为当两个线程同时访问的时候，线程A构建完对象，线程B也已经通过了最初的判空验证，不做第二次判空的话，线程B还是会再次构建instance对象。
-
-重排序，
-instance = new Singleton，会被编译器编译成如下JVM指令：
-
-memory =allocate();    // **1：分配对象的内存空间**
-ctorInstance(memory);  // **2：初始化对象**
-instance =memory;     //  **3：设置instance指向刚分配的内存地址**
-但是这些指令顺序并非一成不变，有可能会经过JVM和CPU的优化，指令重排成下面的顺序：
-memory =allocate();    // **1：分配对象的内存空间**
-instance =memory;     //  **3：设置instance指向刚分配的内存地址**
-ctorInstance(memory);  // **2：初始化对象**
-
-当线程A执行完1,3,时，instance对象还未完成初始化，但已经不再指向null。
-此时如果线程B抢占到CPU资源，执行 if（instance == null）的结果会是false，从而返回一个没有初始化完成的instance对象。
-
-``` java
-public class Singleton {
-    private Singleton() {}  //私有构造函数
-    private **volatile** static Singleton instance = null;  //单例对象
-    //静态工厂方法
-    public static Singleton getInstance() {
-          if (instance == null) {      //双重检测机制
-              synchronized (Singleton.class){  //同步锁
-                  if (instance == null) {     //双重检测机制
-                      instance = new Singleton();
-                  }
-              }
-          }
-          return instance;
-      }
-}
-```
-* volatile 禁止了重排序，避免了前面的问题。
+``` java
+public class Singleton {
+    private Singleton() {}  //私有构造函数
+    private static Singleton instance = null;  //单例对象
+    //静态工厂方法
+    public static Singleton getInstance() {
+        if (instance == null) {
+            instance = new Singleton();
+        }
+        return instance;
+    }
+}
+```
+两个线程同时进入 `instance = new Singleton();` 则会构建了两次
+
+```java
+public class Singleton {
+    private Singleton() {}  //私有构造函数
+    private static Singleton instance = null;  //单例对象
+    //静态工厂方法
+    public static Singleton getInstance() {
+        if (instance == null) {      //双重检测机制
+           synchronized (Singleton.class){  //同步锁
+               if (instance == null) {     //双重检测机制
+                   instance = new Singleton();
+               }
+           }
+        }
+        return instance;
+    }
+}
+```
+* 防止new Singleton() 被执行多次
+* 进入Synchronized 临界区以后，还要再做一次判空。因为当两个线程同时访问的时候，线程A构建完对象，线程B也已经通过了最初的判空验证，不做第二次判空的话，线程B还是会再次构建instance对象。
+
+重排序，
+instance = new Singleton，会被编译器编译成如下JVM指令：
+
+memory =allocate();    // **1：分配对象的内存空间**
+ctorInstance(memory);  // **2：初始化对象**
+instance =memory;     //  **3：设置instance指向刚分配的内存地址**
+但是这些指令顺序并非一成不变，有可能会经过JVM和CPU的优化，指令重排成下面的顺序：
+memory =allocate();    // **1：分配对象的内存空间**
+instance =memory;     //  **3：设置instance指向刚分配的内存地址**
+ctorInstance(memory);  // **2：初始化对象**
+
+当线程A执行完1,3,时，instance对象还未完成初始化，但已经不再指向null。
+此时如果线程B抢占到CPU资源，执行 if（instance == null）的结果会是false，从而返回一个没有初始化完成的instance对象。
+
+``` java
+public class Singleton {
+    private Singleton() {}  //私有构造函数
+    private **volatile** static Singleton instance = null;  //单例对象
+    //静态工厂方法
+    public static Singleton getInstance() {
+          if (instance == null) {      //双重检测机制
+              synchronized (Singleton.class){  //同步锁
+                  if (instance == null) {     //双重检测机制
+                      instance = new Singleton();
+                  }
+              }
+          }
+          return instance;
+      }
+}
+```
+* volatile 禁止了重排序，避免了前面的问题。
diff --git "a/000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217 \350\241\215\347\224\237.txt" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217 \350\241\215\347\224\237.txt"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217 \350\241\215\347\224\237.txt"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217 \350\241\215\347\224\237.txt"
diff --git "a/000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\2172.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\2172.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\215\225\344\276\213\346\250\241\345\274\2172.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\215\225\344\276\213\346\250\241\345\274\2172.md"
diff --git "a/000 - 3 Design Patterns/\345\216\237\345\236\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\216\237\345\236\213\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\216\237\345\236\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\216\237\345\236\213\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\345\244\226\350\247\202\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\244\226\350\247\202\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\244\226\350\247\202\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\244\226\350\247\202\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\345\270\270\350\247\201\347\232\204\351\235\242\345\220\221\345\257\271\350\261\241\350\256\276\350\256\241\345\216\237\345\210\231.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\270\270\350\247\201\347\232\204\351\235\242\345\220\221\345\257\271\350\261\241\350\256\276\350\256\241\345\216\237\345\210\231.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\345\270\270\350\247\201\347\232\204\351\235\242\345\220\221\345\257\271\350\261\241\350\256\276\350\256\241\345\216\237\345\210\231.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\345\270\270\350\247\201\347\232\204\351\235\242\345\220\221\345\257\271\350\261\241\350\256\276\350\256\241\345\216\237\345\210\231.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01 \345\210\233\345\273\272\345\236\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01 \345\210\233\345\273\272\345\236\213\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01 \345\210\233\345\273\272\345\236\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01 \345\210\233\345\273\272\345\236\213\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-01 - \347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-01 - \347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-01 - \347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-01 - \347\256\200\345\215\225\345\267\245\345\216\202\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-02 - \345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-02 - \345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217.md"
similarity index 99%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-02 - \345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-02 - \345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217.md"
index 491b324e..23221cac 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-02 - \345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-02 - \345\267\245\345\216\202\346\226\271\346\263\225\346\250\241\345\274\217.md"	
@@ -1,51 +1,51 @@
-## 2.1. 模式动机
-现在对该系统进行修改，不再设计一个按钮工厂类来统一负责所有产品的创建，而是将具体按钮的创建过程交给专门的工厂子类去完成，我们先定义一个 **抽象的按钮工厂类**，再定义 **具体的工厂类** 来生成 **圆形按钮、矩形按钮、菱形按钮** 等，它们实现在抽象按钮工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的按钮类型，只需要为这种新类型的按钮创建一个具体的工厂类就可以获得该新按钮的实例，这一特点无疑使得工厂方法模式具有超越简单工厂模式的优越性，更加符合“**开闭原则**”。
-
-## 2.2. 模式定义
-**工厂方法模式**(Factory Method Pattern)又称为工厂模式，也叫 **虚拟构造器(Virtual Constructor)模式** 或者 **多态工厂(Polymorphic Factory)模式**，它属于类 **创建型模式**。在工厂方法模式中，工 **厂父类** 负责定义创建产品对象的公共接口，而 **工厂子类** 则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
-
-## 2.3. 模式结构
-工厂方法模式包含如下角色：
-
-Product：抽象产品
-ConcreteProduct：具体产品
-Factory：抽象工厂
-ConcreteFactory：具体工厂
-
-## 2.6. 模式分析
-工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了 *面向对象的多态性*，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在 *不修改工厂角色的情况下引进新产品*。
-
-## 2.7. 实例
-日志记录器
-某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式， 现使用工厂方法模式设计该系统。
-
-##2.8. 工厂方法模式的优点
-1. 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
-2. 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。
-3. 使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个 **具体工厂和具体产品** 就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。
-## 2.9. 工厂方法模式的缺点
-1. 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
-2. 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
-## 2.10. 适用环境
-在以下情况下可以使用工厂方法模式：
-1. 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
-2. 一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
-3. 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。
-## 2.11. 模式应用
-JDBC中的工厂方法:
-``` Java
-  Connection conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://loc
-  alhost:1433; DatabaseName=DB;user=sa;password=");
-  Statement statement=conn.createStatement();
-  ResultSet rs=statement.executeQuery("select * from UserInfo");
-```
-## 2.12. 模式扩展
-1. 使用多个工厂方法：在抽象工厂角色中可以定义多个工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以包含不同的业务逻辑，以满足对不同的产品对象的需求。
-2. 产品对象的重复使用：工厂对象将已经创建过的产品保存到一个集合（如数组、List等）中，然后根据客户对产品的请求，对集合进行查询。如果有满足要求的产品对象，就直接将该产品返回客户端；如果集合中没有这样的产品对象，那么就创建一个新的满足要求的产品对象，然后将这个对象在增加到集合中，再返回给客户端。
-3. 多态性的丧失和模式的退化：如果工厂仅仅返回一个具体产品对象，便违背了工厂方法的用意，发生退化，此时就不再是工厂方法模式了。一般来说，工厂对象应当有一个抽象的父类型，如果工厂等级结构中只有一个具体工厂类的话，抽象工厂就可以省略，也将发生了退化。当只有一个具体工厂，在具体工厂中可以创建所有的产品对象，并且工厂方法设计为静态方法时，工厂方法模式就退化成简单工厂模式。
-## 2.13. 总结
-1. 工厂方法模式又称为工厂模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
-2. 工厂方法模式包含四个角色：抽象产品是定义产品的接口，是工厂方法模式所创建对象的超类型，即产品对象的共同父类或接口；具体产品实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，它们之间往往一一对应；抽象工厂中声明了工厂方法，用于返回一个产品，它是工厂方法模式的核心，任何在模式中创建对象的工厂类都必须实现该接口；具体工厂是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户调用，返回一个具体产品类的实例。
-3. 工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
-4. 工厂方法模式的主要优点是增加新的产品类时无须修改现有系统，并封装了产品对象的创建细节，系统具有良好的灵活性和可扩展性；其缺点在于增加新产品的同时需要增加新的工厂，导致系统类的个数成对增加，在一定程度上增加了系统的复杂性。
-5. 工厂方法模式适用情况包括：一个类不知道它所需要的对象的类；一个类通过其子类来指定创建哪个对象；将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。
+## 2.1. 模式动机
+现在对该系统进行修改，不再设计一个按钮工厂类来统一负责所有产品的创建，而是将具体按钮的创建过程交给专门的工厂子类去完成，我们先定义一个 **抽象的按钮工厂类**，再定义 **具体的工厂类** 来生成 **圆形按钮、矩形按钮、菱形按钮** 等，它们实现在抽象按钮工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的按钮类型，只需要为这种新类型的按钮创建一个具体的工厂类就可以获得该新按钮的实例，这一特点无疑使得工厂方法模式具有超越简单工厂模式的优越性，更加符合“**开闭原则**”。
+
+## 2.2. 模式定义
+**工厂方法模式**(Factory Method Pattern)又称为工厂模式，也叫 **虚拟构造器(Virtual Constructor)模式** 或者 **多态工厂(Polymorphic Factory)模式**，它属于类 **创建型模式**。在工厂方法模式中，工 **厂父类** 负责定义创建产品对象的公共接口，而 **工厂子类** 则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
+
+## 2.3. 模式结构
+工厂方法模式包含如下角色：
+
+Product：抽象产品
+ConcreteProduct：具体产品
+Factory：抽象工厂
+ConcreteFactory：具体工厂
+
+## 2.6. 模式分析
+工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了 *面向对象的多态性*，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在 *不修改工厂角色的情况下引进新产品*。
+
+## 2.7. 实例
+日志记录器
+某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式， 现使用工厂方法模式设计该系统。
+
+##2.8. 工厂方法模式的优点
+1. 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
+2. 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。
+3. 使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个 **具体工厂和具体产品** 就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。
+## 2.9. 工厂方法模式的缺点
+1. 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
+2. 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
+## 2.10. 适用环境
+在以下情况下可以使用工厂方法模式：
+1. 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
+2. 一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
+3. 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。
+## 2.11. 模式应用
+JDBC中的工厂方法:
+``` Java
+  Connection conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://loc
+  alhost:1433; DatabaseName=DB;user=sa;password=");
+  Statement statement=conn.createStatement();
+  ResultSet rs=statement.executeQuery("select * from UserInfo");
+```
+## 2.12. 模式扩展
+1. 使用多个工厂方法：在抽象工厂角色中可以定义多个工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以包含不同的业务逻辑，以满足对不同的产品对象的需求。
+2. 产品对象的重复使用：工厂对象将已经创建过的产品保存到一个集合（如数组、List等）中，然后根据客户对产品的请求，对集合进行查询。如果有满足要求的产品对象，就直接将该产品返回客户端；如果集合中没有这样的产品对象，那么就创建一个新的满足要求的产品对象，然后将这个对象在增加到集合中，再返回给客户端。
+3. 多态性的丧失和模式的退化：如果工厂仅仅返回一个具体产品对象，便违背了工厂方法的用意，发生退化，此时就不再是工厂方法模式了。一般来说，工厂对象应当有一个抽象的父类型，如果工厂等级结构中只有一个具体工厂类的话，抽象工厂就可以省略，也将发生了退化。当只有一个具体工厂，在具体工厂中可以创建所有的产品对象，并且工厂方法设计为静态方法时，工厂方法模式就退化成简单工厂模式。
+## 2.13. 总结
+1. 工厂方法模式又称为工厂模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
+2. 工厂方法模式包含四个角色：抽象产品是定义产品的接口，是工厂方法模式所创建对象的超类型，即产品对象的共同父类或接口；具体产品实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，它们之间往往一一对应；抽象工厂中声明了工厂方法，用于返回一个产品，它是工厂方法模式的核心，任何在模式中创建对象的工厂类都必须实现该接口；具体工厂是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户调用，返回一个具体产品类的实例。
+3. 工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
+4. 工厂方法模式的主要优点是增加新的产品类时无须修改现有系统，并封装了产品对象的创建细节，系统具有良好的灵活性和可扩展性；其缺点在于增加新产品的同时需要增加新的工厂，导致系统类的个数成对增加，在一定程度上增加了系统的复杂性。
+5. 工厂方法模式适用情况包括：一个类不知道它所需要的对象的类；一个类通过其子类来指定创建哪个对象；将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-03 - \346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-03 - \346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-03 - \346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-03 - \346\212\275\350\261\241\345\267\245\345\216\202\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-04 - \345\273\272\351\200\240\350\200\205\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-04 - \345\273\272\351\200\240\350\200\205\346\250\241\345\274\217.md"
similarity index 97%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-04 - \345\273\272\351\200\240\350\200\205\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-04 - \345\273\272\351\200\240\350\200\205\346\250\241\345\274\217.md"
index dc9df8ab..2f854197 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-04 - \345\273\272\351\200\240\350\200\205\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-04 - \345\273\272\351\200\240\350\200\205\346\250\241\345\274\217.md"	
@@ -1,63 +1,63 @@
-# Builder模式
----
-
-##1. 模式介绍
----
-
-###1.1 模式的定义
-
-将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
-
-###1.2 模式的使用场景
-
-1. 相同的方法，不同的执行顺序，产生不同的事件结果时；
-2. 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时；
-3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适；
-
-
-###1.3 Android源码中的模式实现
-
-在Android源码中，我们最常用到的Builder模式就是AlertDialog.Builder， 使用该Builder来构建复杂的AlertDialog对象。简单示例如下 :
-
-```
-//显示基本的AlertDialog  
-    private void showDialog(Context context) {  
-        AlertDialog.Builder builder = new AlertDialog.Builder(context);  
-        builder.setIcon(R.drawable.icon);  
-        builder.setTitle("Title");  
-        builder.setMessage("Message");  
-        builder.setPositiveButton("Button1",  
-                new DialogInterface.OnClickListener() {  
-                    public void onClick(DialogInterface dialog, int whichButton) {  
-                        setTitle("点击了对话框上的Button1");  
-                    }  
-                });  
-        builder.setNeutralButton("Button2",  
-                new DialogInterface.OnClickListener() {  
-                    public void onClick(DialogInterface dialog, int whichButton) {  
-                        setTitle("点击了对话框上的Button2");  
-                    }  
-                });  
-        builder.setNegativeButton("Button3",  
-                new DialogInterface.OnClickListener() {  
-                    public void onClick(DialogInterface dialog, int whichButton) {  
-                        setTitle("点击了对话框上的Button3");  
-                    }  
-                });  
-        builder.create().show();  // 构建AlertDialog， 并且显示
-    }
-```
-
-##2. 优点与缺点
----
-
-###2.1 优点
-
-* 良好的封装性， 使用建造者模式可以使客户端不必知道产品内部组成的细节；
-* 建造者独立，容易扩展；
-* 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。
-
-###2.2 缺点
-
-* 会产生多余的Builder对象以及Director对象，消耗内存；
-* 对象的构建过程暴露。
+# Builder模式
+---
+
+##1. 模式介绍
+---
+
+###1.1 模式的定义
+
+将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
+
+###1.2 模式的使用场景
+
+1. 相同的方法，不同的执行顺序，产生不同的事件结果时；
+2. 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时；
+3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适；
+
+
+###1.3 Android源码中的模式实现
+
+在Android源码中，我们最常用到的Builder模式就是AlertDialog.Builder， 使用该Builder来构建复杂的AlertDialog对象。简单示例如下 :
+
+```
+//显示基本的AlertDialog  
+    private void showDialog(Context context) {  
+        AlertDialog.Builder builder = new AlertDialog.Builder(context);  
+        builder.setIcon(R.drawable.icon);  
+        builder.setTitle("Title");  
+        builder.setMessage("Message");  
+        builder.setPositiveButton("Button1",  
+                new DialogInterface.OnClickListener() {  
+                    public void onClick(DialogInterface dialog, int whichButton) {  
+                        setTitle("点击了对话框上的Button1");  
+                    }  
+                });  
+        builder.setNeutralButton("Button2",  
+                new DialogInterface.OnClickListener() {  
+                    public void onClick(DialogInterface dialog, int whichButton) {  
+                        setTitle("点击了对话框上的Button2");  
+                    }  
+                });  
+        builder.setNegativeButton("Button3",  
+                new DialogInterface.OnClickListener() {  
+                    public void onClick(DialogInterface dialog, int whichButton) {  
+                        setTitle("点击了对话框上的Button3");  
+                    }  
+                });  
+        builder.create().show();  // 构建AlertDialog， 并且显示
+    }
+```
+
+##2. 优点与缺点
+---
+
+###2.1 优点
+
+* 良好的封装性， 使用建造者模式可以使客户端不必知道产品内部组成的细节；
+* 建造者独立，容易扩展；
+* 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。
+
+###2.2 缺点
+
+* 会产生多余的Builder对象以及Director对象，消耗内存；
+* 对象的构建过程暴露。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-05 - \345\216\237\345\236\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-05 - \345\216\237\345\236\213\346\250\241\345\274\217.md"
similarity index 97%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-05 - \345\216\237\345\236\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-05 - \345\216\237\345\236\213\346\250\241\345\274\217.md"
index 1fcd86ea..b7ddb14b 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-05 - \345\216\237\345\236\213\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-05 - \345\216\237\345\236\213\346\250\241\345\274\217.md"	
@@ -1,41 +1,41 @@
-原型模式是软件开发中一种创造性的设计模式。
-当要创建的对象的类型由一个原型实例确定时，它被克隆以生成新的对象。此模式用于：**避免客户端应用程序中的对象生成器的子类**，
-如抽象工厂模式。-避免以标准方式创建新对象的固有成本（例如，使用“新”关键字）
-
-
-#原型模式
----
-
-##模式介绍  
-
-###模式的定义
-
-用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
-
-### 模式的使用场景
-
-1. 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗；
-2. 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；
-3. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
-
-##Android源码中的模式实现
-
-Intent中使用了原型模式
-
-```
-Uri uri = Uri.parse("smsto:0800000123");    
-    Intent shareIntent = new Intent(Intent.ACTION_SENDTO, uri);    
-    shareIntent.putExtra("sms_body", "The SMS text");    
-
-    Intent intent = (Intent)shareIntent.clone() ;
-    startActivity(intent);
-```
-
-##优点与缺点
-
-###优点
-原型模式是在内存二进制流的拷贝，要比直接 new 一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
-
-
-###缺点
-这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的，在实际开发当中应该注意这个潜在的问题。优点就是减少了约束，缺点也是减少了约束，需要大家在实际应用时考虑。
+原型模式是软件开发中一种创造性的设计模式。
+当要创建的对象的类型由一个原型实例确定时，它被克隆以生成新的对象。此模式用于：**避免客户端应用程序中的对象生成器的子类**，
+如抽象工厂模式。-避免以标准方式创建新对象的固有成本（例如，使用“新”关键字）
+
+
+#原型模式
+---
+
+##模式介绍  
+
+###模式的定义
+
+用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
+
+### 模式的使用场景
+
+1. 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗；
+2. 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；
+3. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
+
+##Android源码中的模式实现
+
+Intent中使用了原型模式
+
+```
+Uri uri = Uri.parse("smsto:0800000123");    
+    Intent shareIntent = new Intent(Intent.ACTION_SENDTO, uri);    
+    shareIntent.putExtra("sms_body", "The SMS text");    
+
+    Intent intent = (Intent)shareIntent.clone() ;
+    startActivity(intent);
+```
+
+##优点与缺点
+
+###优点
+原型模式是在内存二进制流的拷贝，要比直接 new 一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
+
+
+###缺点
+这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的，在实际开发当中应该注意这个潜在的问题。优点就是减少了约束，缺点也是减少了约束，需要大家在实际应用时考虑。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-06 - \345\215\225\344\276\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-06 - \345\215\225\344\276\213\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/01-06 - \345\215\225\344\276\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/01-06 - \345\215\225\344\276\213\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02- \347\273\223\346\236\204\345\236\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02- \347\273\223\346\236\204\345\236\213\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02- \347\273\223\346\236\204\345\236\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02- \347\273\223\346\236\204\345\236\213\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-01- \351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-01- \351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"
similarity index 97%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-01- \351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-01- \351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"
index d7491f43..d9c3693d 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-01- \351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-01- \351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"	
@@ -1,13 +1,13 @@
-
-适配器可以帮助两个不兼容的接口一起工作。这是真实世界的定义适配器。
-
-接口可能是不兼容的，但内部功能应该符合需要。
-
-适配器设计模式允许其他不兼容类通过转换一起工作。
-
-一个类的接口成为客户端期望的接口。
-
-适配器模式有两种变体：
-类适配器实现适配器的接口，而对象适配器使用合成器在适配器对象中包含适配器。
-
-本示例使用对象适配器方法。
+
+适配器可以帮助两个不兼容的接口一起工作。这是真实世界的定义适配器。
+
+接口可能是不兼容的，但内部功能应该符合需要。
+
+适配器设计模式允许其他不兼容类通过转换一起工作。
+
+一个类的接口成为客户端期望的接口。
+
+适配器模式有两种变体：
+类适配器实现适配器的接口，而对象适配器使用合成器在适配器对象中包含适配器。
+
+本示例使用对象适配器方法。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-02- \346\241\245\346\216\245\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-02- \346\241\245\346\216\245\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-02- \346\241\245\346\216\245\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-02- \346\241\245\346\216\245\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-03- \347\273\204\345\220\210\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-03- \347\273\204\345\220\210\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-03- \347\273\204\345\220\210\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-03- \347\273\204\345\220\210\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-04- \350\243\205\351\245\260\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-04- \350\243\205\351\245\260\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-04- \350\243\205\351\245\260\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-04- \350\243\205\351\245\260\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-05- \345\244\226\350\247\202\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-05- \345\244\226\350\247\202\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-05- \345\244\226\350\247\202\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-05- \345\244\226\350\247\202\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-06- \344\272\253\345\205\203\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-06- \344\272\253\345\205\203\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-06- \344\272\253\345\205\203\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-06- \344\272\253\345\205\203\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-07- \344\273\243\347\220\206\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-07- \344\273\243\347\220\206\346\250\241\345\274\217.md"
similarity index 99%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-07- \344\273\243\347\220\206\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-07- \344\273\243\347\220\206\346\250\241\345\274\217.md"
index 2cf8125b..79e4cde6 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-07- \344\273\243\347\220\206\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-07- \344\273\243\347\220\206\346\250\241\345\274\217.md"	
@@ -1,57 +1,57 @@
-## 6.1. 模式动机
-在某些情况下，一个客户不想或者不能 **直接引用** 一个对象，此时可以通过一个称之为“代理”的第三者来实现 **间接引用**。代理对象可以在客户端和目标对象之间起到 **中介** 的作用，并且可以通过代理对象去掉客户不能看到 的内容和服务或者添加客户需要的额外服务。
-
-通过引入一个 **新的对象**（如小图片和远程代理 对象）来 **实现** **对** **真实对象** 的 **操作** 或者 **将新的对象作为真实对象的一个替身**，这种实现机制即 为 **代理模式**，通过引入代理对象来间接访问一 个对象，这就是代理模式的模式动机。
-
-## 6.2. 模式定义
-代理模式(Proxy Pattern) ：给某一个对象提供一个代 理，并由代理对象控制对原对象的引用。代理模式的英 文叫做Proxy或Surrogate，它是一种 **对象结构型** 模式。
-
-## 6.3. 模式结构
-代理模式包含如下角色：
-
-Subject: 抽象主题角色
-Proxy: 代理主题角色
-RealSubject: 真实主题角色
-
-## 6.8. 优点
-代理模式的优点
-1. 代理模式能够协调调用者和被调用者，在一定程度上 **降低了系统的耦合度**。
-2. **远程代理** 使得客户端可以访问在 **远程机器上的对象**，远程机器 可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。
-3. 虚拟代理通过使用一个小对象来代表一个大对象，可以 **减少系统资源的消耗**，**对系统进行优化并提高运行速度**。
-4. 保护代理可以控制对 **真实对象的使用权限**。
-
-## 6.9. 缺点
-代理模式的缺点
-1. 由于在客户端和真实主题之间增加了代理对象，因此 有些类型的代理模式可能会造成请求的 **处理速度变慢**。
-2. 实现代理模式需要额外的工作，有些代理模式的实现 **非常复杂**。
-
-## 6.10. 适用环境
-根据代理模式的使用目的，常见的代理模式有以下几种类型：
-
-**远程(Remote)代理**：为一个位于不同的地址空间的对象提供一个本地 的代理对象，这个不同的地址空间可以是在同一台主机中，也可是在 另一台主机中，远程代理又叫做大使(Ambassador)。
-**虚拟(Virtual)代理**：如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。
-**Copy-on-Write代理**：它是虚拟代理的一种，把复制（克隆）操作延迟 到只有在客户端真正需要时才执行。一般来说，对象的深克隆是一个 开销较大的操作，Copy-on-Write代理可以让这个操作延迟，只有对象被用到的时候才被克隆。
-**保护(Protect or Access)代理**：控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。
-**缓冲(Cache)代理**：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
-**防火墙(Firewall)代理**：保护目标不让恶意用户接近。
-**同步化(Synchronization)代理**：使几个用户能够同时使用一个对象而没有冲突。
-**智能引用(Smart Reference)代理**：当一个对象被引用时，提供一些额外的操作，如将此对象被调用的次数记录下来等。
-
-## 6.11. 模式应用
-EJB、Web Service等分布式技术都是代理模式的应用。在EJB中使用了RMI机制，远程服务器中的企业级Bean在本地有一个桩代理，客户端通过桩来调用远程对象中定义的方法，而无须直接与远程对象交互。在EJB的使用中需要提供一个公共的接口，客户端针对该接口进行编程，无须知道桩以及远程EJB的实现细节。
-
-## 6.12. 模式扩展
-几种常用的代理模式
-**图片代理**：一个很常见的代理模式的应用实例就是对大图浏览的控制。
-用户通过浏览器访问网页时先不加载真实的大图，而是通过代理对象的方法来进行处理，在代理对象的方法中，先使用一个线程向客户端浏览器加载一个小图片，然后在后台使用另一个线程来调用大图片的加载方法将大图片加载到客户端。当需要浏览大图片时，再将大图片在新网页中显示。如果用户在浏览大图时加载工作还没有完成，可以再启动一个线程来显示相应的提示信息。通过代理技术结合多线程编程将真实图片的加载放到后台来操作，不影响前台图片的浏览。
-**远程代理**：远程代理可以将网络的细节隐藏起来，使得客户端不必考虑网络的存在。客户完全可以认为被代理的远程业务对象是局域的而不是远程的，而远程代理对象承担了大部分的网络通信工作。
-**虚拟代理**：当一个对象的加载十分耗费资源的时候，虚拟代理的优势就非常明显地体现出来了。虚拟代理模式是一种内存节省技术，那些占用大量内存或处理复杂的对象将推迟到使用它的时候才创建。
--在应用程序启动的时候，可以用代理对象代替真实对象初始化，节省了内存的占用，并大大加速了系统的启动时间。
-
-**动态代理**
-动态代理是一种较为高级的代理模式，它的典型应用就是 **Spring AOP**。
-在传统的代理模式中，客户端通过Proxy调用RealSubject类的request()方法，同时还在代理类中封装了其他方法(如preRequest()和postRequest())，可以处理一些其他问题。
-如果按照这种方法使用代理模式，那么真实主题角色必须是事先已经存在的，并将其作为代理对象的内部成员属性。如果一个真实主题角色必须对应一个代理主题角色，这将导致系统中的类个数急剧增加，因此需要想办法减少系统中类的个数，此外，如何在事先不知道真实主题角色的情况下使用代理主题角色，这都是动态代理需要解决的问题。
-
-## 6.13. 总结
-在代理模式中，要求给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式的英文叫做Proxy或Surrogate，它是一种对象结构型模式。 - 代理模式包含三个角色：抽象主题角色声明了真实主题和代理主题的共同接口；代理主题角色内部包含对真实主题的引用，从而可以在任何时候操作真实主题对象；真实主题角色定义了代理角色所代表的真实对象，在真实主题角色中实现了真实的业务操作，客户端可以通过代理主题角色间接调用真实主题角色中定义的方法。 - 代理模式的优点在于能够协调调用者和被调用者，在一定程度上降低了系统的耦合度；其缺点在于由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢，并且实现代理模式需要额外的工作，有些代理模式的实现非常复杂。远程代理为一个位于不同的地址空间的对象提供一个本地的代表对象，它使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。- 如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建，这个小对象称为虚拟代理。虚拟代理通过使用一个小对象来代表一个大对象，可以减少系统资源的消耗，对系统进行优化并提高运行速度。 - 保护代理可以控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。
+## 6.1. 模式动机
+在某些情况下，一个客户不想或者不能 **直接引用** 一个对象，此时可以通过一个称之为“代理”的第三者来实现 **间接引用**。代理对象可以在客户端和目标对象之间起到 **中介** 的作用，并且可以通过代理对象去掉客户不能看到 的内容和服务或者添加客户需要的额外服务。
+
+通过引入一个 **新的对象**（如小图片和远程代理 对象）来 **实现** **对** **真实对象** 的 **操作** 或者 **将新的对象作为真实对象的一个替身**，这种实现机制即 为 **代理模式**，通过引入代理对象来间接访问一 个对象，这就是代理模式的模式动机。
+
+## 6.2. 模式定义
+代理模式(Proxy Pattern) ：给某一个对象提供一个代 理，并由代理对象控制对原对象的引用。代理模式的英 文叫做Proxy或Surrogate，它是一种 **对象结构型** 模式。
+
+## 6.3. 模式结构
+代理模式包含如下角色：
+
+Subject: 抽象主题角色
+Proxy: 代理主题角色
+RealSubject: 真实主题角色
+
+## 6.8. 优点
+代理模式的优点
+1. 代理模式能够协调调用者和被调用者，在一定程度上 **降低了系统的耦合度**。
+2. **远程代理** 使得客户端可以访问在 **远程机器上的对象**，远程机器 可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。
+3. 虚拟代理通过使用一个小对象来代表一个大对象，可以 **减少系统资源的消耗**，**对系统进行优化并提高运行速度**。
+4. 保护代理可以控制对 **真实对象的使用权限**。
+
+## 6.9. 缺点
+代理模式的缺点
+1. 由于在客户端和真实主题之间增加了代理对象，因此 有些类型的代理模式可能会造成请求的 **处理速度变慢**。
+2. 实现代理模式需要额外的工作，有些代理模式的实现 **非常复杂**。
+
+## 6.10. 适用环境
+根据代理模式的使用目的，常见的代理模式有以下几种类型：
+
+**远程(Remote)代理**：为一个位于不同的地址空间的对象提供一个本地 的代理对象，这个不同的地址空间可以是在同一台主机中，也可是在 另一台主机中，远程代理又叫做大使(Ambassador)。
+**虚拟(Virtual)代理**：如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。
+**Copy-on-Write代理**：它是虚拟代理的一种，把复制（克隆）操作延迟 到只有在客户端真正需要时才执行。一般来说，对象的深克隆是一个 开销较大的操作，Copy-on-Write代理可以让这个操作延迟，只有对象被用到的时候才被克隆。
+**保护(Protect or Access)代理**：控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。
+**缓冲(Cache)代理**：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
+**防火墙(Firewall)代理**：保护目标不让恶意用户接近。
+**同步化(Synchronization)代理**：使几个用户能够同时使用一个对象而没有冲突。
+**智能引用(Smart Reference)代理**：当一个对象被引用时，提供一些额外的操作，如将此对象被调用的次数记录下来等。
+
+## 6.11. 模式应用
+EJB、Web Service等分布式技术都是代理模式的应用。在EJB中使用了RMI机制，远程服务器中的企业级Bean在本地有一个桩代理，客户端通过桩来调用远程对象中定义的方法，而无须直接与远程对象交互。在EJB的使用中需要提供一个公共的接口，客户端针对该接口进行编程，无须知道桩以及远程EJB的实现细节。
+
+## 6.12. 模式扩展
+几种常用的代理模式
+**图片代理**：一个很常见的代理模式的应用实例就是对大图浏览的控制。
+用户通过浏览器访问网页时先不加载真实的大图，而是通过代理对象的方法来进行处理，在代理对象的方法中，先使用一个线程向客户端浏览器加载一个小图片，然后在后台使用另一个线程来调用大图片的加载方法将大图片加载到客户端。当需要浏览大图片时，再将大图片在新网页中显示。如果用户在浏览大图时加载工作还没有完成，可以再启动一个线程来显示相应的提示信息。通过代理技术结合多线程编程将真实图片的加载放到后台来操作，不影响前台图片的浏览。
+**远程代理**：远程代理可以将网络的细节隐藏起来，使得客户端不必考虑网络的存在。客户完全可以认为被代理的远程业务对象是局域的而不是远程的，而远程代理对象承担了大部分的网络通信工作。
+**虚拟代理**：当一个对象的加载十分耗费资源的时候，虚拟代理的优势就非常明显地体现出来了。虚拟代理模式是一种内存节省技术，那些占用大量内存或处理复杂的对象将推迟到使用它的时候才创建。
+-在应用程序启动的时候，可以用代理对象代替真实对象初始化，节省了内存的占用，并大大加速了系统的启动时间。
+
+**动态代理**
+动态代理是一种较为高级的代理模式，它的典型应用就是 **Spring AOP**。
+在传统的代理模式中，客户端通过Proxy调用RealSubject类的request()方法，同时还在代理类中封装了其他方法(如preRequest()和postRequest())，可以处理一些其他问题。
+如果按照这种方法使用代理模式，那么真实主题角色必须是事先已经存在的，并将其作为代理对象的内部成员属性。如果一个真实主题角色必须对应一个代理主题角色，这将导致系统中的类个数急剧增加，因此需要想办法减少系统中类的个数，此外，如何在事先不知道真实主题角色的情况下使用代理主题角色，这都是动态代理需要解决的问题。
+
+## 6.13. 总结
+在代理模式中，要求给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式的英文叫做Proxy或Surrogate，它是一种对象结构型模式。 - 代理模式包含三个角色：抽象主题角色声明了真实主题和代理主题的共同接口；代理主题角色内部包含对真实主题的引用，从而可以在任何时候操作真实主题对象；真实主题角色定义了代理角色所代表的真实对象，在真实主题角色中实现了真实的业务操作，客户端可以通过代理主题角色间接调用真实主题角色中定义的方法。 - 代理模式的优点在于能够协调调用者和被调用者，在一定程度上降低了系统的耦合度；其缺点在于由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢，并且实现代理模式需要额外的工作，有些代理模式的实现非常复杂。远程代理为一个位于不同的地址空间的对象提供一个本地的代表对象，它使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。- 如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建，这个小对象称为虚拟代理。虚拟代理通过使用一个小对象来代表一个大对象，可以减少系统资源的消耗，对系统进行优化并提高运行速度。 - 保护代理可以控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-08- \345\247\224\346\264\276\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-08- \345\247\224\346\264\276\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-08- \345\247\224\346\264\276\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-08- \345\247\224\346\264\276\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-09\344\273\243\347\220\206 vs \345\247\224\346\211\230 \350\257\255\344\271\211.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-09\344\273\243\347\220\206 vs \345\247\224\346\211\230 \350\257\255\344\271\211.md"
similarity index 99%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-09\344\273\243\347\220\206 vs \345\247\224\346\211\230 \350\257\255\344\271\211.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-09\344\273\243\347\220\206 vs \345\247\224\346\211\230 \350\257\255\344\271\211.md"
index 6bf65c4c..24900b14 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/02-09\344\273\243\347\220\206 vs \345\247\224\346\211\230 \350\257\255\344\271\211.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/02-09\344\273\243\347\220\206 vs \345\247\224\346\211\230 \350\257\255\344\271\211.md"	
@@ -1,4 +1,4 @@
-
-proxy :译为代理， 被代理方（B）与代理方（A）的接口完全一致。 主要使用场景（语义）应该是：为简化编程（或无法操作B），不直接把请求交给被代理方（B），而把请求交给代码方（A），由代理方与被代理方进行通信，以完成请求。
-
-delegete : 译为委托，主要语义是：一件事情（或一个请求）对象本身不知道怎样处理，对象把请求交给其它对象来做。
+
+proxy :译为代理， 被代理方（B）与代理方（A）的接口完全一致。 主要使用场景（语义）应该是：为简化编程（或无法操作B），不直接把请求交给被代理方（B），而把请求交给代码方（A），由代理方与被代理方进行通信，以完成请求。
+
+delegete : 译为委托，主要语义是：一件事情（或一个请求）对象本身不知道怎样处理，对象把请求交给其它对象来做。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03- \350\241\214\344\270\272\345\236\213\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03- \350\241\214\344\270\272\345\236\213\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03- \350\241\214\344\270\272\345\236\213\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03- \350\241\214\344\270\272\345\236\213\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-01- \345\221\275\344\273\244\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-01- \345\221\275\344\273\244\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-01- \345\221\275\344\273\244\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-01- \345\221\275\344\273\244\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-02- \344\270\255\344\273\213\350\200\205\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-02- \344\270\255\344\273\213\350\200\205\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-02- \344\270\255\344\273\213\350\200\205\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-02- \344\270\255\344\273\213\350\200\205\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-03- \350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-03- \350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"
similarity index 99%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-03- \350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-03- \350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"
index 974a6669..6593473d 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-03- \350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-03- \350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"	
@@ -1,2 +1,2 @@
-## 3.1. 模式动机
-建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机。
+## 3.1. 模式动机
+建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-04- \347\212\266\346\200\201\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-04- \347\212\266\346\200\201\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-04- \347\212\266\346\200\201\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-04- \347\212\266\346\200\201\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-05- \347\255\226\347\225\245\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-05- \347\255\226\347\225\245\346\250\241\345\274\217.md"
similarity index 99%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-05- \347\255\226\347\225\245\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-05- \347\255\226\347\225\245\346\250\241\345\274\217.md"
index 4f4eb850..a360e19d 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-05- \347\255\226\347\225\245\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-05- \347\255\226\347\225\245\346\250\241\345\274\217.md"	
@@ -1,60 +1,60 @@
-策略模式（也称为策略模式）是一种软件设计模式，可以在 **运行时选择算法的行为**。
-
-## 5.1. 模式动机
-完成一项任务，往往可以有多种不同的方式，每一种方式称为一个策略，我们可以根据环境或者条件的不同选择不同的策略来完成该项任务。
-在软件开发中也常常遇到类似的情况，实现某一个功能有多个途径，此时可以 **使用一种设计模式来使得系统可以灵活地选择解决途径，也能够方便地增加新的解决途径**。
-在软件系统中，有许多算法可以实现某一功能，如查找、排序等，一种常用的方法是 **硬编码(Hard Coding)** 在一个类中，如需要提供多种查找算法，可以将这些算法写到一个类中，在该类中提供多个方法，每一个方法对应一个具体的查找算法；当然也可以将这些查找算法封装在一个统一的方法中，通过if…else…等条件判断语句来进行选择。这两种实现方法我们都可以称之为硬编码，如果需要增加一种新的查找算法，需要修改封装算法类的源代码；更换查找算法，也需要修改客户端调用代码。在这个算法类中封装了大量查找算法，该类代码将较复杂，维护较为困难。
-除了提供专门的查找算法类之外，还可以在客户端程序中直接包含算法代码，这种做法更不可取，将导致客户端程序庞大而且难以维护，如果存在大量可供选择的算法时问题将变得更加严重。
-为了解决这些问题，可以 **定义一些独立的类来封装不同的算法**，每一个类封装一个具体的算法，在这里，**每一个封装算法的类我们都可以称之为策略(Strategy)**，为了保证这些策略的一致性，一般会用 **一个抽象的策略类** 来做算法的定义，而 **具体每种算法** 则对应于 **一个具体策略类** 。
-
-## 5.2. 模式定义
-策略模式(Strategy Pattern)：定义 **一系列算法**，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。
-
-策略模式是一种对象行为型模式。
-
-## 5.3. 模式结构
-策略模式包含如下角色：
-
-Context: 环境类
-Strategy: 抽象策略类
-ConcreteStrategy: 具体策略类
-
-## 5.6. 模式分析
-1.  策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
-2. 在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。
-3. 策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。
-
-## 5.8. 优点
-策略模式的优点
-
-1. 策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。
-2. 策略模式提供了管理相关的算法族的办法。
-3. 策略模式提供了可以替换继承关系的办法。
-4. 使用策略模式可以避免使用多重条件转移语句。
-
-## 5.9. 缺点
-策略模式的缺点
-1. 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
-2. 策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量。
-## 5.10. 适用环境
-在以下情况下可以使用策略模式：
-
-1. 如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
-2. 一个系统需要动态地在几种算法中选择一种。
-3. 如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
-4. 不希望客户端知道复杂的、与算法相关的数据结构，在具体策略类中封装算法和相关的数据结构，提高算法的保密性与安全性。
-
-## 5.12. 模式扩展
-策略模式与状态模式
-
-1. 可以通过环境类状态的个数来决定是使用策略模式还是状态模式。
-2. 策略模式的环境类自己选择一个具体策略类，具体策略类无须关心环境类；而状态模式的环境类由于外在因素需要放进一个具体状态中，以便通过其方法实现状态的切换，因此环境类和状态类之间存在一种双向的关联关系。
-3. 使用策略模式时，客户端需要知道所选的具体策略是哪一个，而使用状态模式时，客户端无须关心具体状态，环境类的状态会根据用户的操作自动转换。
-4. 如果系统中某个类的对象存在多种状态，不同状态下行为有差异，而且这些状态之间可以发生转换时使用状态模式；如果系统中某个类的某一行为存在多种实现方式，而且这些实现方式可以互换时使用策略模式。
-
-## 5.13. 总结
-1. 在策略模式中定义了一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式。策略模式是一种对象行为型模式。
-2. 策略模式包含三个角色：环境类在解决某个问题时可以采用多种策略，在环境类中维护一个对抽象策略类的引用实例；抽象策略类为所支持的算法声明了抽象方法，是所有策略类的父类；具体策略类实现了在抽象策略类中定义的算法。
-3. 策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。
-4. 策略模式主要优点在于对“开闭原则”的完美支持，在不修改原有系统的基础上可以更换算法或者增加新的算法，它很好地管理算法族，提高了代码的复用性，是一种替换继承，避免多重条件转移语句的实现方式；其缺点在于客户端必须知道所有的策略类，并理解其区别，同时在一定程度上增加了系统中类的个数，可能会存在很多策略类。
-5. 策略模式适用情况包括：在一个系统里面有许多类，它们之间的区别仅在于它们的行为，使用策略模式可以动态地让一个对象在许多行为中选择一种行为；一个系统需要动态地在几种算法中选择一种；避免使用难以维护的多重条件选择语句；希望在具体策略类中封装算法和与相关的数据结构。
+策略模式（也称为策略模式）是一种软件设计模式，可以在 **运行时选择算法的行为**。
+
+## 5.1. 模式动机
+完成一项任务，往往可以有多种不同的方式，每一种方式称为一个策略，我们可以根据环境或者条件的不同选择不同的策略来完成该项任务。
+在软件开发中也常常遇到类似的情况，实现某一个功能有多个途径，此时可以 **使用一种设计模式来使得系统可以灵活地选择解决途径，也能够方便地增加新的解决途径**。
+在软件系统中，有许多算法可以实现某一功能，如查找、排序等，一种常用的方法是 **硬编码(Hard Coding)** 在一个类中，如需要提供多种查找算法，可以将这些算法写到一个类中，在该类中提供多个方法，每一个方法对应一个具体的查找算法；当然也可以将这些查找算法封装在一个统一的方法中，通过if…else…等条件判断语句来进行选择。这两种实现方法我们都可以称之为硬编码，如果需要增加一种新的查找算法，需要修改封装算法类的源代码；更换查找算法，也需要修改客户端调用代码。在这个算法类中封装了大量查找算法，该类代码将较复杂，维护较为困难。
+除了提供专门的查找算法类之外，还可以在客户端程序中直接包含算法代码，这种做法更不可取，将导致客户端程序庞大而且难以维护，如果存在大量可供选择的算法时问题将变得更加严重。
+为了解决这些问题，可以 **定义一些独立的类来封装不同的算法**，每一个类封装一个具体的算法，在这里，**每一个封装算法的类我们都可以称之为策略(Strategy)**，为了保证这些策略的一致性，一般会用 **一个抽象的策略类** 来做算法的定义，而 **具体每种算法** 则对应于 **一个具体策略类** 。
+
+## 5.2. 模式定义
+策略模式(Strategy Pattern)：定义 **一系列算法**，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。
+
+策略模式是一种对象行为型模式。
+
+## 5.3. 模式结构
+策略模式包含如下角色：
+
+Context: 环境类
+Strategy: 抽象策略类
+ConcreteStrategy: 具体策略类
+
+## 5.6. 模式分析
+1.  策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
+2. 在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。
+3. 策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。
+
+## 5.8. 优点
+策略模式的优点
+
+1. 策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。
+2. 策略模式提供了管理相关的算法族的办法。
+3. 策略模式提供了可以替换继承关系的办法。
+4. 使用策略模式可以避免使用多重条件转移语句。
+
+## 5.9. 缺点
+策略模式的缺点
+1. 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
+2. 策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量。
+## 5.10. 适用环境
+在以下情况下可以使用策略模式：
+
+1. 如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
+2. 一个系统需要动态地在几种算法中选择一种。
+3. 如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
+4. 不希望客户端知道复杂的、与算法相关的数据结构，在具体策略类中封装算法和相关的数据结构，提高算法的保密性与安全性。
+
+## 5.12. 模式扩展
+策略模式与状态模式
+
+1. 可以通过环境类状态的个数来决定是使用策略模式还是状态模式。
+2. 策略模式的环境类自己选择一个具体策略类，具体策略类无须关心环境类；而状态模式的环境类由于外在因素需要放进一个具体状态中，以便通过其方法实现状态的切换，因此环境类和状态类之间存在一种双向的关联关系。
+3. 使用策略模式时，客户端需要知道所选的具体策略是哪一个，而使用状态模式时，客户端无须关心具体状态，环境类的状态会根据用户的操作自动转换。
+4. 如果系统中某个类的对象存在多种状态，不同状态下行为有差异，而且这些状态之间可以发生转换时使用状态模式；如果系统中某个类的某一行为存在多种实现方式，而且这些实现方式可以互换时使用策略模式。
+
+## 5.13. 总结
+1. 在策略模式中定义了一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式。策略模式是一种对象行为型模式。
+2. 策略模式包含三个角色：环境类在解决某个问题时可以采用多种策略，在环境类中维护一个对抽象策略类的引用实例；抽象策略类为所支持的算法声明了抽象方法，是所有策略类的父类；具体策略类实现了在抽象策略类中定义的算法。
+3. 策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。
+4. 策略模式主要优点在于对“开闭原则”的完美支持，在不修改原有系统的基础上可以更换算法或者增加新的算法，它很好地管理算法族，提高了代码的复用性，是一种替换继承，避免多重条件转移语句的实现方式；其缺点在于客户端必须知道所有的策略类，并理解其区别，同时在一定程度上增加了系统中类的个数，可能会存在很多策略类。
+5. 策略模式适用情况包括：在一个系统里面有许多类，它们之间的区别仅在于它们的行为，使用策略模式可以动态地让一个对象在许多行为中选择一种行为；一个系统需要动态地在几种算法中选择一种；避免使用难以维护的多重条件选择语句；希望在具体策略类中封装算法和与相关的数据结构。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-10- \346\250\241\346\235\277\346\226\271\346\263\225\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-10- \346\250\241\346\235\277\346\226\271\346\263\225\346\250\241\345\274\217.md"
similarity index 98%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-10- \346\250\241\346\235\277\346\226\271\346\263\225\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-10- \346\250\241\346\235\277\346\226\271\346\263\225\346\250\241\345\274\217.md"
index b8d348ac..f19cad57 100644
--- "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/03-10- \346\250\241\346\235\277\346\226\271\346\263\225\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/03-10- \346\250\241\346\235\277\346\226\271\346\263\225\346\250\241\345\274\217.md"	
@@ -1 +1 @@
-模板方法为算法定义了一个框架。 算法子类为空白部分提供实现。
+模板方法为算法定义了一个框架。 算法子类为空白部分提供实现。
diff --git "a/000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/README.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/README.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\346\210\221\347\232\204\347\220\206\350\247\243/README.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\346\210\221\347\232\204\347\220\206\350\247\243/README.md"
diff --git "a/000 - 3 Design Patterns/\347\255\226\347\225\245\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\347\255\226\347\225\245\346\250\241\345\274\217.md"
similarity index 96%
rename from "000 - 3 Design Patterns/\347\255\226\347\225\245\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\347\255\226\347\225\245\346\250\241\345\274\217.md"
index da5b74e3..92dbce22 100644
--- "a/000 - 3 Design Patterns/\347\255\226\347\225\245\346\250\241\345\274\217.md"	
+++ "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\347\255\226\347\225\245\346\250\241\345\274\217.md"	
@@ -1,33 +1,33 @@
-#策略模式
----
-
-##模式的定义
-
-策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
-
-注：针对同一类型操作，将复杂多样的处理方式分别开来，有选择的实现各自特有的操作。
-
-##模式的使用场景
-
-* 针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。
-* 需要安全的封装多种同一类型的操作时。
-* 出现同一抽象多个子类，而又需要使用if-else 或者 switch-case来选择时。
-
-##Android源码中的模式实现
-
-
-
-
-策略模式主要用来分离算法，根据相同的行为抽象来做不同的具体策略实现。
-
-##优缺点
-
-###优点：
-
-* 结构清晰明了、使用简单直观。
-* 耦合度相对而言较低，扩展方便。
-* 操作封装也更为彻底，数据更为安全。
-
-###缺点：
-
-* 随着策略的增加，子类也会变得繁多。
+#策略模式
+---
+
+##模式的定义
+
+策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
+
+注：针对同一类型操作，将复杂多样的处理方式分别开来，有选择的实现各自特有的操作。
+
+##模式的使用场景
+
+* 针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。
+* 需要安全的封装多种同一类型的操作时。
+* 出现同一抽象多个子类，而又需要使用if-else 或者 switch-case来选择时。
+
+##Android源码中的模式实现
+
+
+
+
+策略模式主要用来分离算法，根据相同的行为抽象来做不同的具体策略实现。
+
+##优缺点
+
+###优点：
+
+* 结构清晰明了、使用简单直观。
+* 耦合度相对而言较低，扩展方便。
+* 操作封装也更为彻底，数据更为安全。
+
+###缺点：
+
+* 随着策略的增加，子类也会变得繁多。
diff --git "a/000 - 3 Design Patterns/\347\256\200\345\215\225\345\267\245\345\216\202.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\347\256\200\345\215\225\345\267\245\345\216\202.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\347\256\200\345\215\225\345\267\245\345\216\202.md"
diff --git "a/000 - 3 Design Patterns/\350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\350\247\202\345\257\237\350\200\205\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\350\264\243\344\273\273\351\223\276\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\350\264\243\344\273\273\351\223\276\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\350\264\243\344\273\273\351\223\276\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\350\264\243\344\273\273\351\223\276\346\250\241\345\274\217.md"
diff --git "a/000 - 3 Design Patterns/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md" "b/000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"
similarity index 100%
rename from "000 - 3 Design Patterns/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"
rename to "000 - 3 Design Patterns \350\256\276\350\256\241\346\250\241\345\274\217/\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217.md"
diff --git "a/01 - JavaSE/0000 Java \345\216\206\345\217\262 .md" "b/01 - JavaSE Java\346\240\270\345\277\203/0000 Java \345\216\206\345\217\262 .md"
similarity index 100%
rename from "01 - JavaSE/0000 Java \345\216\206\345\217\262 .md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/0000 Java \345\216\206\345\217\262 .md"
diff --git "a/01 - JavaSE/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.1 \345\244\232\347\272\277\347\250\213\344\271\213\345\206\205\345\255\230\345\217\257\350\247\201\346\200\247.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.1 \345\244\232\347\272\277\347\250\213\344\271\213\345\206\205\345\255\230\345\217\257\350\247\201\346\200\247.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.1 \345\244\232\347\272\277\347\250\213\344\271\213\345\206\205\345\255\230\345\217\257\350\247\201\346\200\247.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.1 \345\244\232\347\272\277\347\250\213\344\271\213\345\206\205\345\255\230\345\217\257\350\247\201\346\200\247.md"
diff --git "a/01 - JavaSE/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.2 \345\206\205\345\255\230\346\250\241\345\236\213FAQ.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.2 \345\206\205\345\255\230\346\250\241\345\236\213FAQ.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.2 \345\206\205\345\255\230\346\250\241\345\236\213FAQ.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/1.1.2 \345\206\205\345\255\230\346\250\241\345\236\213FAQ.md"
diff --git "a/01 - JavaSE/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/README.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.1 \345\206\205\345\255\230\346\250\241\345\236\213/README.md"
diff --git "a/01 - JavaSE/01 - JVM/1.2 \345\206\205\345\255\230\347\256\241\347\220\206/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.2 \345\206\205\345\255\230\347\256\241\347\220\206/README.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.2 \345\206\205\345\255\230\347\256\241\347\220\206/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.2 \345\206\205\345\255\230\347\256\241\347\220\206/README.md"
diff --git "a/01 - JavaSE/01 - JVM/1.3 \345\240\206\345\222\214\346\240\210/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.3 \345\240\206\345\222\214\346\240\210/README.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.3 \345\240\206\345\222\214\346\240\210/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.3 \345\240\206\345\222\214\346\240\210/README.md"
diff --git "a/01 - JavaSE/01 - JVM/1.4 \345\236\203\345\234\276\345\233\236\346\224\266/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.4 \345\236\203\345\234\276\345\233\236\346\224\266/README.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.4 \345\236\203\345\234\276\345\233\236\346\224\266/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.4 \345\236\203\345\234\276\345\233\236\346\224\266/README.md"
diff --git "a/01 - JavaSE/01 - JVM/1.5 \345\217\202\346\225\260\345\217\212\350\260\203\344\274\230/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.5 \345\217\202\346\225\260\345\217\212\350\260\203\344\274\230/README.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/1.5 \345\217\202\346\225\260\345\217\212\350\260\203\344\274\230/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/1.5 \345\217\202\346\225\260\345\217\212\350\260\203\344\274\230/README.md"
diff --git a/01 - JavaSE/01 - JVM/JVM - all.md "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - all.md"
similarity index 100%
rename from 01 - JavaSE/01 - JVM/JVM - all.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - all.md"
diff --git a/01 - JavaSE/01 - JVM/JVM - all2.md "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - all2.md"
similarity index 100%
rename from 01 - JavaSE/01 - JVM/JVM - all2.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - all2.md"
diff --git a/01 - JavaSE/01 - JVM/JVM - tree.txt "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - tree.txt"
similarity index 100%
rename from 01 - JavaSE/01 - JVM/JVM - tree.txt
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - tree.txt"
diff --git "a/01 - JavaSE/01 - JVM/JVM - \345\206\205\345\255\230\346\250\241\345\236\213.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \345\206\205\345\255\230\346\250\241\345\236\213.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM - \345\206\205\345\255\230\346\250\241\345\236\213.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \345\206\205\345\255\230\346\250\241\345\236\213.md"
diff --git "a/01 - JavaSE/01 - JVM/JVM - \345\210\206\345\214\272.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \345\210\206\345\214\272.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM - \345\210\206\345\214\272.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \345\210\206\345\214\272.md"
diff --git "a/01 - JavaSE/01 - JVM/JVM - \345\236\203\345\234\276\346\224\266\351\233\206.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \345\236\203\345\234\276\346\224\266\351\233\206.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM - \345\236\203\345\234\276\346\224\266\351\233\206.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \345\236\203\345\234\276\346\224\266\351\233\206.md"
diff --git "a/01 - JavaSE/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
diff --git "a/01 - JavaSE/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
diff --git "a/01 - JavaSE/01 - JVM/JVM - \350\260\203\344\274\230\346\200\273\347\273\223.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \350\260\203\344\274\230\346\200\273\347\273\223.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM - \350\260\203\344\274\230\346\200\273\347\273\223.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM - \350\260\203\344\274\230\346\200\273\347\273\223.md"
diff --git "a/01 - JavaSE/01 - JVM/JVM \350\277\220\350\241\214\346\227\266\346\225\260\346\215\256\345\214\272.png" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM \350\277\220\350\241\214\346\227\266\346\225\260\346\215\256\345\214\272.png"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM \350\277\220\350\241\214\346\227\266\346\225\260\346\215\256\345\214\272.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM \350\277\220\350\241\214\346\227\266\346\225\260\346\215\256\345\214\272.png"
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\206\205\345\255\230\346\250\241\345\236\213.jpg" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\206\205\345\255\230\346\250\241\345\236\213.jpg"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM\345\206\205\345\255\230\346\250\241\345\236\213.jpg"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\206\205\345\255\230\346\250\241\345\236\213.jpg"
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\206\205\345\255\230\347\273\223\346\236\204.png" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\206\205\345\255\230\347\273\223\346\236\204.png"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/JVM\345\206\205\345\255\230\347\273\223\346\236\204.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\206\205\345\255\230\347\273\223\346\236\204.png"
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/01 - jps.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/01 - jps.md"
similarity index 98%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/01 - jps.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/01 - jps.md"
index 2f413b24..1e29bdfb 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/01 - jps.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/01 - jps.md"	
@@ -1,94 +1,94 @@
-jps位于jdk的bin目录下，其作用是显示当前系统的java进程情况，及其id号。
-jps相当于Solaris进程工具ps。
-不象”pgrep java”或”ps -ef grep java”，jps并不使用应用程序名来查找JVM实例。
-因此，它查找所有的Java应用程序，包括即使没有使用java执行体的那种（例如，定制的启动 器）。另外，jps仅查找当前用户的Java进程，而不是当前系统中的所有进程。
-
-### 位置
-我们知道，很多Java命令都在jdk的JAVA_HOME/bin/目录下面，jps也不例外，他就在bin目录下，所以，他是java自带的一个命令。
-### 功能
-jps(Java Virtual Machine Process Status Tool)是JDK 1.5提供的一个显示当前所有java进程pid的命令，简单实用，非常适合在linux/unix平台上简单察看当前java进程的一些简单情况。
-### 原理
-
-jdk中的jps命令可以显示当前运行的java进程以及相关参数，它的实现机制如下：
-java程序在启动以后，会在java.io.tmpdir指定的目录下，就是临时文件夹里，生成一个类似于hsperfdata_User的文件夹，这个文件夹里在Linux中为 **/tmp/hsperfdata_{userName}/**，有几个文件，名字就是java进程的pid，因此列出当前运行的java进程，只是把这个目录里的文件名列一下而已。 至于系统的参数什么，就可以解析这几个文件获得。
-```
-hollis@hos:/tmp/hsperfdata_hollis
-$ pwd
-/tmp/hsperfdata_hollis
-hollis@hos:/tmp/hsperfdata_hollis$ ll
-total 48
-drwxr-xr-x 2 hollis hollis  4096  4月 16 10:54 ./
-drwxrwxrwt 7 root   root   12288  4月 16 10:56 ../
--rw------- 1 hollis hollis 32768  4月 16 10:57 2679
-hollis@hos:/tmp/hsperfdata_hollis$
-```
-上面的内容就是我机器中/tmp/hsperfdata_hollis目录下的内容，其中2679就是我机器上当前运行中的java的进程的pid，我们执行jps验证一下：
-```
-hollis@hos:/tmp/hsperfdata_hollis$ jps
-2679 org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar
-4445 Jps
-```
-执行了jps命令之后，我们发现有两个java进程，一个是pid为2679的eclipse运行的进程，另外一个是pid为4445的jps使用的进程（他也是java命令，也要开一个进程）
-使用
-想要学习一个命令，先来看看帮助，使用jps -help查看帮助：
-```
-hollis@hos:/tmp/hsperfdata_hollis$ jps -help
-usage: jps [-help]
-       jps [-q] [-mlvV] [<hostid>]
-
-Definitions:
-    <hostid>:      <hostname>[:<port>]
-```
-接下来，为了详细介绍这些参数，我们编写几个类，在main方法里写一个while(true)的循环，查看java进程情况。代码如下：
-```java
-package com.JavaCommand;
-/**
- * @author hollis
- */
-public class JpsDemo {
-    public static void main(String[] args) {
-        while(true){
-            System.out.println(1);
-        }
-    }
-}
-```
-`-q` 只显示pid，不显示class名称,jar文件名和传递给main 方法的参数
-hollis@hos:/tmp/hsperfdata_hollis$ **jps -q**
-2679
-11421
-`-m` 输出传递给main 方法的参数，在嵌入式jvm上可能是null， 在这里，在启动main方法的时候，我给String[] args传递两个参数。hollis,chuang,执行 **jsp -m**:
-```
-hollis@hos:/tmp/hsperfdata_hollis$ jps -m
-12062 JpsDemo hollis,chuang
-```
-`-l` 输出应用程序main class的完整package名 或者 应用程序的jar文件完整路径名
-```
-hollis@hos:/tmp/hsperfdata_hollis$ jps -l
-12356 sun.tools.jps.Jps
-2679 /home/hollis/tools/eclipse//plugins/org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar
-12329 com.JavaCommand.JpsDemo
-```
-`-v` 输出传递给JVM的参数 在这里，在启动main方法的时候，我给jvm传递一个参数：-Dfile.encoding=UTF-8,执行jps -v：
-```
-hollis@hos:/tmp/hsperfdata_hollis$ jps -v
-2679 org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar -Djava.library.path=/usr/lib/jni:/usr/lib/x86_64-linux-gnu/jni -Dosgi.requiredJavaVersion=1.6 -XX:MaxPermSize=256m -Xms40m -Xmx512m
-13157 Jps -Denv.class.path=/home/hollis/tools/java/jdk1.7.0_71/lib:/home/hollis/tools/java/jdk1.7.0_71/jre/lib: -Dapplication.home=/home/hollis/tools/java/jdk1.7.0_71 -Xms8m
-13083 JpsDemo -Dfile.encoding=UTF-8
-```
-PS:jps命令有个地方很不好，似乎只能显示当前用户的java进程，要显示其他用户的还是只能用unix/linux的`ps`命令。
-jps是我最常用的java命令。使用jps可以查看当前有哪些Java进程处于运行状态。如果我运行了一个web应用（使用tomcat、jboss、jetty等启动）的时候，我就可以使用jps查看启动情况。有的时候我想知道这个应用的日志会输出到哪里，或者启动的时候使用了哪些javaagent，那么我可以使用jps -v 查看进程的jvm参数情况。
-
-### JPS失效处理
-现象： 用`ps -ef|grep java`能看到启动的java进程，但是用jps查看却不存在该进程的id。
-待会儿解释过之后就能知道在该情况下，jconsole、jvisualvm可能无法监控该进程，其他java自带工具也可能无法使用
-分析： jps、jconsole、jvisualvm等工具的数据来源就是这个文件（/tmp/hsperfdata_userName/pid)。所以当该文件不存在或是无法读取时就会出现jps无法查看该进程号，jconsole无法监控等问题
-原因：
-（1）、磁盘读写、目录权限问题 若该用户没有权限写/tmp目录或是磁盘已满，则无法创建/tmp/hsperfdata_userName/pid文件。或该文件已经生成，但用户没有读权限
-（2）、临时文件丢失，被删除或是定期清理 对于linux机器，一般都会存在定时任务对临时文件夹进行清理，导致/tmp目录被清空。这也是我第一次碰到该现象的原因。常用的可能定时删除临时目录的工具为crontab、redhat的tmpwatch、ubuntu的tmpreaper等等
-这个导致的现象可能会是这样，用jconsole监控进程，发现在某一时段后进程仍然存在，但是却没有监控信息了。
-（3）、java进程信息文件存储地址被设置，不在/tmp目录下 上面我们在介绍时说默认会在/tmp/hsperfdata_userName目录保存进程信息，但由于以上1、2所述原因，可能导致该文件无法生成或是丢失，所以java启动时提供了参数(`-Djava.io.tmpdir`)，可以对这个文件的位置进行设置，而jps、jconsole都只会从/tmp目录读取，而无法从设置后的目录读物信息，这是我第二次碰到该现象的原因
-
-附：
-1.如何给main传递参数 在eclipse中，鼠标右键->Run As->Run COnfiguations->Arguments->在Program arguments中写下要传的参数值
-1.如何给JVM传递参数 在eclipse中，鼠标右键->Run As->Run COnfiguations->Arguments->在VM arguments中写下要传的参数值（一般以-D开头）
+jps位于jdk的bin目录下，其作用是显示当前系统的java进程情况，及其id号。
+jps相当于Solaris进程工具ps。
+不象”pgrep java”或”ps -ef grep java”，jps并不使用应用程序名来查找JVM实例。
+因此，它查找所有的Java应用程序，包括即使没有使用java执行体的那种（例如，定制的启动 器）。另外，jps仅查找当前用户的Java进程，而不是当前系统中的所有进程。
+
+### 位置
+我们知道，很多Java命令都在jdk的JAVA_HOME/bin/目录下面，jps也不例外，他就在bin目录下，所以，他是java自带的一个命令。
+### 功能
+jps(Java Virtual Machine Process Status Tool)是JDK 1.5提供的一个显示当前所有java进程pid的命令，简单实用，非常适合在linux/unix平台上简单察看当前java进程的一些简单情况。
+### 原理
+
+jdk中的jps命令可以显示当前运行的java进程以及相关参数，它的实现机制如下：
+java程序在启动以后，会在java.io.tmpdir指定的目录下，就是临时文件夹里，生成一个类似于hsperfdata_User的文件夹，这个文件夹里在Linux中为 **/tmp/hsperfdata_{userName}/**，有几个文件，名字就是java进程的pid，因此列出当前运行的java进程，只是把这个目录里的文件名列一下而已。 至于系统的参数什么，就可以解析这几个文件获得。
+```
+hollis@hos:/tmp/hsperfdata_hollis
+$ pwd
+/tmp/hsperfdata_hollis
+hollis@hos:/tmp/hsperfdata_hollis$ ll
+total 48
+drwxr-xr-x 2 hollis hollis  4096  4月 16 10:54 ./
+drwxrwxrwt 7 root   root   12288  4月 16 10:56 ../
+-rw------- 1 hollis hollis 32768  4月 16 10:57 2679
+hollis@hos:/tmp/hsperfdata_hollis$
+```
+上面的内容就是我机器中/tmp/hsperfdata_hollis目录下的内容，其中2679就是我机器上当前运行中的java的进程的pid，我们执行jps验证一下：
+```
+hollis@hos:/tmp/hsperfdata_hollis$ jps
+2679 org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar
+4445 Jps
+```
+执行了jps命令之后，我们发现有两个java进程，一个是pid为2679的eclipse运行的进程，另外一个是pid为4445的jps使用的进程（他也是java命令，也要开一个进程）
+使用
+想要学习一个命令，先来看看帮助，使用jps -help查看帮助：
+```
+hollis@hos:/tmp/hsperfdata_hollis$ jps -help
+usage: jps [-help]
+       jps [-q] [-mlvV] [<hostid>]
+
+Definitions:
+    <hostid>:      <hostname>[:<port>]
+```
+接下来，为了详细介绍这些参数，我们编写几个类，在main方法里写一个while(true)的循环，查看java进程情况。代码如下：
+```java
+package com.JavaCommand;
+/**
+ * @author hollis
+ */
+public class JpsDemo {
+    public static void main(String[] args) {
+        while(true){
+            System.out.println(1);
+        }
+    }
+}
+```
+`-q` 只显示pid，不显示class名称,jar文件名和传递给main 方法的参数
+hollis@hos:/tmp/hsperfdata_hollis$ **jps -q**
+2679
+11421
+`-m` 输出传递给main 方法的参数，在嵌入式jvm上可能是null， 在这里，在启动main方法的时候，我给String[] args传递两个参数。hollis,chuang,执行 **jsp -m**:
+```
+hollis@hos:/tmp/hsperfdata_hollis$ jps -m
+12062 JpsDemo hollis,chuang
+```
+`-l` 输出应用程序main class的完整package名 或者 应用程序的jar文件完整路径名
+```
+hollis@hos:/tmp/hsperfdata_hollis$ jps -l
+12356 sun.tools.jps.Jps
+2679 /home/hollis/tools/eclipse//plugins/org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar
+12329 com.JavaCommand.JpsDemo
+```
+`-v` 输出传递给JVM的参数 在这里，在启动main方法的时候，我给jvm传递一个参数：-Dfile.encoding=UTF-8,执行jps -v：
+```
+hollis@hos:/tmp/hsperfdata_hollis$ jps -v
+2679 org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar -Djava.library.path=/usr/lib/jni:/usr/lib/x86_64-linux-gnu/jni -Dosgi.requiredJavaVersion=1.6 -XX:MaxPermSize=256m -Xms40m -Xmx512m
+13157 Jps -Denv.class.path=/home/hollis/tools/java/jdk1.7.0_71/lib:/home/hollis/tools/java/jdk1.7.0_71/jre/lib: -Dapplication.home=/home/hollis/tools/java/jdk1.7.0_71 -Xms8m
+13083 JpsDemo -Dfile.encoding=UTF-8
+```
+PS:jps命令有个地方很不好，似乎只能显示当前用户的java进程，要显示其他用户的还是只能用unix/linux的`ps`命令。
+jps是我最常用的java命令。使用jps可以查看当前有哪些Java进程处于运行状态。如果我运行了一个web应用（使用tomcat、jboss、jetty等启动）的时候，我就可以使用jps查看启动情况。有的时候我想知道这个应用的日志会输出到哪里，或者启动的时候使用了哪些javaagent，那么我可以使用jps -v 查看进程的jvm参数情况。
+
+### JPS失效处理
+现象： 用`ps -ef|grep java`能看到启动的java进程，但是用jps查看却不存在该进程的id。
+待会儿解释过之后就能知道在该情况下，jconsole、jvisualvm可能无法监控该进程，其他java自带工具也可能无法使用
+分析： jps、jconsole、jvisualvm等工具的数据来源就是这个文件（/tmp/hsperfdata_userName/pid)。所以当该文件不存在或是无法读取时就会出现jps无法查看该进程号，jconsole无法监控等问题
+原因：
+（1）、磁盘读写、目录权限问题 若该用户没有权限写/tmp目录或是磁盘已满，则无法创建/tmp/hsperfdata_userName/pid文件。或该文件已经生成，但用户没有读权限
+（2）、临时文件丢失，被删除或是定期清理 对于linux机器，一般都会存在定时任务对临时文件夹进行清理，导致/tmp目录被清空。这也是我第一次碰到该现象的原因。常用的可能定时删除临时目录的工具为crontab、redhat的tmpwatch、ubuntu的tmpreaper等等
+这个导致的现象可能会是这样，用jconsole监控进程，发现在某一时段后进程仍然存在，但是却没有监控信息了。
+（3）、java进程信息文件存储地址被设置，不在/tmp目录下 上面我们在介绍时说默认会在/tmp/hsperfdata_userName目录保存进程信息，但由于以上1、2所述原因，可能导致该文件无法生成或是丢失，所以java启动时提供了参数(`-Djava.io.tmpdir`)，可以对这个文件的位置进行设置，而jps、jconsole都只会从/tmp目录读取，而无法从设置后的目录读物信息，这是我第二次碰到该现象的原因
+
+附：
+1.如何给main传递参数 在eclipse中，鼠标右键->Run As->Run COnfiguations->Arguments->在Program arguments中写下要传的参数值
+1.如何给JVM传递参数 在eclipse中，鼠标右键->Run As->Run COnfiguations->Arguments->在VM arguments中写下要传的参数值（一般以-D开头）
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/02 - jstack.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/02 - jstack.md"
similarity index 98%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/02 - jstack.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/02 - jstack.md"
index 2ee295c5..147c52a9 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/02 - jstack.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/02 - jstack.md"	
@@ -1,100 +1,100 @@
-### jstack是java虚拟机自带的一种堆栈跟踪工具。
-### 功能
-  jstack用于生成java虚拟机当前时刻的线程快照。**线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等**。
-  线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。
-  如果java程序崩溃生成core文件，jstack工具可以用来获得core文件的java stack和native stack的信息，从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。
-  另外，jstack工具还可以附属到正在运行的java程序中，看到当时运行的java程序的java stack和native stack的信息, 如果现在运行的java程序呈现hung的状态，jstack是非常有用的。
-  So,**jstack命令主要用来查看Java线程的调用堆栈的，可以用来分析线程问题（如死锁）**。
-### 线程状态
-  想要通过jstack命令来分析线程的情况的话，首先要知道线程都有哪些状态，下面这些状态是我们使用jstack命令查看线程堆栈信息时可能会看到的线程的几种状态：
-  NEW,未启动的。不会出现在Dump中。
-  RUNNABLE,在虚拟机内执行的。
-  BLOCKED,受阻塞并等待监视器锁。
-  WATING,无限期等待另一个线程执行特定操作。
-  TIMED_WATING,有时限的等待另一个线程的特定操作。
-  TERMINATED,已退出的。
-  Monitor
-  在多线程的 JAVA程序中，实现线程之间的同步，就要说说 Monitor。 Monitor是 Java中用以实现线程之间的互斥与协作的主要手段，它可以看成是对象或者 Class的锁。每一个对象都有，也仅有一个 monitor。下 面这个图，描述了线程和 Monitor之间关系，以 及线程的状态转换图：
-
-  进入区(Entrt Set):表示线程通过synchronized要求获取对象的锁。如果对象未被锁住,则迚入拥有者;否则则在进入区等待。一旦对象锁被其他线程释放,立即参与竞争。
-  拥有者(The Owner):表示某一线程成功竞争到对象锁。
-  等待区(Wait Set):表示线程通过对象的wait方法,释放对象的锁,并在等待区等待被唤醒。
-  从图中可以看出，一个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是“Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。 先看 “Entry Set”里面的线程。我们称被 synchronized保护起来的代码段为临界区。当一个线程申请进入临界区时，它就进入了 “Entry Set”队列。对应的 code就像：
-  synchronized(obj) {
-  .........
-
-  }
-  调用修饰
-  表示线程在方法调用时,额外的重要的操作。线程Dump分析的重要信息。修饰上方的方法调用。
-  ```
-  locked <地址> 目标：使用synchronized申请对象锁成功,监视器的拥有者。
-  waiting to lock <地址> 目标：使用synchronized申请对象锁未成功,在迚入区等待。
-  waiting on <地址> 目标：使用synchronized申请对象锁成功后,释放锁幵在等待区等待。
-  parking to wait for <地址> 目标
-  ```
-  **locked**
-  ```
-  at oracle.jdbc.driver.PhysicalConnection.prepareStatement
-  - locked <0x00002aab63bf7f58> (a oracle.jdbc.driver.T4CConnection)
-  at oracle.jdbc.driver.PhysicalConnection.prepareStatement
-  - locked <0x00002aab63bf7f58> (a oracle.jdbc.driver.T4CConnection)
-  at com.jiuqi.dna.core.internal.db.datasource.PooledConnection.prepareStatement
-  ```
-  通过synchronized关键字,成功获取到了对象的锁,成为监视器的拥有者,在临界区内操作。对象锁是可以线程重入的。
-  **waiting to lock**
-  ```
-  at com.jiuqi.dna.core.impl.CacheHolder.isVisibleIn(CacheHolder.java:165)
-  - waiting to lock <0x0000000097ba9aa8> (a CacheHolder)
-  at com.jiuqi.dna.core.impl.CacheGroup$Index.findHolder
-  at com.jiuqi.dna.core.impl.ContextImpl.find
-  at com.jiuqi.dna.bap.basedata.common.util.BaseDataCenter.findInfo
-  ```
-  通过synchronized关键字,没有获取到了对象的锁,线程在监视器的进入区等待。在调用栈顶出现,线程状态为Blocked。
-  **waiting on**
-  ```
-  at java.lang.Object.wait(Native Method)
-  - waiting on <0x00000000da2defb0> (a WorkingThread)
-  at com.jiuqi.dna.core.impl.WorkingManager.getWorkToDo
-  - locked <0x00000000da2defb0> (a WorkingThread)
-  at com.jiuqi.dna.core.impl.WorkingThread.run
-  ```
-  通过synchronized关键字,成功获取到了对象的锁后,调用了wait方法,进入对象的等待区等待。在调用栈顶出现,线程状态为WAITING或TIMED_WATING。
-  **parking to wait for**
-  park是基本的线程阻塞原语,不通过监视器在对象上阻塞。随concurrent包会出现的新的机制,不synchronized体系不同。
-  线程动作
-  线程状态产生的原因
-  ```
-  runnable:状态一般为RUNNABLE。
-  in Object.wait():等待区等待,状态为WAITING或TIMED_WAITING。
-  waiting for monitor entry:进入区等待,状态为BLOCKED。
-  waiting on condition:等待区等待、被park。
-  sleeping:休眠的线程,调用了Thread.sleep()。
-  ```
-  **Wait on condition** 该状态出现在线程等待某个条件的发生。具体是什么原因，可以结合 stacktrace来分析。 最常见的情况就是线程处于sleep状态，等待被唤醒。 常见的情况还有等待网络IO：在java引入nio之前，对于每个网络连接，都有一个对应的线程来处理网络的读写操作，即使没有可读写的数据，线程仍然阻塞在读写操作上，这样有可能造成资源浪费，而且给操作系统的线程调度也带来压力。在 NewIO里采用了新的机制，编写的服务器程序的性能和可扩展性都得到提高。 正等待网络读写，这可能是一个网络瓶颈的征兆。因为网络阻塞导致线程无法执行。一种情况是网络非常忙，几 乎消耗了所有的带宽，仍然有大量数据等待网络读 写；另一种情况也可能是网络空闲，但由于路由等问题，导致包无法正常的到达。所以要结合系统的一些性能观察工具来综合分析，比如 netstat统计单位时间的发送包的数目，如果很明显超过了所在网络带宽的限制 ; 观察 cpu的利用率，如果系统态的 CPU时间，相对于用户态的 CPU时间比例较高；如果程序运行在 Solaris 10平台上，可以用 dtrace工具看系统调用的情况，如果观察到 read/write的系统调用的次数或者运行时间遥遥领先；这些都指向由于网络带宽所限导致的网络瓶颈。（来自http://www.blogjava.net/jzone/articles/303979.html）
-
-### 线程Dump的分析
-  **原则**
-  结合代码阅读的推理。需要线程Dump和源码的相互推导和印证。
-  造成Bug的根源往往丌会在调用栈上直接体现,一定格外注意线程当前调用之前的所有调用。
-入手点
-**进入区等待**
-"d&a-3588" daemon waiting for monitor entry [0x000000006e5d5000]
-java.lang.Thread.State: BLOCKED (on object monitor)
-at com.jiuqi.dna.bap.authority.service.UserService$LoginHandler.handle()
-- waiting to lock <0x0000000602f38e90> (a java.lang.Object)
-at com.jiuqi.dna.bap.authority.service.UserService$LoginHandler.handle()
-线程状态BLOCKED,线程动作wait on monitor entry,调用修饰waiting to lock总是一起出现。表示在代码级别已经存在冲突的调用。必然有问题的代码,需要尽可能减少其发生。
-**同步块阻塞**
-一个线程锁住某对象,大量其他线程在该对象上等待。
-"blocker" runnable
-java.lang.Thread.State: RUNNABLE
-at com.jiuqi.hcl.javadump.Blocker$1.run(Blocker.java:23)
-- locked <0x00000000eb8eff68> (a java.lang.Object)
-"blockee-11" waiting for monitor entry
-java.lang.Thread.State: BLOCKED (on object monitor)
-at com.jiuqi.hcl.javadump.Blocker$2.run(Blocker.java:41)
-- waiting to lock <0x00000000eb8eff68> (a java.lang.Object)
-"blockee-86" waiting for monitor entry
-java.lang.Thread.State: BLOCKED (on object monitor)
-at com.jiuqi.hcl.javadump.Blocker$2.run(Blocker.java:41)
-- waiting to lock <0x00000000eb8eff68> (a java.lang.Object)
+### jstack是java虚拟机自带的一种堆栈跟踪工具。
+### 功能
+  jstack用于生成java虚拟机当前时刻的线程快照。**线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等**。
+  线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。
+  如果java程序崩溃生成core文件，jstack工具可以用来获得core文件的java stack和native stack的信息，从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。
+  另外，jstack工具还可以附属到正在运行的java程序中，看到当时运行的java程序的java stack和native stack的信息, 如果现在运行的java程序呈现hung的状态，jstack是非常有用的。
+  So,**jstack命令主要用来查看Java线程的调用堆栈的，可以用来分析线程问题（如死锁）**。
+### 线程状态
+  想要通过jstack命令来分析线程的情况的话，首先要知道线程都有哪些状态，下面这些状态是我们使用jstack命令查看线程堆栈信息时可能会看到的线程的几种状态：
+  NEW,未启动的。不会出现在Dump中。
+  RUNNABLE,在虚拟机内执行的。
+  BLOCKED,受阻塞并等待监视器锁。
+  WATING,无限期等待另一个线程执行特定操作。
+  TIMED_WATING,有时限的等待另一个线程的特定操作。
+  TERMINATED,已退出的。
+  Monitor
+  在多线程的 JAVA程序中，实现线程之间的同步，就要说说 Monitor。 Monitor是 Java中用以实现线程之间的互斥与协作的主要手段，它可以看成是对象或者 Class的锁。每一个对象都有，也仅有一个 monitor。下 面这个图，描述了线程和 Monitor之间关系，以 及线程的状态转换图：
+
+  进入区(Entrt Set):表示线程通过synchronized要求获取对象的锁。如果对象未被锁住,则迚入拥有者;否则则在进入区等待。一旦对象锁被其他线程释放,立即参与竞争。
+  拥有者(The Owner):表示某一线程成功竞争到对象锁。
+  等待区(Wait Set):表示线程通过对象的wait方法,释放对象的锁,并在等待区等待被唤醒。
+  从图中可以看出，一个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是“Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。 先看 “Entry Set”里面的线程。我们称被 synchronized保护起来的代码段为临界区。当一个线程申请进入临界区时，它就进入了 “Entry Set”队列。对应的 code就像：
+  synchronized(obj) {
+  .........
+
+  }
+  调用修饰
+  表示线程在方法调用时,额外的重要的操作。线程Dump分析的重要信息。修饰上方的方法调用。
+  ```
+  locked <地址> 目标：使用synchronized申请对象锁成功,监视器的拥有者。
+  waiting to lock <地址> 目标：使用synchronized申请对象锁未成功,在迚入区等待。
+  waiting on <地址> 目标：使用synchronized申请对象锁成功后,释放锁幵在等待区等待。
+  parking to wait for <地址> 目标
+  ```
+  **locked**
+  ```
+  at oracle.jdbc.driver.PhysicalConnection.prepareStatement
+  - locked <0x00002aab63bf7f58> (a oracle.jdbc.driver.T4CConnection)
+  at oracle.jdbc.driver.PhysicalConnection.prepareStatement
+  - locked <0x00002aab63bf7f58> (a oracle.jdbc.driver.T4CConnection)
+  at com.jiuqi.dna.core.internal.db.datasource.PooledConnection.prepareStatement
+  ```
+  通过synchronized关键字,成功获取到了对象的锁,成为监视器的拥有者,在临界区内操作。对象锁是可以线程重入的。
+  **waiting to lock**
+  ```
+  at com.jiuqi.dna.core.impl.CacheHolder.isVisibleIn(CacheHolder.java:165)
+  - waiting to lock <0x0000000097ba9aa8> (a CacheHolder)
+  at com.jiuqi.dna.core.impl.CacheGroup$Index.findHolder
+  at com.jiuqi.dna.core.impl.ContextImpl.find
+  at com.jiuqi.dna.bap.basedata.common.util.BaseDataCenter.findInfo
+  ```
+  通过synchronized关键字,没有获取到了对象的锁,线程在监视器的进入区等待。在调用栈顶出现,线程状态为Blocked。
+  **waiting on**
+  ```
+  at java.lang.Object.wait(Native Method)
+  - waiting on <0x00000000da2defb0> (a WorkingThread)
+  at com.jiuqi.dna.core.impl.WorkingManager.getWorkToDo
+  - locked <0x00000000da2defb0> (a WorkingThread)
+  at com.jiuqi.dna.core.impl.WorkingThread.run
+  ```
+  通过synchronized关键字,成功获取到了对象的锁后,调用了wait方法,进入对象的等待区等待。在调用栈顶出现,线程状态为WAITING或TIMED_WATING。
+  **parking to wait for**
+  park是基本的线程阻塞原语,不通过监视器在对象上阻塞。随concurrent包会出现的新的机制,不synchronized体系不同。
+  线程动作
+  线程状态产生的原因
+  ```
+  runnable:状态一般为RUNNABLE。
+  in Object.wait():等待区等待,状态为WAITING或TIMED_WAITING。
+  waiting for monitor entry:进入区等待,状态为BLOCKED。
+  waiting on condition:等待区等待、被park。
+  sleeping:休眠的线程,调用了Thread.sleep()。
+  ```
+  **Wait on condition** 该状态出现在线程等待某个条件的发生。具体是什么原因，可以结合 stacktrace来分析。 最常见的情况就是线程处于sleep状态，等待被唤醒。 常见的情况还有等待网络IO：在java引入nio之前，对于每个网络连接，都有一个对应的线程来处理网络的读写操作，即使没有可读写的数据，线程仍然阻塞在读写操作上，这样有可能造成资源浪费，而且给操作系统的线程调度也带来压力。在 NewIO里采用了新的机制，编写的服务器程序的性能和可扩展性都得到提高。 正等待网络读写，这可能是一个网络瓶颈的征兆。因为网络阻塞导致线程无法执行。一种情况是网络非常忙，几 乎消耗了所有的带宽，仍然有大量数据等待网络读 写；另一种情况也可能是网络空闲，但由于路由等问题，导致包无法正常的到达。所以要结合系统的一些性能观察工具来综合分析，比如 netstat统计单位时间的发送包的数目，如果很明显超过了所在网络带宽的限制 ; 观察 cpu的利用率，如果系统态的 CPU时间，相对于用户态的 CPU时间比例较高；如果程序运行在 Solaris 10平台上，可以用 dtrace工具看系统调用的情况，如果观察到 read/write的系统调用的次数或者运行时间遥遥领先；这些都指向由于网络带宽所限导致的网络瓶颈。（来自http://www.blogjava.net/jzone/articles/303979.html）
+
+### 线程Dump的分析
+  **原则**
+  结合代码阅读的推理。需要线程Dump和源码的相互推导和印证。
+  造成Bug的根源往往丌会在调用栈上直接体现,一定格外注意线程当前调用之前的所有调用。
+入手点
+**进入区等待**
+"d&a-3588" daemon waiting for monitor entry [0x000000006e5d5000]
+java.lang.Thread.State: BLOCKED (on object monitor)
+at com.jiuqi.dna.bap.authority.service.UserService$LoginHandler.handle()
+- waiting to lock <0x0000000602f38e90> (a java.lang.Object)
+at com.jiuqi.dna.bap.authority.service.UserService$LoginHandler.handle()
+线程状态BLOCKED,线程动作wait on monitor entry,调用修饰waiting to lock总是一起出现。表示在代码级别已经存在冲突的调用。必然有问题的代码,需要尽可能减少其发生。
+**同步块阻塞**
+一个线程锁住某对象,大量其他线程在该对象上等待。
+"blocker" runnable
+java.lang.Thread.State: RUNNABLE
+at com.jiuqi.hcl.javadump.Blocker$1.run(Blocker.java:23)
+- locked <0x00000000eb8eff68> (a java.lang.Object)
+"blockee-11" waiting for monitor entry
+java.lang.Thread.State: BLOCKED (on object monitor)
+at com.jiuqi.hcl.javadump.Blocker$2.run(Blocker.java:41)
+- waiting to lock <0x00000000eb8eff68> (a java.lang.Object)
+"blockee-86" waiting for monitor entry
+java.lang.Thread.State: BLOCKED (on object monitor)
+at com.jiuqi.hcl.javadump.Blocker$2.run(Blocker.java:41)
+- waiting to lock <0x00000000eb8eff68> (a java.lang.Object)
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/03 - jstat.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/03 - jstat.md"
similarity index 99%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/03 - jstat.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/03 - jstat.md"
index 15786107..ee5b597c 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/03 - jstat.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/03 - jstat.md"	
@@ -1,57 +1,57 @@
-jstat(JVM Statistics Monitoring Tool)是 **用于监控虚拟机各种运行状态信息的命令行工具**。
-他可以 **显示本地或远程虚拟机进程中的类装载、内存、垃圾收集、JIT编译等运行数据**，在没有GUI图形的服务器上，它是运行期定位虚拟机性能问题的首选工具。
-jstat位于java的bin目录下，主要利用JVM内建的指令对Java应用程序的资源和性能进行实时的命令行的监控，包括了对Heap size和垃圾回收状况的监控。
-可见，Jstat是轻量级的、专门针对JVM的工具，非常适用。
-jstat 命令格式
- **jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]**
-参数解释：
-`Option` — 选项，我们一般使用 -gcutil 查看gc情况
-`vmid` — VM的进程号，即当前运行的java进程号
-`interval`- 间隔时间，单位为秒或者毫秒
-`count` — 打印次数，如果缺省则打印无数次
-参数interval和count代表查询间隔和次数，如果省略这两个参数，说明只查询一次。假设需要每250毫秒查询一次进程5828垃圾收集状况，一共查询5次，那命令行如下：
-`jstat -gc 5828 250 5`
-对于命令格式中的VMID与LVMID需要特别说明下：如果是本地虚拟机进程，
-VMID(Virtual Machine IDentifier,虚机标识符)和LVMID(Local Virtual Machine IDentifier,虚机标识符)是一致的，
-如果是远程虚拟机进程，那VMID的格式应当是：[protocol:][//] lvmid [@hostname[:port]/servername]
-
-**option**
-选项option代表这用户希望查询的虚拟机信息，主要分为3类：类装载、垃圾收集和运行期编译状况，具体选项及作用如下：
- * `–class` 监视类装载、卸载数量、总空间及类装载所耗费的时间
- * `–gc` 监视Java堆状况，包括Eden区、2个Survivor区、老年代、永久代等的容量
- * `–gccapacity` 监视内容与-gc基本相同，但输出主要关注Java堆各个区域使用到的最大和最小空间
- * `–gcutil` 监视内容与-gc基本相同，但输出主要关注已使用空间占总空间的百分比
- * `–gccause` 与-gcutil功能一样，但是会额外输出导致上一次GC产生的原因
- * `–gcnew` 监视新生代GC的状况
- * `–gcnewcapacity` 监视内容与-gcnew基本相同，输出主要关注使用到的最大和最小空间
- * `–gcold` 监视老年代GC的状况
- * `–gcoldcapacity` 监视内容与——gcold基本相同，输出主要关注使用到的最大和最小空间
- * `–gcpermcapacity` 输出永久代使用到的最大和最小空间
- * `–compiler` 输出JIT编译器编译过的方法、耗时等信息
- * `–printcompilation` 输出已经被JIT编译的方法
-
-常见术语
-1. `jstat –class<pid>` : 显示加载class的数量，及所占空间等信息。
-Loaded 装载的类的数量 Bytes 装载类所占用的字节数 Unloaded 卸载类的数量 Bytes 卸载类的字节数 Time 装载和卸载类所花费的时间
-2. `jstat -compiler <pid>`显示VM实时编译的数量等信息。
-Compiled 编译任务执行数量 Failed 编译任务执行失败数量 Invalid 编译任务执行失效数量 Time 编译任务消耗时间 FailedType 最后一个编译失败任务的类型 FailedMethod 最后一个编译失败任务所在的类及方法
-3. `jstat -gc <pid>`: 可以显示gc的信息，查看gc的次数，及时间。
-S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节) S0U 年轻代中第一个survivor（幸存区）目前已使用空间 (字节) S1U 年轻代中第二个survivor（幸存区）目前已使用空间 (字节) EC 年轻代中Eden（伊甸园）的容量 (字节) EU 年轻代中Eden（伊甸园）目前已使用空间 (字节) OC Old代的容量 (字节) OU Old代目前已使用空间 (字节) PC Perm(持久代)的容量 (字节) PU Perm(持久代)目前已使用空间 (字节)YGC 从应用程序启动到采样时年轻代中gc次数 YGCT 从应用程序启动到采样时年轻代中gc所用时间(s) FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
-4. `jstat -gccapacity <pid>`:可以显示，VM内存中三代（young,old,perm）对象的使用和占用大小
-NGCMN 年轻代(young)中初始化(最小)的大小(字节) NGCMX 年轻代(young)的最大容量 (字节)NGC 年轻代(young)中当前的容量 (字节) S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节) EC 年轻代中Eden（伊甸园）的容量 (字节) OGCMN old代中初始化(最小)的大小 (字节) OGCMX old代的最大容量(字节) OGC old代当前新生成的容量 (字节) OC Old代的容量 (字节) PGCMN perm代中初始化(最小)的大小 (字节) PGCMX perm代的最大容量 (字节)
-PGC perm代当前新生成的容量 (字节) PC Perm(持久代)的容量 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数
-5. `jstat -gcutil <pid>`:统计gc信息
-S0 年轻代中第一个survivor（幸存区）已使用的占当前容量百分比 S1 年轻代中第二个survivor（幸存区）已使用的占当前容量百分比 E 年轻代中Eden（伊甸园）已使用的占当前容量百分比 O old代已使用的占当前容量百分比 P perm代已使用的占当前容量百分比 YGC 从应用程序启动到采样时年轻代中gc次数 YGCT 从应用程序启动到采样时年轻代中gc所用时间(s)FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
-6. `jstat -gcnew <pid>`:年轻代对象的信息。
-S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节) S0U 年轻代中第一个survivor（幸存区）目前已使用空间 (字节) S1U 年轻代中第二个survivor（幸存区）目前已使用空间 (字节) TT 持有次数限制 MTT 最大持有次数限制EC 年轻代中Eden（伊甸园）的容量 (字节) EU 年轻代中Eden（伊甸园）目前已使用空间 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 YGCT 从应用程序启动到采样时年轻代中gc所用时间(s)
-7. `jstat -gcnewcapacity<pid>`: 年轻代对象的信息及其占用量。
-NGCMN 年轻代(young)中初始化(最小)的大小(字节) NGCMX 年轻代(young)的最大容量 (字节)NGC 年轻代(young)中当前的容量 (字节) S0CMX 年轻代中第一个survivor（幸存区）的最大容量 (字节) S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1CMX 年轻代中第二个survivor（幸存区）的最大容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节)ECMX 年轻代中Eden（伊甸园）的最大容量 (字节) EC 年轻代中Eden（伊甸园）的容量 (字节)YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数
-8. `jstat -gcold <pid>`：old代对象的信息。
-PC Perm(持久代)的容量 (字节) PU Perm(持久代)目前已使用空间 (字节) OC Old代的容量 (字节) OU Old代目前已使用空间 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
-9. `stat -gcoldcapacity <pid>`: old代对象的信息及其占用量。
-OGCMN old代中初始化(最小)的大小 (字节) OGCMX old代的最大容量(字节) OGC old代当前新生成的容量 (字节) OC Old代的容量 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
-10. `jstat -gcpermcapacity<pid>`: perm对象的信息及其占用量。
-PGCMN perm代中初始化(最小)的大小 (字节) PGCMX perm代的最大容量 (字节)
-PGC perm代当前新生成的容量 (字节) PC Perm(持久代)的容量 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
-11. `jstat -printcompilation <pid>`：当前VM执行的信息。
-Compiled 编译任务的数目 Size 方法生成的字节码的大小 Type 编译类型 Method 类名和方法名用来标识编译的方法。类名使用/做为一个命名空间分隔符。方法名是给定类中的方法。上述格式是由-XX:+PrintComplation选项进行设置的
+jstat(JVM Statistics Monitoring Tool)是 **用于监控虚拟机各种运行状态信息的命令行工具**。
+他可以 **显示本地或远程虚拟机进程中的类装载、内存、垃圾收集、JIT编译等运行数据**，在没有GUI图形的服务器上，它是运行期定位虚拟机性能问题的首选工具。
+jstat位于java的bin目录下，主要利用JVM内建的指令对Java应用程序的资源和性能进行实时的命令行的监控，包括了对Heap size和垃圾回收状况的监控。
+可见，Jstat是轻量级的、专门针对JVM的工具，非常适用。
+jstat 命令格式
+ **jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]**
+参数解释：
+`Option` — 选项，我们一般使用 -gcutil 查看gc情况
+`vmid` — VM的进程号，即当前运行的java进程号
+`interval`- 间隔时间，单位为秒或者毫秒
+`count` — 打印次数，如果缺省则打印无数次
+参数interval和count代表查询间隔和次数，如果省略这两个参数，说明只查询一次。假设需要每250毫秒查询一次进程5828垃圾收集状况，一共查询5次，那命令行如下：
+`jstat -gc 5828 250 5`
+对于命令格式中的VMID与LVMID需要特别说明下：如果是本地虚拟机进程，
+VMID(Virtual Machine IDentifier,虚机标识符)和LVMID(Local Virtual Machine IDentifier,虚机标识符)是一致的，
+如果是远程虚拟机进程，那VMID的格式应当是：[protocol:][//] lvmid [@hostname[:port]/servername]
+
+**option**
+选项option代表这用户希望查询的虚拟机信息，主要分为3类：类装载、垃圾收集和运行期编译状况，具体选项及作用如下：
+ * `–class` 监视类装载、卸载数量、总空间及类装载所耗费的时间
+ * `–gc` 监视Java堆状况，包括Eden区、2个Survivor区、老年代、永久代等的容量
+ * `–gccapacity` 监视内容与-gc基本相同，但输出主要关注Java堆各个区域使用到的最大和最小空间
+ * `–gcutil` 监视内容与-gc基本相同，但输出主要关注已使用空间占总空间的百分比
+ * `–gccause` 与-gcutil功能一样，但是会额外输出导致上一次GC产生的原因
+ * `–gcnew` 监视新生代GC的状况
+ * `–gcnewcapacity` 监视内容与-gcnew基本相同，输出主要关注使用到的最大和最小空间
+ * `–gcold` 监视老年代GC的状况
+ * `–gcoldcapacity` 监视内容与——gcold基本相同，输出主要关注使用到的最大和最小空间
+ * `–gcpermcapacity` 输出永久代使用到的最大和最小空间
+ * `–compiler` 输出JIT编译器编译过的方法、耗时等信息
+ * `–printcompilation` 输出已经被JIT编译的方法
+
+常见术语
+1. `jstat –class<pid>` : 显示加载class的数量，及所占空间等信息。
+Loaded 装载的类的数量 Bytes 装载类所占用的字节数 Unloaded 卸载类的数量 Bytes 卸载类的字节数 Time 装载和卸载类所花费的时间
+2. `jstat -compiler <pid>`显示VM实时编译的数量等信息。
+Compiled 编译任务执行数量 Failed 编译任务执行失败数量 Invalid 编译任务执行失效数量 Time 编译任务消耗时间 FailedType 最后一个编译失败任务的类型 FailedMethod 最后一个编译失败任务所在的类及方法
+3. `jstat -gc <pid>`: 可以显示gc的信息，查看gc的次数，及时间。
+S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节) S0U 年轻代中第一个survivor（幸存区）目前已使用空间 (字节) S1U 年轻代中第二个survivor（幸存区）目前已使用空间 (字节) EC 年轻代中Eden（伊甸园）的容量 (字节) EU 年轻代中Eden（伊甸园）目前已使用空间 (字节) OC Old代的容量 (字节) OU Old代目前已使用空间 (字节) PC Perm(持久代)的容量 (字节) PU Perm(持久代)目前已使用空间 (字节)YGC 从应用程序启动到采样时年轻代中gc次数 YGCT 从应用程序启动到采样时年轻代中gc所用时间(s) FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
+4. `jstat -gccapacity <pid>`:可以显示，VM内存中三代（young,old,perm）对象的使用和占用大小
+NGCMN 年轻代(young)中初始化(最小)的大小(字节) NGCMX 年轻代(young)的最大容量 (字节)NGC 年轻代(young)中当前的容量 (字节) S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节) EC 年轻代中Eden（伊甸园）的容量 (字节) OGCMN old代中初始化(最小)的大小 (字节) OGCMX old代的最大容量(字节) OGC old代当前新生成的容量 (字节) OC Old代的容量 (字节) PGCMN perm代中初始化(最小)的大小 (字节) PGCMX perm代的最大容量 (字节)
+PGC perm代当前新生成的容量 (字节) PC Perm(持久代)的容量 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数
+5. `jstat -gcutil <pid>`:统计gc信息
+S0 年轻代中第一个survivor（幸存区）已使用的占当前容量百分比 S1 年轻代中第二个survivor（幸存区）已使用的占当前容量百分比 E 年轻代中Eden（伊甸园）已使用的占当前容量百分比 O old代已使用的占当前容量百分比 P perm代已使用的占当前容量百分比 YGC 从应用程序启动到采样时年轻代中gc次数 YGCT 从应用程序启动到采样时年轻代中gc所用时间(s)FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
+6. `jstat -gcnew <pid>`:年轻代对象的信息。
+S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节) S0U 年轻代中第一个survivor（幸存区）目前已使用空间 (字节) S1U 年轻代中第二个survivor（幸存区）目前已使用空间 (字节) TT 持有次数限制 MTT 最大持有次数限制EC 年轻代中Eden（伊甸园）的容量 (字节) EU 年轻代中Eden（伊甸园）目前已使用空间 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 YGCT 从应用程序启动到采样时年轻代中gc所用时间(s)
+7. `jstat -gcnewcapacity<pid>`: 年轻代对象的信息及其占用量。
+NGCMN 年轻代(young)中初始化(最小)的大小(字节) NGCMX 年轻代(young)的最大容量 (字节)NGC 年轻代(young)中当前的容量 (字节) S0CMX 年轻代中第一个survivor（幸存区）的最大容量 (字节) S0C 年轻代中第一个survivor（幸存区）的容量 (字节) S1CMX 年轻代中第二个survivor（幸存区）的最大容量 (字节) S1C 年轻代中第二个survivor（幸存区）的容量 (字节)ECMX 年轻代中Eden（伊甸园）的最大容量 (字节) EC 年轻代中Eden（伊甸园）的容量 (字节)YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数
+8. `jstat -gcold <pid>`：old代对象的信息。
+PC Perm(持久代)的容量 (字节) PU Perm(持久代)目前已使用空间 (字节) OC Old代的容量 (字节) OU Old代目前已使用空间 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
+9. `stat -gcoldcapacity <pid>`: old代对象的信息及其占用量。
+OGCMN old代中初始化(最小)的大小 (字节) OGCMX old代的最大容量(字节) OGC old代当前新生成的容量 (字节) OC Old代的容量 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
+10. `jstat -gcpermcapacity<pid>`: perm对象的信息及其占用量。
+PGCMN perm代中初始化(最小)的大小 (字节) PGCMX perm代的最大容量 (字节)
+PGC perm代当前新生成的容量 (字节) PC Perm(持久代)的容量 (字节) YGC 从应用程序启动到采样时年轻代中gc次数 FGC 从应用程序启动到采样时old代(全gc)gc次数 FGCT 从应用程序启动到采样时old代(全gc)gc所用时间(s) GCT 从应用程序启动到采样时gc用的总时间(s)
+11. `jstat -printcompilation <pid>`：当前VM执行的信息。
+Compiled 编译任务的数目 Size 方法生成的字节码的大小 Type 编译类型 Method 类名和方法名用来标识编译的方法。类名使用/做为一个命名空间分隔符。方法名是给定类中的方法。上述格式是由-XX:+PrintComplation选项进行设置的
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/04 - jmap.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/04 - jmap.md"
similarity index 98%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/04 - jmap.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/04 - jmap.md"
index 55a027f1..417742bc 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/04 - jmap.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/04 - jmap.md"	
@@ -1,173 +1,173 @@
-Jmap
-
-  jmap是JDK自带的工具软件，主要用于打印指定Java进程(或核心文件、远程调试服务器)的共享对象内存映射或堆内存细节。可以使用jmap生成Heap  这篇文章主要介绍Java的堆Dump以及jamp命令
-
-### 什么是堆Dump
-  堆Dump是反应Java堆使用情况的内存镜像，其中主要包括系统信息、虚拟机属性、完整的线程Dump、所有类和对象的状态等。 一般，在内存不足、GC异常等情况下，我们就会怀疑有内存泄露。这个时候我们就可以制作堆Dump来查看具体情况。分析原因。
-
-### 基础知识
-
-  常见内存错误：
-  outOfMemoryError 年老代内存不足。
-  outOfMemoryError:PermGen Space 永久代内存不足。
-  outOfMemoryError:GC overhead limit exceed 垃圾回收时间占用系统运行时间的98%或以上。
-
-### jmap
-
-  用法摘要
-  ``` yml
-  Usage:
-      jmap [option] <pid>
-          (to connect to running process)
-      jmap [option] <executable <core>
-          (to connect to a core file)
-      jmap [option] [server_id@]<remote server IP or hostname>
-          (to connect to remote debug server)
-
-  where <option> is one of:
-      <none>               to print same info as Solaris pmap
-      -heap                to print java heap summary
-      -histo[:live]        to print histogram of java object heap; if the "live"
-                           suboption is specified, only count live objects
-      -permstat            to print permanent generation statistics
-      -finalizerinfo       to print information on objects awaiting finalization
-      -dump:<dump-options> to dump java heap in hprof binary format
-                           dump-options:
-                             live         dump only live objects; if not specified,
-                                          all objects in the heap are dumped.
-                             format=b     binary format
-                             file=<file>  dump heap to <file>
-                           Example: jmap -dump:live,format=b,file=heap.bin <pid>
-      -F                   force. Use with -dump:<dump-options> <pid> or -histo
-                           to force a heap dump or histogram when <pid> does not
-                           respond. The "live" suboption is not supported
-                           in this mode.
-      -h | -help           to print this help message
-      -J<flag>             to pass <flag> directly to the runtime system
-  ```
-  指定进程号(pid)的进程 jmap [ option ] 指定核心文件 jmap [ option ] 指定远程调试服务器 jmap [ option ] [server-id@]
-
-### 参数：
-
-  `option` 选项参数是互斥的(不可同时使用)。想要使用选项参数，直接跟在命令名称后即可。
-  `pid` 需要打印配置信息的进程ID。该进程必须是一个Java进程。想要获取运行的Java进程列表，你可以使用jps。
-  `executable` 产生核心dump的Java可执行文件。
-  `core` 需要打印配置信息的核心文件。
-  `remote-hostname-or-IP` 远程调试服务器的(请查看jsadebugd)主机名或IP地址。
-  `server-id` 可选的唯一id，如果相同的远程主机上运行了多台调试服务器，用此选项参数标识服务器。
-
-### 选项:
-
-  `<no option> `如果使用不带选项参数的jmap打印共享对象映射，将会打印目标虚拟机中加载的每个共享对象的起始地址、映射大小以及共享对象文件的路径全称。这与Solaris的pmap工具比较相似。
-  `-dump:[live,]format=b,file=<filename>` 以hprof二进制格式转储Java堆到指定filename的文件中。live子选项是可选的。如果指定了live子选项，堆中只有活动的对象会被转储。想要浏览heap dump，你可以使用jhat(Java堆分析工具)读取生成的文件。
-  `-finalizerinfo` 打印等待终结的对象信息。
-  `-heap` 打印一个堆的摘要信息，包括使用的GC算法、堆配置信息和generation wise heap usage。
-  `-histo[:live]` 打印堆的柱状图。其中包括每个Java类、对象数量、内存大小(单位：字节)、完全限定的类名。打印的虚拟机内部的类名称将会带有一个’ * ’前缀。如果指定了live子选项，则只计算活动的对象。
-  `-permstat` 打印Java堆内存的永久保存区域的类加载器的智能统计信息。对于每个类加载器而言，它的名称、活跃度、地址、父类加载器、它所加载的类的数量和大小都会被打印。此外，包含的字符串数量和大小也会被打印。
-  `-F` 强制模式。如果指定的pid没有响应，请使用jmap -dump或jmap -histo选项。此模式下，不支持live子选项。
-  `-h` 打印帮助信息。
-  `-help` 打印帮助信息。
-  `-J<flag> `指定传递给运行jmap的JVM的参数。
-
-  举例
-  查看java 堆（heap）使用情况,执行命令：
-  ```yml
-  hollis@hos:~/workspace/design_apaas/apaasweb/control/bin$ jmap -heap 31846
-
-  Attaching to process ID 31846, please wait...
-  Debugger attached successfully.
-  Server compiler detected.
-  JVM version is 24.71-b01
-
-  using thread-local object allocation.
-  Parallel GC with 4 thread(s)//GC 方式
-
-  Heap Configuration: //堆内存初始化配置
-     MinHeapFreeRatio = 0 //对应jvm启动参数-XX:MinHeapFreeRatio设置JVM堆最小空闲比率(default 40)
-     MaxHeapFreeRatio = 100 //对应jvm启动参数 -XX:MaxHeapFreeRatio设置JVM堆最大空闲比率(default 70)
-     MaxHeapSize      = 2082471936 (1986.0MB) //对应jvm启动参数-XX:MaxHeapSize=设置JVM堆的最大大小
-     NewSize          = 1310720 (1.25MB)//对应jvm启动参数-XX:NewSize=设置JVM堆的‘新生代’的默认大小
-     MaxNewSize       = 17592186044415 MB//对应jvm启动参数-XX:MaxNewSize=设置JVM堆的‘新生代’的最大大小
-     OldSize          = 5439488 (5.1875MB)//对应jvm启动参数-XX:OldSize=<value>:设置JVM堆的‘老生代’的大小
-     NewRatio         = 2 //对应jvm启动参数-XX:NewRatio=:‘新生代’和‘老生代’的大小比率
-     SurvivorRatio    = 8 //对应jvm启动参数-XX:SurvivorRatio=设置年轻代中Eden区与Survivor区的大小比值
-     PermSize         = 21757952 (20.75MB)  //对应jvm启动参数-XX:PermSize=<value>:设置JVM堆的‘永生代’的初始大小
-     MaxPermSize      = 85983232 (82.0MB)//对应jvm启动参数-XX:MaxPermSize=<value>:设置JVM堆的‘永生代’的最大大小
-     G1HeapRegionSize = 0 (0.0MB)
-
-  Heap Usage://堆内存使用情况
-  PS Young Generation
-  Eden Space://Eden区内存分布
-     capacity = 33030144 (31.5MB)//Eden区总容量
-     used     = 1524040 (1.4534378051757812MB)  //Eden区已使用
-     free     = 31506104 (30.04656219482422MB)  //Eden区剩余容量
-     4.614088270399305% used //Eden区使用比率
-  From Space:  //其中一个Survivor区的内存分布
-     capacity = 5242880 (5.0MB)
-     used     = 0 (0.0MB)
-     free     = 5242880 (5.0MB)
-     0.0% used
-  To Space:  //另一个Survivor区的内存分布
-     capacity = 5242880 (5.0MB)
-     used     = 0 (0.0MB)
-     free     = 5242880 (5.0MB)
-     0.0% used
-  PS Old Generation //当前的Old区内存分布
-     capacity = 86507520 (82.5MB)
-     used     = 0 (0.0MB)
-     free     = 86507520 (82.5MB)
-     0.0% used
-  PS Perm Generation//当前的 “永生代” 内存分布
-     capacity = 22020096 (21.0MB)
-     used     = 2496528 (2.3808746337890625MB)
-     free     = 19523568 (18.619125366210938MB)
-     11.337498256138392% used
-
-  670 interned Strings occupying 43720 bytes.
-  ```
-
-
-  查看堆内存(histogram)中的对象数量及大小。执行命令：
-  ```
-  hollis@hos:~/workspace/design_apaas/apaasweb/control/bin$ jmap -histo 3331
-
-  num     #instances         #bytes  class name
-  编号     个数                字节     类名
-  ----------------------------------------------
-     1:             7        1322080  [I
-     2:          5603         722368  <methodKlass>
-     3:          5603         641944  <constMethodKlass>
-     4:         34022         544352  java.lang.Integer
-     5:           371         437208  <constantPoolKlass>
-     6:           336         270624  <constantPoolCacheKlass>
-     7:           371         253816  <instanceKlassKlass>
-  ```
-
-  ```
-  jmap -histo:live 这个命令执行，JVM会先触发gc，然后再统计信息。
-  ```
-
-  将内存使用的详细情况输出到文件，执行命令：
-  ```
-  hollis@hos:~/workspace/design_apaas/apaasweb/control/bin$ jmap -dump:format=b,file=heapDump 6900
-  ```
-
-  然后用jhat命令可以参看 jhat -port 5000 heapDump 在浏览器中访问：http://localhost:5000/ 查看详细信息
-
-  这个命令执行，JVM会将整个heap的信息dump写入到一个文件，heap如果比较大的话，就会导致这个过程比较耗时，并且执行的过程中为了保证dump的信息是可靠的，所以会暂停应用。
-
-  总结
-  1. 如果程序内存不足或者频繁GC，很有可能存在内存泄露情况，这时候就要借助Java堆Dump查看对象的情况。
-  2. 要制作堆Dump可以直接使用jvm自带的jmap命令
-  3. 可以先使用jmap -heap命令查看堆的使用情况，看一下各个堆空间的占用情况。
-  4. 使用jmap -histo:[live]查看堆内存中的对象的情况。如果有大量对象在持续被引用，并没有被释放掉，那就产生了内存泄露，就要结合代码，把不用的对象释放掉。
-  5. 也可以使用 jmap -dump:format=b,file=<fileName>命令将堆信息保存到一个文件中，再借助jhat命令查看详细内容
-  6. 在内存出现泄露、溢出或者其它前提条件下，建议多dump几次内存，把内存文件进行编号归档，便于后续内存整理分析。
-
-  Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can’t attach to the process
-  在ubuntu中第一次使用jmap会报错：Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process，
-  这是oracla文档中提到的一个bug:http://bugs.java.com/bugdatabase/view_bug.do?bug_id=7050524,解决方式如下：
-
-  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope 该方法在下次重启前有效。
-
-  永久有效方法 sudo vi /etc/sysctl.d/10-ptrace.conf 编辑下面这行: kernel.yama.ptrace_scope = 1 修改为: kernel.yama.ptrace_scope = 0 重启系统，使修改生效。
+Jmap
+
+  jmap是JDK自带的工具软件，主要用于打印指定Java进程(或核心文件、远程调试服务器)的共享对象内存映射或堆内存细节。可以使用jmap生成Heap  这篇文章主要介绍Java的堆Dump以及jamp命令
+
+### 什么是堆Dump
+  堆Dump是反应Java堆使用情况的内存镜像，其中主要包括系统信息、虚拟机属性、完整的线程Dump、所有类和对象的状态等。 一般，在内存不足、GC异常等情况下，我们就会怀疑有内存泄露。这个时候我们就可以制作堆Dump来查看具体情况。分析原因。
+
+### 基础知识
+
+  常见内存错误：
+  outOfMemoryError 年老代内存不足。
+  outOfMemoryError:PermGen Space 永久代内存不足。
+  outOfMemoryError:GC overhead limit exceed 垃圾回收时间占用系统运行时间的98%或以上。
+
+### jmap
+
+  用法摘要
+  ``` yml
+  Usage:
+      jmap [option] <pid>
+          (to connect to running process)
+      jmap [option] <executable <core>
+          (to connect to a core file)
+      jmap [option] [server_id@]<remote server IP or hostname>
+          (to connect to remote debug server)
+
+  where <option> is one of:
+      <none>               to print same info as Solaris pmap
+      -heap                to print java heap summary
+      -histo[:live]        to print histogram of java object heap; if the "live"
+                           suboption is specified, only count live objects
+      -permstat            to print permanent generation statistics
+      -finalizerinfo       to print information on objects awaiting finalization
+      -dump:<dump-options> to dump java heap in hprof binary format
+                           dump-options:
+                             live         dump only live objects; if not specified,
+                                          all objects in the heap are dumped.
+                             format=b     binary format
+                             file=<file>  dump heap to <file>
+                           Example: jmap -dump:live,format=b,file=heap.bin <pid>
+      -F                   force. Use with -dump:<dump-options> <pid> or -histo
+                           to force a heap dump or histogram when <pid> does not
+                           respond. The "live" suboption is not supported
+                           in this mode.
+      -h | -help           to print this help message
+      -J<flag>             to pass <flag> directly to the runtime system
+  ```
+  指定进程号(pid)的进程 jmap [ option ] 指定核心文件 jmap [ option ] 指定远程调试服务器 jmap [ option ] [server-id@]
+
+### 参数：
+
+  `option` 选项参数是互斥的(不可同时使用)。想要使用选项参数，直接跟在命令名称后即可。
+  `pid` 需要打印配置信息的进程ID。该进程必须是一个Java进程。想要获取运行的Java进程列表，你可以使用jps。
+  `executable` 产生核心dump的Java可执行文件。
+  `core` 需要打印配置信息的核心文件。
+  `remote-hostname-or-IP` 远程调试服务器的(请查看jsadebugd)主机名或IP地址。
+  `server-id` 可选的唯一id，如果相同的远程主机上运行了多台调试服务器，用此选项参数标识服务器。
+
+### 选项:
+
+  `<no option> `如果使用不带选项参数的jmap打印共享对象映射，将会打印目标虚拟机中加载的每个共享对象的起始地址、映射大小以及共享对象文件的路径全称。这与Solaris的pmap工具比较相似。
+  `-dump:[live,]format=b,file=<filename>` 以hprof二进制格式转储Java堆到指定filename的文件中。live子选项是可选的。如果指定了live子选项，堆中只有活动的对象会被转储。想要浏览heap dump，你可以使用jhat(Java堆分析工具)读取生成的文件。
+  `-finalizerinfo` 打印等待终结的对象信息。
+  `-heap` 打印一个堆的摘要信息，包括使用的GC算法、堆配置信息和generation wise heap usage。
+  `-histo[:live]` 打印堆的柱状图。其中包括每个Java类、对象数量、内存大小(单位：字节)、完全限定的类名。打印的虚拟机内部的类名称将会带有一个’ * ’前缀。如果指定了live子选项，则只计算活动的对象。
+  `-permstat` 打印Java堆内存的永久保存区域的类加载器的智能统计信息。对于每个类加载器而言，它的名称、活跃度、地址、父类加载器、它所加载的类的数量和大小都会被打印。此外，包含的字符串数量和大小也会被打印。
+  `-F` 强制模式。如果指定的pid没有响应，请使用jmap -dump或jmap -histo选项。此模式下，不支持live子选项。
+  `-h` 打印帮助信息。
+  `-help` 打印帮助信息。
+  `-J<flag> `指定传递给运行jmap的JVM的参数。
+
+  举例
+  查看java 堆（heap）使用情况,执行命令：
+  ```yml
+  hollis@hos:~/workspace/design_apaas/apaasweb/control/bin$ jmap -heap 31846
+
+  Attaching to process ID 31846, please wait...
+  Debugger attached successfully.
+  Server compiler detected.
+  JVM version is 24.71-b01
+
+  using thread-local object allocation.
+  Parallel GC with 4 thread(s)//GC 方式
+
+  Heap Configuration: //堆内存初始化配置
+     MinHeapFreeRatio = 0 //对应jvm启动参数-XX:MinHeapFreeRatio设置JVM堆最小空闲比率(default 40)
+     MaxHeapFreeRatio = 100 //对应jvm启动参数 -XX:MaxHeapFreeRatio设置JVM堆最大空闲比率(default 70)
+     MaxHeapSize      = 2082471936 (1986.0MB) //对应jvm启动参数-XX:MaxHeapSize=设置JVM堆的最大大小
+     NewSize          = 1310720 (1.25MB)//对应jvm启动参数-XX:NewSize=设置JVM堆的‘新生代’的默认大小
+     MaxNewSize       = 17592186044415 MB//对应jvm启动参数-XX:MaxNewSize=设置JVM堆的‘新生代’的最大大小
+     OldSize          = 5439488 (5.1875MB)//对应jvm启动参数-XX:OldSize=<value>:设置JVM堆的‘老生代’的大小
+     NewRatio         = 2 //对应jvm启动参数-XX:NewRatio=:‘新生代’和‘老生代’的大小比率
+     SurvivorRatio    = 8 //对应jvm启动参数-XX:SurvivorRatio=设置年轻代中Eden区与Survivor区的大小比值
+     PermSize         = 21757952 (20.75MB)  //对应jvm启动参数-XX:PermSize=<value>:设置JVM堆的‘永生代’的初始大小
+     MaxPermSize      = 85983232 (82.0MB)//对应jvm启动参数-XX:MaxPermSize=<value>:设置JVM堆的‘永生代’的最大大小
+     G1HeapRegionSize = 0 (0.0MB)
+
+  Heap Usage://堆内存使用情况
+  PS Young Generation
+  Eden Space://Eden区内存分布
+     capacity = 33030144 (31.5MB)//Eden区总容量
+     used     = 1524040 (1.4534378051757812MB)  //Eden区已使用
+     free     = 31506104 (30.04656219482422MB)  //Eden区剩余容量
+     4.614088270399305% used //Eden区使用比率
+  From Space:  //其中一个Survivor区的内存分布
+     capacity = 5242880 (5.0MB)
+     used     = 0 (0.0MB)
+     free     = 5242880 (5.0MB)
+     0.0% used
+  To Space:  //另一个Survivor区的内存分布
+     capacity = 5242880 (5.0MB)
+     used     = 0 (0.0MB)
+     free     = 5242880 (5.0MB)
+     0.0% used
+  PS Old Generation //当前的Old区内存分布
+     capacity = 86507520 (82.5MB)
+     used     = 0 (0.0MB)
+     free     = 86507520 (82.5MB)
+     0.0% used
+  PS Perm Generation//当前的 “永生代” 内存分布
+     capacity = 22020096 (21.0MB)
+     used     = 2496528 (2.3808746337890625MB)
+     free     = 19523568 (18.619125366210938MB)
+     11.337498256138392% used
+
+  670 interned Strings occupying 43720 bytes.
+  ```
+
+
+  查看堆内存(histogram)中的对象数量及大小。执行命令：
+  ```
+  hollis@hos:~/workspace/design_apaas/apaasweb/control/bin$ jmap -histo 3331
+
+  num     #instances         #bytes  class name
+  编号     个数                字节     类名
+  ----------------------------------------------
+     1:             7        1322080  [I
+     2:          5603         722368  <methodKlass>
+     3:          5603         641944  <constMethodKlass>
+     4:         34022         544352  java.lang.Integer
+     5:           371         437208  <constantPoolKlass>
+     6:           336         270624  <constantPoolCacheKlass>
+     7:           371         253816  <instanceKlassKlass>
+  ```
+
+  ```
+  jmap -histo:live 这个命令执行，JVM会先触发gc，然后再统计信息。
+  ```
+
+  将内存使用的详细情况输出到文件，执行命令：
+  ```
+  hollis@hos:~/workspace/design_apaas/apaasweb/control/bin$ jmap -dump:format=b,file=heapDump 6900
+  ```
+
+  然后用jhat命令可以参看 jhat -port 5000 heapDump 在浏览器中访问：http://localhost:5000/ 查看详细信息
+
+  这个命令执行，JVM会将整个heap的信息dump写入到一个文件，heap如果比较大的话，就会导致这个过程比较耗时，并且执行的过程中为了保证dump的信息是可靠的，所以会暂停应用。
+
+  总结
+  1. 如果程序内存不足或者频繁GC，很有可能存在内存泄露情况，这时候就要借助Java堆Dump查看对象的情况。
+  2. 要制作堆Dump可以直接使用jvm自带的jmap命令
+  3. 可以先使用jmap -heap命令查看堆的使用情况，看一下各个堆空间的占用情况。
+  4. 使用jmap -histo:[live]查看堆内存中的对象的情况。如果有大量对象在持续被引用，并没有被释放掉，那就产生了内存泄露，就要结合代码，把不用的对象释放掉。
+  5. 也可以使用 jmap -dump:format=b,file=<fileName>命令将堆信息保存到一个文件中，再借助jhat命令查看详细内容
+  6. 在内存出现泄露、溢出或者其它前提条件下，建议多dump几次内存，把内存文件进行编号归档，便于后续内存整理分析。
+
+  Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can’t attach to the process
+  在ubuntu中第一次使用jmap会报错：Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process，
+  这是oracla文档中提到的一个bug:http://bugs.java.com/bugdatabase/view_bug.do?bug_id=7050524,解决方式如下：
+
+  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope 该方法在下次重启前有效。
+
+  永久有效方法 sudo vi /etc/sysctl.d/10-ptrace.conf 编辑下面这行: kernel.yama.ptrace_scope = 1 修改为: kernel.yama.ptrace_scope = 0 重启系统，使修改生效。
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/05 - jhat.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/05 - jhat.md"
similarity index 98%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/05 - jhat.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/05 - jhat.md"
index 70e5ee3b..de33f89a 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/05 - jhat.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/05 - jhat.md"	
@@ -1,124 +1,124 @@
-jhat(Java Heap Analysis Tool),是一个用来分析java的堆情况的命令。之前的文章讲到过，使用jmap可以生成Java堆的Dump文件。生成dump文件之后就可以用jhat命令，将dump文件转成html的形式，然后通过http访问可以查看堆情况。
-jhat命令解析会Java堆dump并启动一个web服务器，然后就可以在浏览器中查看堆的dump文件了。
-实例
-
-### 一、导出dump文件
-关于dump文件的生成可以看jmap命令的详细介绍.
-1、运行java程序
-```
-/**
- * Created by hollis on 16/1/21.
- */
-public class JhatTest {
-
-    public static void main(String[] args) {
-        while(true) {
-            String string = new String("hollis");
-            System.out.println(string);
-        }
-    }
-}
-```
-2、查看该进程的ID
-```
-HollisMacBook-Air:apaas hollis$ jps -l
-68680 org.jetbrains.jps.cmdline.Launcher
-62247 com.intellij.rt.execution.application.AppMain
-69038 sun.tools.jps.Jps
-```
-使用jps命令查看发现有三个java进程在运行，一个是我的IDEA使用的进程68680，一个是JPS命令使用的进程69038，另外一个就是上面那段代码运行的进程62247。
-3、生成dump文件
-```
-HollisMacBook-Air:test hollis$ jmap -dump:format=b,file=heapDump 62247
-Dumping heap to /Users/hollis/workspace/test/heapDump ...
-Heap dump file created
-```
-以上命令可以将进程6900的堆dump文件导出到heapDump文件中。
-查看当前目录就能看到heapDump文件。
-除了使用jmap命令，还可以通过以下方式：
-1、使用 jconsole 选项通过 HotSpotDiagnosticMXBean 从运行时获得堆转储（生成dump文件）、
-2、虚拟机启动时如果指定了 -XX:+HeapDumpOnOutOfMemoryError 选项, 则在抛出 OutOfMemoryError 时, 会自动执行堆转储。
-3、使用 hprof 命令
-
-### 二、解析Java堆转储文件,并启动一个 web server
-```
-HollisMacBook-Air:apaas hollis$ jhat heapDump
-Reading from heapDump...
-Dump file created Thu Jan 21 18:59:51 CST 2016
-Snapshot read, resolving...
-Resolving 341297 objects...
-Chasing references, expect 68 dots....................................................................
-Eliminating duplicate references....................................................................
-Snapshot resolved.
-Started HTTP server on port 7000
-Server is ready.
-```
-使用jhat命令，就启动了一个http服务，端口是7000
-然后在访问http://localhost:7000/
-页面如下：
-
-### 三、分析
-在浏览器里面看到dump文件之后就可以进行分析了。这个页面会列出当前进程中的所有对像情况。
-该页面提供了几个查询功能可供使用：
-All classes including platform//
-Show all members of the rootset
-Show instance counts for all classes (including platform)
-Show instance counts for all classes (excluding platform)
-Show heap histogram
-Show finalizer summary
-Execute Object Query Language (OQL) query
-一般查看堆异常情况主要看这个两个部分：
-Show instance counts for all classes (excluding platform)，平台外的所有对象信息。如下图：
-
-Show heap histogram 以树状图形式展示堆情况。如下图：
-
-具体排查时需要结合代码，观察是否大量应该被回收的对象在一直被引用或者是否有占用内存特别大的对象无法被回收。
-
-### 用法摘要
-这一部分放在后面介绍的原因是一般不太使用。
-```
-HollisMacBook-Air:~ hollis$ jhat -help
-Usage:  jhat [-stack <bool>] [-refs <bool>] [-port <port>] [-baseline <file>] [-debug <int>] [-version] [-h|-help] <file>
-
-    -J<flag>          Pass <flag> directly to the runtime system. For
-              example, -J-mx512m to use a maximum heap size of 512MB
-    -stack false:     Turn off tracking object allocation call stack.
-    -refs false:      Turn off tracking of references to objects
-    -port <port>:     Set the port for the HTTP server.  Defaults to 7000
-    -exclude <file>:  Specify a file that lists data members that should
-              be excluded from the reachableFrom query.
-    -baseline <file>: Specify a baseline object dump.  Objects in
-              both heap dumps with the same ID and same class will
-              be marked as not being "new".
-    -debug <int>:     Set debug level.
-                0:  No debug output
-                1:  Debug hprof file parsing
-                2:  Debug hprof file parsing, no server
-    -version          Report version number
-    -h|-help          Print this help and exit
-    <file>            The file to read
-```
--stack false|true
-关闭对象分配调用栈跟踪(tracking object allocation call stack)。 如果分配位置信息在堆转储中不可用. 则必须将此标志设置为 false. 默认值为 true.
--refs false|true
-关闭对象引用跟踪(tracking of references to objects)。 默认值为 true. 默认情况下, 返回的指针是指向其他特定对象的对象,如反向链接或输入引用(referrers or incoming references), 会统计/计算堆中的所有对象。
--port port-number
-设置 jhat HTTP server 的端口号. 默认值 7000.
--exclude exclude-file
-指定对象查询时需要排除的数据成员列表文件(a file that lists data members that should be excluded from the reachable objects query)。 例如, 如果文件列列出了 java.lang.String.value , 那么当从某个特定对象 Object o 计算可达的对象列表时, 引用路径涉及 java.lang.String.value 的都会被排除。
--baseline exclude-file
-指定一个基准堆转储(baseline heap dump)。 在两个 heap dumps 中有相同 object ID 的对象会被标记为不是新的(marked as not being new). 其他对象被标记为新的(new). 在比较两个不同的堆转储时很有用.
--debug int
-设置 debug 级别. 0 表示不输出调试信息。 值越大则表示输出更详细的 debug 信息.
--version
-启动后只显示版本信息就退出
--J< flag >
-因为 jhat 命令实际上会启动一个JVM来执行, 通过 -J 可以在启动JVM时传入一些启动参数. 例如, -J-Xmx512m 则指定运行 jhat 的Java虚拟机使用的最大堆内存为 512 MB. 如果需要使用多个JVM启动参数,则传入多个 -Jxxxxxx.
-
-### OQL
-jhat还提供了一种对象查询语言(Object Query Language)，OQL有点类似SQL,可以用来查询。
-OQL语句的执行页面: http://localhost:7000/oql/
-OQL帮助信息页面为: http://localhost:7000/oqlhelp/
-OQL的预发可以在帮助页面查看，这里就不详细讲解了。
-参考资料
-jhat
+jhat(Java Heap Analysis Tool),是一个用来分析java的堆情况的命令。之前的文章讲到过，使用jmap可以生成Java堆的Dump文件。生成dump文件之后就可以用jhat命令，将dump文件转成html的形式，然后通过http访问可以查看堆情况。
+jhat命令解析会Java堆dump并启动一个web服务器，然后就可以在浏览器中查看堆的dump文件了。
+实例
+
+### 一、导出dump文件
+关于dump文件的生成可以看jmap命令的详细介绍.
+1、运行java程序
+```
+/**
+ * Created by hollis on 16/1/21.
+ */
+public class JhatTest {
+
+    public static void main(String[] args) {
+        while(true) {
+            String string = new String("hollis");
+            System.out.println(string);
+        }
+    }
+}
+```
+2、查看该进程的ID
+```
+HollisMacBook-Air:apaas hollis$ jps -l
+68680 org.jetbrains.jps.cmdline.Launcher
+62247 com.intellij.rt.execution.application.AppMain
+69038 sun.tools.jps.Jps
+```
+使用jps命令查看发现有三个java进程在运行，一个是我的IDEA使用的进程68680，一个是JPS命令使用的进程69038，另外一个就是上面那段代码运行的进程62247。
+3、生成dump文件
+```
+HollisMacBook-Air:test hollis$ jmap -dump:format=b,file=heapDump 62247
+Dumping heap to /Users/hollis/workspace/test/heapDump ...
+Heap dump file created
+```
+以上命令可以将进程6900的堆dump文件导出到heapDump文件中。
+查看当前目录就能看到heapDump文件。
+除了使用jmap命令，还可以通过以下方式：
+1、使用 jconsole 选项通过 HotSpotDiagnosticMXBean 从运行时获得堆转储（生成dump文件）、
+2、虚拟机启动时如果指定了 -XX:+HeapDumpOnOutOfMemoryError 选项, 则在抛出 OutOfMemoryError 时, 会自动执行堆转储。
+3、使用 hprof 命令
+
+### 二、解析Java堆转储文件,并启动一个 web server
+```
+HollisMacBook-Air:apaas hollis$ jhat heapDump
+Reading from heapDump...
+Dump file created Thu Jan 21 18:59:51 CST 2016
+Snapshot read, resolving...
+Resolving 341297 objects...
+Chasing references, expect 68 dots....................................................................
+Eliminating duplicate references....................................................................
+Snapshot resolved.
+Started HTTP server on port 7000
+Server is ready.
+```
+使用jhat命令，就启动了一个http服务，端口是7000
+然后在访问http://localhost:7000/
+页面如下：
+
+### 三、分析
+在浏览器里面看到dump文件之后就可以进行分析了。这个页面会列出当前进程中的所有对像情况。
+该页面提供了几个查询功能可供使用：
+All classes including platform//
+Show all members of the rootset
+Show instance counts for all classes (including platform)
+Show instance counts for all classes (excluding platform)
+Show heap histogram
+Show finalizer summary
+Execute Object Query Language (OQL) query
+一般查看堆异常情况主要看这个两个部分：
+Show instance counts for all classes (excluding platform)，平台外的所有对象信息。如下图：
+
+Show heap histogram 以树状图形式展示堆情况。如下图：
+
+具体排查时需要结合代码，观察是否大量应该被回收的对象在一直被引用或者是否有占用内存特别大的对象无法被回收。
+
+### 用法摘要
+这一部分放在后面介绍的原因是一般不太使用。
+```
+HollisMacBook-Air:~ hollis$ jhat -help
+Usage:  jhat [-stack <bool>] [-refs <bool>] [-port <port>] [-baseline <file>] [-debug <int>] [-version] [-h|-help] <file>
+
+    -J<flag>          Pass <flag> directly to the runtime system. For
+              example, -J-mx512m to use a maximum heap size of 512MB
+    -stack false:     Turn off tracking object allocation call stack.
+    -refs false:      Turn off tracking of references to objects
+    -port <port>:     Set the port for the HTTP server.  Defaults to 7000
+    -exclude <file>:  Specify a file that lists data members that should
+              be excluded from the reachableFrom query.
+    -baseline <file>: Specify a baseline object dump.  Objects in
+              both heap dumps with the same ID and same class will
+              be marked as not being "new".
+    -debug <int>:     Set debug level.
+                0:  No debug output
+                1:  Debug hprof file parsing
+                2:  Debug hprof file parsing, no server
+    -version          Report version number
+    -h|-help          Print this help and exit
+    <file>            The file to read
+```
+-stack false|true
+关闭对象分配调用栈跟踪(tracking object allocation call stack)。 如果分配位置信息在堆转储中不可用. 则必须将此标志设置为 false. 默认值为 true.
+-refs false|true
+关闭对象引用跟踪(tracking of references to objects)。 默认值为 true. 默认情况下, 返回的指针是指向其他特定对象的对象,如反向链接或输入引用(referrers or incoming references), 会统计/计算堆中的所有对象。
+-port port-number
+设置 jhat HTTP server 的端口号. 默认值 7000.
+-exclude exclude-file
+指定对象查询时需要排除的数据成员列表文件(a file that lists data members that should be excluded from the reachable objects query)。 例如, 如果文件列列出了 java.lang.String.value , 那么当从某个特定对象 Object o 计算可达的对象列表时, 引用路径涉及 java.lang.String.value 的都会被排除。
+-baseline exclude-file
+指定一个基准堆转储(baseline heap dump)。 在两个 heap dumps 中有相同 object ID 的对象会被标记为不是新的(marked as not being new). 其他对象被标记为新的(new). 在比较两个不同的堆转储时很有用.
+-debug int
+设置 debug 级别. 0 表示不输出调试信息。 值越大则表示输出更详细的 debug 信息.
+-version
+启动后只显示版本信息就退出
+-J< flag >
+因为 jhat 命令实际上会启动一个JVM来执行, 通过 -J 可以在启动JVM时传入一些启动参数. 例如, -J-Xmx512m 则指定运行 jhat 的Java虚拟机使用的最大堆内存为 512 MB. 如果需要使用多个JVM启动参数,则传入多个 -Jxxxxxx.
+
+### OQL
+jhat还提供了一种对象查询语言(Object Query Language)，OQL有点类似SQL,可以用来查询。
+OQL语句的执行页面: http://localhost:7000/oql/
+OQL帮助信息页面为: http://localhost:7000/oqlhelp/
+OQL的预发可以在帮助页面查看，这里就不详细讲解了。
+参考资料
+jhat
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/06 - javap.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/06 - javap.md"
similarity index 97%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/06 - javap.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/06 - javap.md"
index 01082ee5..65e733c5 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/06 - javap.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/06 - javap.md"	
@@ -1,114 +1,114 @@
-javap是jdk自带的一个工具，可以对 **代码反编译**，也可以 **查看java编译器生成的字节码**。
-
-一般情况下，很少有人使用javap对class文件进行反编译，因为有很多成熟的反编译工具可以使用，比如 **jad** **http://javare.cn/**。
-但是，javap还可以查看java编译器为我们生成的字节码。
-通过它，可以对照源代码和字节码，从而了解很多编译器内部的工作。
-
-实例
-javap命令分解一个class文件，它根据options来决定到底输出什么。来看这个例子，先编译(javac)下面这个类。
-``` java
-import java.awt.*;
-import java.applet.*;
-
-public class DocFooter extends Applet {
-        String date;
-        String email;
-
-        public void init() {
-                resize(500,100);
-                date = getParameter("LAST_UPDATED");
-                email = getParameter("EMAIL");
-        }
-
-        public void paint(Graphics g) {
-                g.drawString(date + " by ",100, 15);
-                g.drawString(email,290,15);
-        }
-}
-```
-在命令行上键入javap DocFooter后，输出结果如下
-
-如果没有使用options,那么javap将会输出包，类里的protected和public域以及类里的所有方法。javap将会把它们输出在标准输出上。
-``` java
-Compiled from "DocFooter.java"
-public class DocFooter extends java.applet.Applet {
-  java.lang.String date;
-  java.lang.String email;
-  public DocFooter();
-  public void init();
-  public void paint(java.awt.Graphics);
-}
-```
-如果加入了-c，即javap -c DocFooter，那么输出结果如下 输出的内容就是 **字节码**。
-``` java
-Compiled from "DocFooter.java"
-public class DocFooter extends java.applet.Applet {
-  java.lang.String date;
-
-  java.lang.String email;
-
-  public DocFooter();
-    Code:
-       0: aload_0       
-       1: invokespecial #1                  // Method java/applet/Applet."<init>":()V
-       4: return        
-
-  public void init();
-    Code:
-       0: aload_0       
-       1: sipush        500
-       4: bipush        100
-       6: invokevirtual #2                  // Method resize:(II)V
-       9: aload_0       
-      10: aload_0       
-      11: ldc           #3                  // String LAST_UPDATED
-      13: invokevirtual #4                  // Method getParameter:(Ljava/lang/String;)Ljava/lang/String;
-      16: putfield      #5                  // Field date:Ljava/lang/String;
-      19: aload_0       
-      20: aload_0       
-      21: ldc           #6                  // String EMAIL
-      23: invokevirtual #4                  // Method getParameter:(Ljava/lang/String;)Ljava/lang/String;
-      26: putfield      #7                  // Field email:Ljava/lang/String;
-      29: return        
-
-  public void paint(java.awt.Graphics);
-    Code:
-       0: aload_1       
-       1: new           #8                  // class java/lang/StringBuilder
-       4: dup           
-       5: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
-       8: aload_0       
-       9: getfield      #5                  // Field date:Ljava/lang/String;
-      12: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
-      15: ldc           #11                 // String  by
-      17: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
-      20: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
-      23: bipush        100
-      25: bipush        15
-      27: invokevirtual #13                 // Method java/awt/Graphics.drawString:(Ljava/lang/String;II)V
-      30: aload_1       
-      31: aload_0       
-      32: getfield      #7                  // Field email:Ljava/lang/String;
-      35: sipush        290
-      38: bipush        15
-      40: invokevirtual #13                 // Method java/awt/Graphics.drawString:(Ljava/lang/String;II)V
-      43: return        
-}
-```
-
-用法摘要
--help 帮助
--l 输出行和变量的表
--public 只输出public方法和域
--protected 只输出public和protected类和成员
--package 只输出包，public和protected类和成员，这是默认的
--p -private 输出所有类和成员
--s 输出内部类型签名
--c 输出分解后的代码，例如，类中每一个方法内，包含java字节码的指令，
--verbose 输出栈大小，方法参数的个数
--constants 输出静态final常量
-
-总结
-javap可以用于 **反编译** 和 **查看编译器编译后的字节码**。
-平时一般用javap -c比较多，该命令用于列出每个方法所执行的JVM指令，并显示每个方法的字节码的实际作用。
-可以通过字节码和源代码的对比，深入分析java的编译原理，了解和解决各种Java原理级别的问题。
+javap是jdk自带的一个工具，可以对 **代码反编译**，也可以 **查看java编译器生成的字节码**。
+
+一般情况下，很少有人使用javap对class文件进行反编译，因为有很多成熟的反编译工具可以使用，比如 **jad** **http://javare.cn/**。
+但是，javap还可以查看java编译器为我们生成的字节码。
+通过它，可以对照源代码和字节码，从而了解很多编译器内部的工作。
+
+实例
+javap命令分解一个class文件，它根据options来决定到底输出什么。来看这个例子，先编译(javac)下面这个类。
+``` java
+import java.awt.*;
+import java.applet.*;
+
+public class DocFooter extends Applet {
+        String date;
+        String email;
+
+        public void init() {
+                resize(500,100);
+                date = getParameter("LAST_UPDATED");
+                email = getParameter("EMAIL");
+        }
+
+        public void paint(Graphics g) {
+                g.drawString(date + " by ",100, 15);
+                g.drawString(email,290,15);
+        }
+}
+```
+在命令行上键入javap DocFooter后，输出结果如下
+
+如果没有使用options,那么javap将会输出包，类里的protected和public域以及类里的所有方法。javap将会把它们输出在标准输出上。
+``` java
+Compiled from "DocFooter.java"
+public class DocFooter extends java.applet.Applet {
+  java.lang.String date;
+  java.lang.String email;
+  public DocFooter();
+  public void init();
+  public void paint(java.awt.Graphics);
+}
+```
+如果加入了-c，即javap -c DocFooter，那么输出结果如下 输出的内容就是 **字节码**。
+``` java
+Compiled from "DocFooter.java"
+public class DocFooter extends java.applet.Applet {
+  java.lang.String date;
+
+  java.lang.String email;
+
+  public DocFooter();
+    Code:
+       0: aload_0       
+       1: invokespecial #1                  // Method java/applet/Applet."<init>":()V
+       4: return        
+
+  public void init();
+    Code:
+       0: aload_0       
+       1: sipush        500
+       4: bipush        100
+       6: invokevirtual #2                  // Method resize:(II)V
+       9: aload_0       
+      10: aload_0       
+      11: ldc           #3                  // String LAST_UPDATED
+      13: invokevirtual #4                  // Method getParameter:(Ljava/lang/String;)Ljava/lang/String;
+      16: putfield      #5                  // Field date:Ljava/lang/String;
+      19: aload_0       
+      20: aload_0       
+      21: ldc           #6                  // String EMAIL
+      23: invokevirtual #4                  // Method getParameter:(Ljava/lang/String;)Ljava/lang/String;
+      26: putfield      #7                  // Field email:Ljava/lang/String;
+      29: return        
+
+  public void paint(java.awt.Graphics);
+    Code:
+       0: aload_1       
+       1: new           #8                  // class java/lang/StringBuilder
+       4: dup           
+       5: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
+       8: aload_0       
+       9: getfield      #5                  // Field date:Ljava/lang/String;
+      12: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
+      15: ldc           #11                 // String  by
+      17: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
+      20: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
+      23: bipush        100
+      25: bipush        15
+      27: invokevirtual #13                 // Method java/awt/Graphics.drawString:(Ljava/lang/String;II)V
+      30: aload_1       
+      31: aload_0       
+      32: getfield      #7                  // Field email:Ljava/lang/String;
+      35: sipush        290
+      38: bipush        15
+      40: invokevirtual #13                 // Method java/awt/Graphics.drawString:(Ljava/lang/String;II)V
+      43: return        
+}
+```
+
+用法摘要
+-help 帮助
+-l 输出行和变量的表
+-public 只输出public方法和域
+-protected 只输出public和protected类和成员
+-package 只输出包，public和protected类和成员，这是默认的
+-p -private 输出所有类和成员
+-s 输出内部类型签名
+-c 输出分解后的代码，例如，类中每一个方法内，包含java字节码的指令，
+-verbose 输出栈大小，方法参数的个数
+-constants 输出静态final常量
+
+总结
+javap可以用于 **反编译** 和 **查看编译器编译后的字节码**。
+平时一般用javap -c比较多，该命令用于列出每个方法所执行的JVM指令，并显示每个方法的字节码的实际作用。
+可以通过字节码和源代码的对比，深入分析java的编译原理，了解和解决各种Java原理级别的问题。
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/07 - Java\345\274\200\345\217\221\345\277\205\351\241\273\346\216\214\346\217\241\347\232\204\347\272\277\344\270\212\351\227\256\351\242\230\346\216\222\346\237\245\345\221\275\344\273\244.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/07 - Java\345\274\200\345\217\221\345\277\205\351\241\273\346\216\214\346\217\241\347\232\204\347\272\277\344\270\212\351\227\256\351\242\230\346\216\222\346\237\245\345\221\275\344\273\244.md"
similarity index 98%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/07 - Java\345\274\200\345\217\221\345\277\205\351\241\273\346\216\214\346\217\241\347\232\204\347\272\277\344\270\212\351\227\256\351\242\230\346\216\222\346\237\245\345\221\275\344\273\244.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/07 - Java\345\274\200\345\217\221\345\277\205\351\241\273\346\216\214\346\217\241\347\232\204\347\272\277\344\270\212\351\227\256\351\242\230\346\216\222\346\237\245\345\221\275\344\273\244.md"
index cbf454bc..9ff20241 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/07 - Java\345\274\200\345\217\221\345\277\205\351\241\273\346\216\214\346\217\241\347\232\204\347\272\277\344\270\212\351\227\256\351\242\230\346\216\222\346\237\245\345\221\275\344\273\244.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/07 - Java\345\274\200\345\217\221\345\277\205\351\241\273\346\216\214\346\217\241\347\232\204\347\272\277\344\270\212\351\227\256\351\242\230\346\216\222\346\237\245\345\221\275\344\273\244.md"	
@@ -1,73 +1,73 @@
-作为一个合格的开发人员，不仅要能写得一手还代码，还有一项很重要的技能就是排查问题。这里提到的排查问题不仅仅是在coding的过程中debug等，还包括的就是线上问题的排查。由于在生产环境中，一般没办法debug（其实有些问题，debug也白扯。。。）,所以我们需要借助一些常用命令来查看运行时的具体情况，这些运行时信息包括但不限于运行日志、异常堆栈、堆使用情况、GC情况、JVM参数情况、线程情况等。
-给一个系统定位问题的时候，知识、经验是关键，数据是依据，工具是运用知识处理数据的手段。为了便于我们排查和解决问题，Sun公司为我们提供了一些常用命令。这些命令一般都是jdk/lib/tools.jar中类库的一层薄包装。随着JVM的安装一起被安装到机器中，在bin目录中。下面就来认识一下这些命令以及具体使用方式。文中涉及到的所有命令的详细信息可以参考 Java命令学习系列文章
-
-### 1. jps
-功能
-显示当前所有java进程pid的命令。
-常用指令
-jps：显示当前用户的所有java进程的PID
-jps -v 3331：显示虚拟机参数
-jps -m 3331：显示传递给main()函数的参数
-jps -l 3331：显示主类的全路径
-详细介绍
---------------------------------------------------------------------------------
-### 2. jstack
-功能
-生成当前时刻的线程快照。
-常用指令
-jstack 3331：查看线程情况
-jstack -F 3331：正常输出不被响应时，使用该指令
-jstack -l 3331：除堆栈外，显示关于锁的附件信息
-详细介绍
---------------------------------------------------------------------------------
-### 3. jstat
-功能
-显示进程中的类装载、内存、垃圾收集、JIT编译等运行数据。
-常用指令
-jstat -gc 3331 250 20 ：查询进程2764的垃圾收集情况，每250毫秒查询一次，一共查询20次。
-jstat -gccause：额外输出上次GC原因
-jstat -calss：件事类装载、类卸载、总空间以及所消耗的时间
-详细介绍
---------------------------------------------------------------------------------
-### 4. jmap
-功能
-生成堆转储快照（heapdump）
-常用指令
-jmap -heap 3331：查看java 堆（heap）使用情况
-jmap -histo 3331：查看堆内存(histogram)中的对象数量及大小
-jmap -histo:live 3331：JVM会先触发gc，然后再统计信息
-jmap -dump:format=b,file=heapDump 3331：将内存使用的详细情况输出到文件，之后一般使用其他工具进行分析。
-详细介绍
---------------------------------------------------------------------------------
-
-### 5. jhat
-功能
-一般与jmap搭配使用，用来分析jmap生成的堆转储文件。
-由于有很多可视化工具（Eclipse Memory Analyzer 、IBM HeapAnalyzer）可以替代，所以很少用。不过在没有可视化工具的机器上也是可用的。
-常用指令
-jmap -dump:format=b,file=heapDump 3331 + jhat heapDump：解析Java堆转储文件,并启动一个 web server
-详细介绍
---------------------------------------------------------------------------------
-### 6. jinfo
-功能
-实时查看和调整虚拟机参数，可以显示未被显示指定的参数的默认值（jps -v 则不能）。
-`jdk8中已经不支持该命令。`
-常用指令
-jinfo -flag CMSIniniatingOccupancyFration 1444：查询CMSIniniatingOccupancyFration参数值
-详细介绍
---------------------------------------------------------------------------------
-
-常见问题定位过程
-### 频繁GC问题或内存溢出问题
-一、使用jps查看线程ID
-二、使用jstat -gc 3331 250 20 查看gc情况，一般比较关注PERM区的情况，查看GC的增长情况。
-三、使用jstat -gccause：额外输出上次GC原因
-四、使用jmap -dump:format=b,file=heapDump 3331生成堆转储文件
-五、使用jhat或者可视化工具（Eclipse Memory Analyzer 、IBM HeapAnalyzer）分析堆情况。
-六、结合代码解决内存溢出或泄露问题。
---------------------------------------------------------------------------------
-### 死锁问题
-一、使用jps查看线程ID
-二、使用jstack 3331：查看线程情况
-结语
-经常使用适当的虚拟机监控和分析工具可以加快我们分析数据、定位解决问题的速度，但也要知道，工具永远都是知识技能的一层包装，没有什么工具是包治百病的。
+作为一个合格的开发人员，不仅要能写得一手还代码，还有一项很重要的技能就是排查问题。这里提到的排查问题不仅仅是在coding的过程中debug等，还包括的就是线上问题的排查。由于在生产环境中，一般没办法debug（其实有些问题，debug也白扯。。。）,所以我们需要借助一些常用命令来查看运行时的具体情况，这些运行时信息包括但不限于运行日志、异常堆栈、堆使用情况、GC情况、JVM参数情况、线程情况等。
+给一个系统定位问题的时候，知识、经验是关键，数据是依据，工具是运用知识处理数据的手段。为了便于我们排查和解决问题，Sun公司为我们提供了一些常用命令。这些命令一般都是jdk/lib/tools.jar中类库的一层薄包装。随着JVM的安装一起被安装到机器中，在bin目录中。下面就来认识一下这些命令以及具体使用方式。文中涉及到的所有命令的详细信息可以参考 Java命令学习系列文章
+
+### 1. jps
+功能
+显示当前所有java进程pid的命令。
+常用指令
+jps：显示当前用户的所有java进程的PID
+jps -v 3331：显示虚拟机参数
+jps -m 3331：显示传递给main()函数的参数
+jps -l 3331：显示主类的全路径
+详细介绍
+--------------------------------------------------------------------------------
+### 2. jstack
+功能
+生成当前时刻的线程快照。
+常用指令
+jstack 3331：查看线程情况
+jstack -F 3331：正常输出不被响应时，使用该指令
+jstack -l 3331：除堆栈外，显示关于锁的附件信息
+详细介绍
+--------------------------------------------------------------------------------
+### 3. jstat
+功能
+显示进程中的类装载、内存、垃圾收集、JIT编译等运行数据。
+常用指令
+jstat -gc 3331 250 20 ：查询进程2764的垃圾收集情况，每250毫秒查询一次，一共查询20次。
+jstat -gccause：额外输出上次GC原因
+jstat -calss：件事类装载、类卸载、总空间以及所消耗的时间
+详细介绍
+--------------------------------------------------------------------------------
+### 4. jmap
+功能
+生成堆转储快照（heapdump）
+常用指令
+jmap -heap 3331：查看java 堆（heap）使用情况
+jmap -histo 3331：查看堆内存(histogram)中的对象数量及大小
+jmap -histo:live 3331：JVM会先触发gc，然后再统计信息
+jmap -dump:format=b,file=heapDump 3331：将内存使用的详细情况输出到文件，之后一般使用其他工具进行分析。
+详细介绍
+--------------------------------------------------------------------------------
+
+### 5. jhat
+功能
+一般与jmap搭配使用，用来分析jmap生成的堆转储文件。
+由于有很多可视化工具（Eclipse Memory Analyzer 、IBM HeapAnalyzer）可以替代，所以很少用。不过在没有可视化工具的机器上也是可用的。
+常用指令
+jmap -dump:format=b,file=heapDump 3331 + jhat heapDump：解析Java堆转储文件,并启动一个 web server
+详细介绍
+--------------------------------------------------------------------------------
+### 6. jinfo
+功能
+实时查看和调整虚拟机参数，可以显示未被显示指定的参数的默认值（jps -v 则不能）。
+`jdk8中已经不支持该命令。`
+常用指令
+jinfo -flag CMSIniniatingOccupancyFration 1444：查询CMSIniniatingOccupancyFration参数值
+详细介绍
+--------------------------------------------------------------------------------
+
+常见问题定位过程
+### 频繁GC问题或内存溢出问题
+一、使用jps查看线程ID
+二、使用jstat -gc 3331 250 20 查看gc情况，一般比较关注PERM区的情况，查看GC的增长情况。
+三、使用jstat -gccause：额外输出上次GC原因
+四、使用jmap -dump:format=b,file=heapDump 3331生成堆转储文件
+五、使用jhat或者可视化工具（Eclipse Memory Analyzer 、IBM HeapAnalyzer）分析堆情况。
+六、结合代码解决内存溢出或泄露问题。
+--------------------------------------------------------------------------------
+### 死锁问题
+一、使用jps查看线程ID
+二、使用jstack 3331：查看线程情况
+结语
+经常使用适当的虚拟机监控和分析工具可以加快我们分析数据、定位解决问题的速度，但也要知道，工具永远都是知识技能的一层包装，没有什么工具是包治百病的。
diff --git "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/readme.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/readme.md"
similarity index 97%
rename from "01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/readme.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/readme.md"
index 0247c145..5a52972c 100644
--- "a/01 - JavaSE/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/readme.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/JVM\345\270\270\350\247\201\345\221\275\344\273\244/readme.md"	
@@ -1,33 +1,33 @@
-### 一、常用命令：
-  在JDK的bin目彔下,包含了java命令及其他实用工具。
-  `jps`:查看 **本机的Java中进程信息**。
-  `jstack`:打印 **线程的栈信息**,制作线程Dump。
-  `jmap`:打印 **内存映射,制作堆Dump**。
-  `jstat`:**性能监控工具**。
-  `jhat`:**内存分析工具**。
-
-  `jconsole`:简易的可视化控制台。
-  `jvisualvm`:功能强大的控制台。
-
-### 二、认识Java Dump：
-  **什么是Java Dump？**
-  Java虚拟机的运行时快照。将Java虚拟机运行时的状态和信息保存到文件。
-  线程Dump,包含所有线程的运行状态。纯文本格式。
-  堆Dump,包含线程Dump,幵包含所有堆对象的状态。二进制格式。
-  **Java Dump有什么用？**
-  补足传统Bug分析手段的不足: 可在任何Java环境使用;信息量充足。 针对非功能正确性的Bug,主要为:多线程幵发、内存泄漏。
-  制作Java Dump
-  使用Java虚拟机制作Dump
-  指示虚拟机在发生内存不足错误时,自动生成堆Dump
-  -XX:+HeapDumpOnOutOfMemoryError
-  使用图形化工具制作Dump
-  使用JDK(1.6)自带的工具:Java VisualVM。
-  使用命令行制作Dump
-  `jstack`:打印线程的栈信息,制作线程Dump。
-  `jmap`:打印内存映射,制作堆Dump。
-
-  步骤：
-  1. 检查虚拟机版本（java -version）
-  2. 找出目标Java应用的进程ID（jps）
-  3. 使用jstack命令制作线程Dump • Linux环境下使用kill命令制作线程Dump
-  4. 使用jmap命令制作堆Dump
+### 一、常用命令：
+  在JDK的bin目彔下,包含了java命令及其他实用工具。
+  `jps`:查看 **本机的Java中进程信息**。
+  `jstack`:打印 **线程的栈信息**,制作线程Dump。
+  `jmap`:打印 **内存映射,制作堆Dump**。
+  `jstat`:**性能监控工具**。
+  `jhat`:**内存分析工具**。
+
+  `jconsole`:简易的可视化控制台。
+  `jvisualvm`:功能强大的控制台。
+
+### 二、认识Java Dump：
+  **什么是Java Dump？**
+  Java虚拟机的运行时快照。将Java虚拟机运行时的状态和信息保存到文件。
+  线程Dump,包含所有线程的运行状态。纯文本格式。
+  堆Dump,包含线程Dump,幵包含所有堆对象的状态。二进制格式。
+  **Java Dump有什么用？**
+  补足传统Bug分析手段的不足: 可在任何Java环境使用;信息量充足。 针对非功能正确性的Bug,主要为:多线程幵发、内存泄漏。
+  制作Java Dump
+  使用Java虚拟机制作Dump
+  指示虚拟机在发生内存不足错误时,自动生成堆Dump
+  -XX:+HeapDumpOnOutOfMemoryError
+  使用图形化工具制作Dump
+  使用JDK(1.6)自带的工具:Java VisualVM。
+  使用命令行制作Dump
+  `jstack`:打印线程的栈信息,制作线程Dump。
+  `jmap`:打印内存映射,制作堆Dump。
+
+  步骤：
+  1. 检查虚拟机版本（java -version）
+  2. 找出目标Java应用的进程ID（jps）
+  3. 使用jstack命令制作线程Dump • Linux环境下使用kill命令制作线程Dump
+  4. 使用jmap命令制作堆Dump
diff --git "a/01 - JavaSE/01 - JVM/Java\345\206\205\345\255\230\345\214\272\345\237\237\344\270\216\345\206\205\345\255\230\346\272\242\345\207\272.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/Java\345\206\205\345\255\230\345\214\272\345\237\237\344\270\216\345\206\205\345\255\230\346\272\242\345\207\272.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/Java\345\206\205\345\255\230\345\214\272\345\237\237\344\270\216\345\206\205\345\255\230\346\272\242\345\207\272.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/Java\345\206\205\345\255\230\345\214\272\345\237\237\344\270\216\345\206\205\345\255\230\346\272\242\345\207\272.md"
diff --git "a/01 - JavaSE/01 - JVM/Java\350\231\232\346\213\237\346\234\272.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/Java\350\231\232\346\213\237\346\234\272.md"
similarity index 98%
rename from "01 - JavaSE/01 - JVM/Java\350\231\232\346\213\237\346\234\272.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/Java\350\231\232\346\213\237\346\234\272.md"
index 0495efec..d9d555fe 100644
--- "a/01 - JavaSE/01 - JVM/Java\350\231\232\346\213\237\346\234\272.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/Java\350\231\232\346\213\237\346\234\272.md"	
@@ -1,824 +1,824 @@
-<!-- GFM-TOC -->
-* [一、运行时数据区域](#一运行时数据区域)
-    * [程序计数器](#程序计数器)
-    * [虚拟机栈](#虚拟机栈)
-    * [本地方法栈](#本地方法栈)
-    * [堆](#堆)
-    * [方法区](#方法区)
-    * [运行时常量池](#运行时常量池)
-    * [直接内存](#直接内存)
-* [二、垃圾收集](#二垃圾收集)
-    * [判断一个对象是否可回收](#判断一个对象是否可回收)
-    * [垃圾收集算法](#垃圾收集算法)
-    * [垃圾收集器](#垃圾收集器)
-    * [内存分配与回收策略](#内存分配与回收策略)
-* [三、类加载机制](#三类加载机制)
-    * [类的生命周期](#类的生命周期)
-    * [类初始化时机](#类初始化时机)
-    * [类加载过程](#类加载过程)
-    * [类加载器](#类加载器)
-* [四、JVM 参数](#四jvm-参数)
-    * [GC 优化配置](#gc-优化配置)
-    * [GC 类型设置](#gc-类型设置)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、运行时数据区域
-
-<div align="center"> <img src="/image/01/jvm/540631a4-6018-40a5-aed7-081e2eeeaeea.png" width="500"/> </div><br>
-
-## 程序计数器
-
-记录正在执行的虚拟机字节码指令的地址（如果正在执行的是本地方法则为空）。
-
-## 虚拟机栈
-
-每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
-
-<div align="center"> <img src="/image/01/jvm/f5757d09-88e7-4bbd-8cfb-cecf55604854.png" width=""/> </div><br>
-
-可以通过 -Xss 这个虚拟机参数来指定一个程序的 Java 虚拟机栈内存大小：
-
-```java
-java -Xss=512M HackTheJava
-```
-
-该区域可能抛出以下异常：
-
-- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
-- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
-
-## 本地方法栈
-
-本地方法不是用 Java 实现，对待这些方法需要特别处理。
-
-与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
-
-<div align="center"> <img src="/image/01/jvm/JNIFigure1.png" width="350"/> </div><br>
-
-## 堆
-
-所有对象实例都在这里分配内存。
-
-是垃圾收集的主要区域（"GC 堆"），现代的垃圾收集器基本都是采用分代收集算法，该算法的思想是针对不同的对象采取不同的垃圾回收算法，因此虚拟机把 Java 堆分成以下三块：
-
-- 新生代（Young Generation）
-- 老年代（Old Generation）
-- 永久代（Permanent Generation）
-
-当一个对象被创建时，它首先进入新生代，之后有可能被转移到老年代中。新生代存放着大量的生命很短的对象，因此新生代在三个区域中垃圾回收的频率最高。为了更高效地进行垃圾回收，把新生代继续划分成以下三个空间：
-
-- Eden
-- From Survivor
-- To Survivor
-
-<div align="center"> <img src="/image/01/jvm/ppt_img.png" width=""/> </div><br>
-
-Java 堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
-
-可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的 Java 堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
-
-```java
-java -Xms=1M -Xmx=2M HackTheJava
-```
-
-## 方法区
-
-用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
-
-和 Java 堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
-
-对这块区域进行垃圾回收的主要目标是对常量池的回收和对类的卸载，但是一般比较难实现。
-
-JDK 1.7 之前，HotSpot 虚拟机把它当成永久代来进行垃圾回收，JDK 1.8 之后，取消了永久代，用 metaspace（元数据）区替代。
-
-## 运行时常量池
-
-运行时常量池是方法区的一部分。
-
-Class 文件中的常量池（编译器生成的各种字面量和符号引用）会在类加载后被放入这个区域。
-
-除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。这部分常量也会被放入运行时常量池。
-
-## 直接内存
-
-在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过一个存储在 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在 Java 堆和 Native 堆中来回复制数据。
-
-# 二、垃圾收集
-
-程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后也会消失，因此不需要对这三个区域进行垃圾回收。垃圾回收主要是针对 Java 堆和方法区进行。
-
-## 判断一个对象是否可回收
-
-### 1. 引用计数算法
-
-给对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
-
-两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。
-
-```java
-public class ReferenceCountingGC {
-    public Object instance = null;
-
-    public static void main(String[] args) {
-        ReferenceCountingGC objectA = new ReferenceCountingGC();
-        ReferenceCountingGC objectB = new ReferenceCountingGC();
-        objectA.instance = objectB;
-        objectB.instance = objectA;
-    }
-}
-```
-
-正因为循环引用的存在，因此 Java 虚拟机不适用引用计数算法。
-
-### 2. 可达性分析算法
-
-通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
-
-<div align="center"> <img src="/image/01/jvm/0635cbe8.png" width=""/> </div><br>
-
-Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
-
-- 虚拟机栈中引用的对象
-- 本地方法栈中引用的对象
-- 方法区中类静态属性引用的对象
-- 方法区中的常量引用的对象
-
-### 3. 引用类型
-
-无论是通过引用计算算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达，判定对象是否可被回收都与引用有关。
-
-Java 具有四种强度不同的引用类型。
-
-**（一）强引用**
-
-被强引用关联的对象不会被垃圾收集器回收。
-
-使用 new 一个新对象的方式来创建强引用。
-
-```java
-Object obj = new Object();
-```
-
-**（二）软引用**
-
-被软引用关联的对象，只有在内存不够的情况下才会被回收。
-
-使用 SoftReference 类来创建软引用。
-
-```java
-Object obj = new Object();
-SoftReference<Object> sf = new SoftReference<Object>(obj);
-obj = null; // 使对象只被软引用关联
-```
-
-**（三）弱引用**
-
-被弱引用关联的对象一定会被垃圾收集器回收，也就是说它只能存活到下一次垃圾收集发生之前。
-
-使用 WeakReference 类来实现弱引用。
-
-```java
-Object obj = new Object();
-WeakReference<Object> wf = new WeakReference<Object>(obj);
-obj = null;
-```
-
-WeakHashMap 的 Entry 继承自 WeakReference，主要用来实现缓存。
-
-```java
-private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
-```
-
-Tomcat 中的 ConcurrentCache 就使用了 WeakHashMap 来实现缓存功能。ConcurrentCache 采取的是分代缓存，经常使用的对象放入 eden 中，而不常用的对象放入 longterm。eden 使用 ConcurrentHashMap 实现，longterm 使用 WeakHashMap，保证了不常使用的对象容易被回收。
-
-```java
-public final class ConcurrentCache<K, V> {
-
-    private final int size;
-
-    private final Map<K, V> eden;
-
-    private final Map<K, V> longterm;
-
-    public ConcurrentCache(int size) {
-        this.size = size;
-        this.eden = new ConcurrentHashMap<>(size);
-        this.longterm = new WeakHashMap<>(size);
-    }
-
-    public V get(K k) {
-        V v = this.eden.get(k);
-        if (v == null) {
-            v = this.longterm.get(k);
-            if (v != null)
-                this.eden.put(k, v);
-        }
-        return v;
-    }
-
-    public void put(K k, V v) {
-        if (this.eden.size() >= size) {
-            this.longterm.putAll(this.eden);
-            this.eden.clear();
-        }
-        this.eden.put(k, v);
-    }
-}
-```
-
-**（四）虚引用**
-
-又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象实例。
-
-为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
-
-使用 PhantomReference 来实现虚引用。
-
-```java
-Object obj = new Object();
-PhantomReference<Object> pf = new PhantomReference<Object>(obj);
-obj = null;
-```
-
-### 4. 方法区的回收
-
-因为方法区主要存放永久代对象，而永久代对象的回收率比新生代差很多，因此在方法区上进行回收性价比不高。
-
-主要是对常量池的回收和对类的卸载。
-
-类的卸载条件很多，需要满足以下三个条件，并且满足了也不一定会被卸载：
-
-- 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
-- 加载该类的 ClassLoader 已经被回收。
-- 该类对应的 java.lang.Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
-
-可以通过 -Xnoclassgc 参数来控制是否对类进行卸载。
-
-在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGi 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载功能，以保证不会出现内存溢出。
-
-### 5. finalize()
-
-finalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好，并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
-
-当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能通过在该方法中让对象重新被引用，从而实现自救。
-
-## 垃圾收集算法
-
-### 1. 标记 - 清除
-
-<div align="center"> <img src="/image/01/jvm/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/> </div><br>
-
-将需要回收的对象进行标记，然后清理掉被标记的对象。
-
-不足：
-
-- 标记和清除过程效率都不高；
-- 会产生大量不连续的内存碎片，导致无法给大对象分配内存。
-
-### 2. 标记 - 整理
-
-<div align="center"> <img src="/image/01/jvm/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/> </div><br>
-
-让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
-
-### 3. 复制
-
-<div align="center"> <img src="/image/01/jvm/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/> </div><br>
-
-将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
-
-主要不足是只使用了内存的一半。
-
-现在的商业虚拟机都采用这种收集算法来回收新生代，但是并不是将内存划分为大小相等的两块，而是分为一块较大的 Eden 空间和两块较小的 Survior 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象一次性复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90 %。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行分配担保，也就是借用老年代的空间存储放不下的对象。
-
-### 4. 分代收集
-
-现在的商业虚拟机采用分代收集算法，它根据对象存活周期将内存划分为几块，不同块采用适当的收集算法。
-
-一般将 Java 堆分为新生代和老年代。
-
-- 新生代使用：复制算法
-- 老年代使用：标记 - 清理 或者 标记 - 整理 算法
-
-## 垃圾收集器
-
-<div align="center"> <img src="/image/01/jvm/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/> </div><br>
-
-以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
-
-### 1. Serial 收集器
-
-<div align="center"> <img src="/image/01/jvm/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/> </div><br>
-
-Serial 翻译为串行，可以理解为垃圾收集和用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序。除了 CMS 和 G1 之外，其它收集器都是以串行的方式执行。CMS 和 G1 可以使得垃圾收集和用户程序同时执行，被称为并发执行。
-
-它是单线程的收集器，只会使用一个线程进行垃圾收集工作。
-
-它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
-
-它是 Client 模式下的默认新生代收集器，因为在用户的桌面应用场景下，分配给虚拟机管理的内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
-
-### 2. ParNew 收集器
-
-<div align="center"> <img src="/image/01/jvm/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/> </div><br>
-
-它是 Serial 收集器的多线程版本。
-
-是 Server 模式下的虚拟机首选新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
-
-默认开始的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
-
-### 3. Parallel Scavenge 收集器
-
-与 ParNew 一样是并行的多线程收集器。
-
-其它收集器关注点是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户代码的时间占总时间的比值。
-
-停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。
-
-提供了两个参数用于精确控制吞吐量，分别是控制最大垃圾收集停顿时间 -XX:MaxGCPauseMillis 参数以及直接设置吞吐量大小的 -XX:GCTimeRatio 参数（值为大于 0 且小于 100 的整数）。缩短停顿时间是以牺牲吞吐量和新生代空间来换取的：新生代空间变小，垃圾回收变得频繁，导致吞吐量下降。
-
-还提供了一个参数 -XX:+UseAdaptiveSizePolicy，这是一个开关参数，打开参数后，就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例（-XX:SurvivorRatio）、晋升老年代对象年龄（-XX:PretenureSizeThreshold）等细节参数了，虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量，这种方式称为 GC 自适应的调节策略（GC Ergonomics）。
-
-### 4. Serial Old 收集器
-
-<div align="center"> <img src="/image/01/jvm/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/> </div><br>
-
-是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用。如果用在 Server 模式下，它有两大用途：
-
-- 在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
-- 作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。
-
-### 5. Parallel Old 收集器
-
-<div align="center"> <img src="/image/01/jvm/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/> </div><br>
-
-是 Parallel Scavenge 收集器的老年代版本。
-
-在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。
-
-### 6. CMS 收集器
-
-<div align="center"> <img src="/image/01/jvm/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/> </div><br>
-
-CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
-
-特点：并发收集、低停顿。并发指的是用户线程和 GC 线程同时运行。
-
-分为以下四个流程：
-
-- 初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
-- 并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
-- 重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
-- 并发清除：不需要停顿。
-
-在整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，不需要进行停顿。
-
-具有以下缺点：
-
-- 吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 CPU 利用率不够高。
-- 无法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。可以使用 -XX:CMSInitiatingOccupancyFraction 来改变触发 CMS 收集器工作的内存占用百分，如果这个值设置的太大，导致预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
-- 标记 - 清除算法导致的空间碎片，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。
-
-### 7. G1 收集器
-
-G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。
-
-Java 堆被分为新生代、老年代和永久代，其它收集器进行收集的范围都是整个新生代或者老生代，而 G1 可以直接对新生代和永久代一起回收。
-
-<div align="center"> <img src="/image/01/jvm/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/> </div><br>
-
-G1 把新生代和老年代划分成多个大小相等的独立区域（Region），新生代和永久代不再物理隔离。
-
-<div align="center"> <img src="/image/01/jvm/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/> </div><br>
-
-通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 记录垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
-
-每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
-
-<div align="center"> <img src="/image/01/jvm/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/> </div><br>
-
-如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
-
-- 初始标记
-- 并发标记
-- 最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
-- 筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿是时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。
-
-具备如下特点：
-
-- 空间整合：整体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
-- 可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。
-
-更详细内容请参考：[Getting Started with the G1 Garbage Collector](http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html)
-
-### 8. 比较
-
-| 收集器 | 串行/并行/并发 | 新生代/老年代 | 收集算法 | 目标 | 适用场景 |
-| :---: | :---: | :---: | :---: | :---: | :---: |
-|  **Serial**  | 串行 | 新生代 | 复制 | 响应速度优先 | 单 CPU 环境下的 Client 模式 |
-|  **Serial Old**  | 串行 | 老年代 | 标记-整理 | 响应速度优先 | 单 CPU 环境下的 Client 模式、CMS 的后备预案 |
-|  **ParNew**  | 串行 + 并行 | 新生代 | 复制算法 | 响应速度优先 | 多 CPU 环境时在 Server 模式下与 CMS 配合 |
-|  **Parallel Scavenge**  | 串行 + 并行 | 新生代 | 复制算法 | 吞吐量优先 | 在后台运算而不需要太多交互的任务 |
-|  **Parallel Old**  | 串行 + 并行 | 老年代 | 标记-整理 | 吞吐量优先 | 在后台运算而不需要太多交互的任务 |
-|  **CMS**  | 并行 + 并发 | 老年代 | 标记-清除 | 响应速度优先 | 集中在互联网站或 B/S 系统服务端上的 Java 应用 |
-|  **G1**  | 并行 + 并发 | 新生代 + 老年代 | 标记-整理 + 复制算法 | 响应速度优先 | 面向服务端应用，将来替换 CMS |
-
-## 内存分配与回收策略
-
-对象的内存分配，也就是在堆上分配。主要分配在新生代的 Eden 区上，少数情况下也可能直接分配在老年代中。
-
-### 1. Minor GC 和 Full GC
-
-- Minor GC：发生在新生代上，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
-- Full GC：发生在老年代上，老年代对象和新生代的相反，其存活时间长，因此 Full GC 很少执行，而且执行速度会比 Minor GC 慢很多。
-
-### 2. 内存分配策略
-
-**（一）对象优先在 Eden 分配**
-
-大多数情况下，对象在新生代 Eden 区分配，当 Eden 区空间不够时，发起 Minor GC。
-
-**（二）大对象直接进入老年代**
-
-大对象是指需要连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组。
-
-经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配给大对象。
-
--XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制。
-
-**（三）长期存活的对象进入老年代**
-
-为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。
-
--XX:MaxTenuringThreshold 用来定义年龄的阈值。
-
-**（四）动态对象年龄判定**
-
-虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 区中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
-
-**（五）空间分配担保**
-
-在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的；如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC，尽管这次 Minor GC 是有风险的；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那这时也要改为进行一次 Full GC。
-
-### 3. Full GC 的触发条件
-
-对于 Minor GC，其触发条件非常简单，当 Eden 区空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
-
-**（一）调用 System.gc()**
-
-此方法的调用是建议虚拟机进行 Full GC，虽然只是建议而非一定，但很多情况下它会触发 Full GC，从而增加 Full GC 的频率，也即增加了间歇性停顿的次数。因此强烈建议能不使用此方法就不要使用，让虚拟机自己去管理它的内存。可通过 -XX:DisableExplicitGC 来禁止 RMI 调用 System.gc()。
-
-**（二）老年代空间不足**
-
-老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等，当执行 Full GC 后空间仍然不足，则抛出 Java.lang.OutOfMemoryError。为避免以上原因引起的 Full GC，调优时应尽量做到让对象在 Minor GC 阶段被回收、让对象在新生代多存活一段时间以及不要创建过大的对象及数组。
-
-**（三）空间分配担保失败**
-
-使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果出现了 HandlePromotionFailure 担保失败，则会触发 Full GC。
-
-**（四）JDK 1.7 及以前的永久代空间不足**
-
-在 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 时当前的浮动垃圾过多导致暂时性的空间不足触发 Full GC），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
-
-# 三、类加载机制
-
-类是在运行期间动态加载的。
-
-## 类的生命周期
-
-<div align="center"> <img src="/image/01/jvm/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/> </div><br>
-
-包括以下 7 个阶段：
-
--  **加载（Loading）**
--  **验证（Verification）**
--  **准备（Preparation）**
--  **解析（Resolution）**
--  **初始化（Initialization）**
-- 使用（Using）
-- 卸载（Unloading）
-
-其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
-
-## 类初始化时机
-
-虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随着发生）：
-
-- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
-
-- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
-
-- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
-
-- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
-
-- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
-
-以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
-
-- 通过子类引用父类的静态字段，不会导致子类初始化。
-
-```java
-System.out.println(SubClass.value); // value 字段在 SuperClass 中定义
-```
-
-- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
-
-```java
-SuperClass[] sca = new SuperClass[10];
-```
-
-- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
-
-```java
-System.out.println(ConstClass.HELLOWORLD);
-```
-
-## 类加载过程
-
-包含了加载、验证、准备、解析和初始化这 5 个阶段。
-
-### 1. 加载
-
-加载是类加载的一个阶段，注意不要混淆。
-
-加载过程完成以下三件事：
-
-- 通过一个类的全限定名来获取定义此类的二进制字节流。
-- 将这个字节流所代表的静态存储结构转化为方法区的运行时存储结构。
-- 在内存中生成一个代表这个类的 Class 对象，作为方法区这个类的各种数据的访问入口。
-
-其中二进制字节流可以从以下方式中获取：
-
-- 从 ZIP 包读取，这很常见，最终成为日后 JAR、EAR、WAR 格式的基础。
-- 从网络中获取，这种场景最典型的应用是 Applet。
-- 运行时计算生成，这种场景使用得最多得就是动态代理技术，在 java.lang.reflect.Proxy 中，就是用了 ProxyGenerator.generateProxyClass 的代理类的二进制字节流。
-- 由其他文件生成，典型场景是 JSP 应用，即由 JSP 文件生成对应的 Class 类。
-- 从数据库读取，这种场景相对少见，例如有些中间件服务器（如 SAP Netweaver）可以选择把程序安装到数据库中来完成程序代码在集群间的分发。
-...
-
-### 2. 验证
-
-确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
-
-- 文件格式验证：验证字节流是否符合 Class 文件格式的规范，并且能被当前版本的虚拟机处理。
-- 元数据验证：对字节码描述的信息进行语义分析，以保证其描述的信息符合 Java 语言规范的要求。
-- 字节码验证：通过数据流和控制流分析，确保程序语义是合法、符合逻辑的。
-- 符号引用验证：发生在虚拟机将符号引用转换为直接引用的时候，对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验。
-
-### 3. 准备
-
-类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存。
-
-实例变量不会在这阶段分配内存，它将会在对象实例化时随着对象一起分配在 Java 堆中。（实例化不是类加载的一个过程，类加载发生在所有实例化操作之前，并且类加载只进行一次，实例化可以进行多次）
-
-初始值一般为 0 值，例如下面的类变量 value 被初始化为 0 而不是 123。
-
-```java
-public static int value = 123;
-```
-
-如果类变量是常量，那么会按照表达式来进行初始化，而不是赋值为 0。
-
-```java
-public static final int value = 123;
-```
-
-### 4. 解析
-
-将常量池的符号引用替换为直接引用的过程。
-
-### 5. 初始化
-
-初始化阶段才真正开始执行类中的定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 &lt;clinit>() 方法的过程。
-
-在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
-
-&lt;clinit>() 方法具有以下特点：
-
-- 是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static{} 块）中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
-
-```java
-public class Test {
-    static {
-        i = 0;                // 给变量赋值可以正常编译通过
-        System.out.print(i);  // 这句编译器会提示“非法向前引用”
-    }
-    static int i = 1;
-}
-```
-
-- 与类的构造函数（或者说实例构造器 &lt;init>()）不同，不需要显式的调用父类的构造器。虚拟机会自动保证在子类的 &lt;clinit>() 方法运行之前，父类的 &lt;clinit>() 方法已经执行结束。因此虚拟机中第一个执行 &lt;clinit>() 方法的类肯定为 java.lang.Object。
-
-- 由于父类的 &lt;clinit>() 方法先执行，也就意味着父类中定义的静态语句块要优于子类的变量赋值操作。例如以下代码：
-
-```java
-static class Parent {
-    public static int A = 1;
-    static {
-        A = 2;
-    }
-}
-
-static class Sub extends Parent {
-    public static int B = A;
-}
-
-public static void main(String[] args) {
-     System.out.println(Sub.B);  // 输出结果是父类中的静态变量 A 的值，也就是 2。
-}
-```
-
-- &lt;clinit>() 方法对于类或接口不是必须的，如果一个类中不包含静态语句块，也没有对类变量的赋值操作，编译器可以不为该类生成 &lt;clinit>() 方法。
-
-- 接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 &lt;clinit>() 方法。但接口与类不同的是，执行接口的 &lt;clinit>() 方法不需要先执行父接口的 &lt;clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 &lt;clinit>() 方法。
-
-- 虚拟机会保证一个类的 &lt;clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 &lt;clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 &lt;clinit>() 方法完毕。如果在一个类的 &lt;clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
-
-## 类加载器
-
-实现类的加载动作。在 Java 虚拟机外部实现，以便让应用程序自己决定如何去获取所需要的类。
-
-### 1. 类与类加载器
-
-两个类相等：类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
-
-这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
-
-### 2. 类加载器分类
-
-从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
-
-- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
-
-- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
-
-从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
-
-- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 &lt;JAVA_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
-
-- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 &lt;JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
-
-- 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
-
-### 3. 双亲委派模型
-
-应用程序都是由三种类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的类加载器。
-
-下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
-
-<div align="center"> <img src="/image/01/jvm/class_loader_hierarchy.png" width="600"/> </div><br>
-
-**（一）工作过程**
-
-一个类加载器首先将类加载请求传送到父类加载器，只有当父类加载器无法完成类加载请求时才尝试加载。
-
-**（二）好处**
-
-使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而是的基础类得到统一。
-
-例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。因为双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。正因为 rt.jar 中的 Object 优先级更高，因为程序中所有的 Object 都是这个 Object。
-
-**（三）实现**
-
-以下是抽象类 java.lang.ClassLoader 的代码片段，其中的 loadClass() 方法运行过程如下：先检查类是否已经加载过，如果没有则让父类加载器去加载。当父类加载器加载失败时抛出 ClassNotFoundException，此时尝试自己去加载。
-
-```java
-public abstract class ClassLoader {
-    // The parent class loader for delegation
-    private final ClassLoader parent;
-
-    public Class<?> loadClass(String name) throws ClassNotFoundException {
-        return loadClass(name, false);
-    }
-
-    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-        synchronized (getClassLoadingLock(name)) {
-            // First, check if the class has already been loaded
-            Class<?> c = findLoadedClass(name);
-            if (c == null) {
-                try {
-                    if (parent != null) {
-                        c = parent.loadClass(name, false);
-                    } else {
-                        c = findBootstrapClassOrNull(name);
-                    }
-                } catch (ClassNotFoundException e) {
-                    // ClassNotFoundException thrown if class not found
-                    // from the non-null parent class loader
-                }
-
-                if (c == null) {
-                    // If still not found, then invoke findClass in order
-                    // to find the class.
-                    c = findClass(name);
-                }
-            }
-            if (resolve) {
-                resolveClass(c);
-            }
-            return c;
-        }
-    }
-
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        throw new ClassNotFoundException(name);
-    }
-}
-```
-
-### 4. 自定义类加载器实现
-
-FileSystemClassLoader 是自定义类加载器，继承自 java.lang.ClassLoader，用于加载文件系统上的类。它首先根据类的全名在文件系统上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。
-
-java.lang.ClassLoader 类的方法 loadClass() 实现了双亲委派模型的逻辑，因此自定义类加载器一般不去重写它，而是通过重写 findClass() 方法。
-
-```java
-public class FileSystemClassLoader extends ClassLoader {
-
-    private String rootDir;
-
-    public FileSystemClassLoader(String rootDir) {
-        this.rootDir = rootDir;
-    }
-
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        byte[] classData = getClassData(name);
-        if (classData == null) {
-            throw new ClassNotFoundException();
-        } else {
-            return defineClass(name, classData, 0, classData.length);
-        }
-    }
-
-    private byte[] getClassData(String className) {
-        String path = classNameToPath(className);
-        try {
-            InputStream ins = new FileInputStream(path);
-            ByteArrayOutputStream baos = new ByteArrayOutputStream();
-            int bufferSize = 4096;
-            byte[] buffer = new byte[bufferSize];
-            int bytesNumRead;
-            while ((bytesNumRead = ins.read(buffer)) != -1) {
-                baos.write(buffer, 0, bytesNumRead);
-            }
-            return baos.toByteArray();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    private String classNameToPath(String className) {
-        return rootDir + File.separatorChar
-                + className.replace('.', File.separatorChar) + ".class";
-    }
-}
-```
-
-# 四、JVM 参数
-
-## GC 优化配置
-
-| 配置 | 描述 |
-| --- | --- |
-| -Xms | 初始化堆内存大小 |
-| -Xmx | 堆内存最大值 |
-| -Xmn | 新生代大小 |
-| -XX:PermSize | 初始化永久代大小 |
-| -XX:MaxPermSize | 永久代最大容量 |
-
-## GC 类型设置
-
-| 配置 | 描述 |
-| --- | --- |
-| -XX:+UseSerialGC | 串行垃圾回收器 |
-| -XX:+UseParallelGC | 并行垃圾回收器 |
-| -XX:+UseConcMarkSweepGC | 并发标记扫描垃圾回收器 |
-| -XX:ParallelCMSThreads= | 并发标记扫描垃圾回收器 = 为使用的线程数量 |
-| -XX:+UseG1GC | G1 垃圾回收器 |
-
-```java
-java -Xmx12m -Xms3m -Xmn1m -XX:PermSize=20m -XX:MaxPermSize=20m -XX:+UseSerialGC -jar java-application.jar
-```
-
-# 参考资料
-
-- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
-- [Jvm memory](https://www.slideshare.net/benewu/jvm-memory)
-- [Memory Architecture Of JVM(Runtime Data Areas)](https://hackthejava.wordpress.com/2015/01/09/memory-architecture-by-jvmruntime-data-areas/)
-- [JVM Run-Time Data Areas](https://www.programcreek.com/2013/04/jvm-run-time-data-areas/)
-- [Android on x86: Java Native Interface and the Android Native Development Kit](http://www.drdobbs.com/architecture-and-design/android-on-x86-java-native-interface-and/240166271)
-- [深入理解 JVM(2)——GC 算法与内存分配策略](https://crowhawk.github.io/2017/08/10/jvm_2/)
-- [深入理解 JVM(3)——7 种垃圾收集器](https://crowhawk.github.io/2017/08/15/jvm_3/)
-- [JVM Internals](http://blog.jamesdbloom.com/JVMInternals.html)
-- [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
-- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
-- [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
+<!-- GFM-TOC -->
+* [一、运行时数据区域](#一运行时数据区域)
+    * [程序计数器](#程序计数器)
+    * [虚拟机栈](#虚拟机栈)
+    * [本地方法栈](#本地方法栈)
+    * [堆](#堆)
+    * [方法区](#方法区)
+    * [运行时常量池](#运行时常量池)
+    * [直接内存](#直接内存)
+* [二、垃圾收集](#二垃圾收集)
+    * [判断一个对象是否可回收](#判断一个对象是否可回收)
+    * [垃圾收集算法](#垃圾收集算法)
+    * [垃圾收集器](#垃圾收集器)
+    * [内存分配与回收策略](#内存分配与回收策略)
+* [三、类加载机制](#三类加载机制)
+    * [类的生命周期](#类的生命周期)
+    * [类初始化时机](#类初始化时机)
+    * [类加载过程](#类加载过程)
+    * [类加载器](#类加载器)
+* [四、JVM 参数](#四jvm-参数)
+    * [GC 优化配置](#gc-优化配置)
+    * [GC 类型设置](#gc-类型设置)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、运行时数据区域
+
+<div align="center"> <img src="/image/01/jvm/540631a4-6018-40a5-aed7-081e2eeeaeea.png" width="500"/> </div><br>
+
+## 程序计数器
+
+记录正在执行的虚拟机字节码指令的地址（如果正在执行的是本地方法则为空）。
+
+## 虚拟机栈
+
+每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
+
+<div align="center"> <img src="/image/01/jvm/f5757d09-88e7-4bbd-8cfb-cecf55604854.png" width=""/> </div><br>
+
+可以通过 -Xss 这个虚拟机参数来指定一个程序的 Java 虚拟机栈内存大小：
+
+```java
+java -Xss=512M HackTheJava
+```
+
+该区域可能抛出以下异常：
+
+- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
+- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
+
+## 本地方法栈
+
+本地方法不是用 Java 实现，对待这些方法需要特别处理。
+
+与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
+
+<div align="center"> <img src="/image/01/jvm/JNIFigure1.png" width="350"/> </div><br>
+
+## 堆
+
+所有对象实例都在这里分配内存。
+
+是垃圾收集的主要区域（"GC 堆"），现代的垃圾收集器基本都是采用分代收集算法，该算法的思想是针对不同的对象采取不同的垃圾回收算法，因此虚拟机把 Java 堆分成以下三块：
+
+- 新生代（Young Generation）
+- 老年代（Old Generation）
+- 永久代（Permanent Generation）
+
+当一个对象被创建时，它首先进入新生代，之后有可能被转移到老年代中。新生代存放着大量的生命很短的对象，因此新生代在三个区域中垃圾回收的频率最高。为了更高效地进行垃圾回收，把新生代继续划分成以下三个空间：
+
+- Eden
+- From Survivor
+- To Survivor
+
+<div align="center"> <img src="/image/01/jvm/ppt_img.png" width=""/> </div><br>
+
+Java 堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
+
+可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的 Java 堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
+
+```java
+java -Xms=1M -Xmx=2M HackTheJava
+```
+
+## 方法区
+
+用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
+
+和 Java 堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
+
+对这块区域进行垃圾回收的主要目标是对常量池的回收和对类的卸载，但是一般比较难实现。
+
+JDK 1.7 之前，HotSpot 虚拟机把它当成永久代来进行垃圾回收，JDK 1.8 之后，取消了永久代，用 metaspace（元数据）区替代。
+
+## 运行时常量池
+
+运行时常量池是方法区的一部分。
+
+Class 文件中的常量池（编译器生成的各种字面量和符号引用）会在类加载后被放入这个区域。
+
+除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。这部分常量也会被放入运行时常量池。
+
+## 直接内存
+
+在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过一个存储在 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在 Java 堆和 Native 堆中来回复制数据。
+
+# 二、垃圾收集
+
+程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后也会消失，因此不需要对这三个区域进行垃圾回收。垃圾回收主要是针对 Java 堆和方法区进行。
+
+## 判断一个对象是否可回收
+
+### 1. 引用计数算法
+
+给对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
+
+两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。
+
+```java
+public class ReferenceCountingGC {
+    public Object instance = null;
+
+    public static void main(String[] args) {
+        ReferenceCountingGC objectA = new ReferenceCountingGC();
+        ReferenceCountingGC objectB = new ReferenceCountingGC();
+        objectA.instance = objectB;
+        objectB.instance = objectA;
+    }
+}
+```
+
+正因为循环引用的存在，因此 Java 虚拟机不适用引用计数算法。
+
+### 2. 可达性分析算法
+
+通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
+
+<div align="center"> <img src="/image/01/jvm/0635cbe8.png" width=""/> </div><br>
+
+Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
+
+- 虚拟机栈中引用的对象
+- 本地方法栈中引用的对象
+- 方法区中类静态属性引用的对象
+- 方法区中的常量引用的对象
+
+### 3. 引用类型
+
+无论是通过引用计算算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达，判定对象是否可被回收都与引用有关。
+
+Java 具有四种强度不同的引用类型。
+
+**（一）强引用**
+
+被强引用关联的对象不会被垃圾收集器回收。
+
+使用 new 一个新对象的方式来创建强引用。
+
+```java
+Object obj = new Object();
+```
+
+**（二）软引用**
+
+被软引用关联的对象，只有在内存不够的情况下才会被回收。
+
+使用 SoftReference 类来创建软引用。
+
+```java
+Object obj = new Object();
+SoftReference<Object> sf = new SoftReference<Object>(obj);
+obj = null; // 使对象只被软引用关联
+```
+
+**（三）弱引用**
+
+被弱引用关联的对象一定会被垃圾收集器回收，也就是说它只能存活到下一次垃圾收集发生之前。
+
+使用 WeakReference 类来实现弱引用。
+
+```java
+Object obj = new Object();
+WeakReference<Object> wf = new WeakReference<Object>(obj);
+obj = null;
+```
+
+WeakHashMap 的 Entry 继承自 WeakReference，主要用来实现缓存。
+
+```java
+private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
+```
+
+Tomcat 中的 ConcurrentCache 就使用了 WeakHashMap 来实现缓存功能。ConcurrentCache 采取的是分代缓存，经常使用的对象放入 eden 中，而不常用的对象放入 longterm。eden 使用 ConcurrentHashMap 实现，longterm 使用 WeakHashMap，保证了不常使用的对象容易被回收。
+
+```java
+public final class ConcurrentCache<K, V> {
+
+    private final int size;
+
+    private final Map<K, V> eden;
+
+    private final Map<K, V> longterm;
+
+    public ConcurrentCache(int size) {
+        this.size = size;
+        this.eden = new ConcurrentHashMap<>(size);
+        this.longterm = new WeakHashMap<>(size);
+    }
+
+    public V get(K k) {
+        V v = this.eden.get(k);
+        if (v == null) {
+            v = this.longterm.get(k);
+            if (v != null)
+                this.eden.put(k, v);
+        }
+        return v;
+    }
+
+    public void put(K k, V v) {
+        if (this.eden.size() >= size) {
+            this.longterm.putAll(this.eden);
+            this.eden.clear();
+        }
+        this.eden.put(k, v);
+    }
+}
+```
+
+**（四）虚引用**
+
+又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象实例。
+
+为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
+
+使用 PhantomReference 来实现虚引用。
+
+```java
+Object obj = new Object();
+PhantomReference<Object> pf = new PhantomReference<Object>(obj);
+obj = null;
+```
+
+### 4. 方法区的回收
+
+因为方法区主要存放永久代对象，而永久代对象的回收率比新生代差很多，因此在方法区上进行回收性价比不高。
+
+主要是对常量池的回收和对类的卸载。
+
+类的卸载条件很多，需要满足以下三个条件，并且满足了也不一定会被卸载：
+
+- 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
+- 加载该类的 ClassLoader 已经被回收。
+- 该类对应的 java.lang.Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
+
+可以通过 -Xnoclassgc 参数来控制是否对类进行卸载。
+
+在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGi 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载功能，以保证不会出现内存溢出。
+
+### 5. finalize()
+
+finalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好，并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
+
+当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能通过在该方法中让对象重新被引用，从而实现自救。
+
+## 垃圾收集算法
+
+### 1. 标记 - 清除
+
+<div align="center"> <img src="/image/01/jvm/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/> </div><br>
+
+将需要回收的对象进行标记，然后清理掉被标记的对象。
+
+不足：
+
+- 标记和清除过程效率都不高；
+- 会产生大量不连续的内存碎片，导致无法给大对象分配内存。
+
+### 2. 标记 - 整理
+
+<div align="center"> <img src="/image/01/jvm/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/> </div><br>
+
+让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
+
+### 3. 复制
+
+<div align="center"> <img src="/image/01/jvm/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/> </div><br>
+
+将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
+
+主要不足是只使用了内存的一半。
+
+现在的商业虚拟机都采用这种收集算法来回收新生代，但是并不是将内存划分为大小相等的两块，而是分为一块较大的 Eden 空间和两块较小的 Survior 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象一次性复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90 %。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行分配担保，也就是借用老年代的空间存储放不下的对象。
+
+### 4. 分代收集
+
+现在的商业虚拟机采用分代收集算法，它根据对象存活周期将内存划分为几块，不同块采用适当的收集算法。
+
+一般将 Java 堆分为新生代和老年代。
+
+- 新生代使用：复制算法
+- 老年代使用：标记 - 清理 或者 标记 - 整理 算法
+
+## 垃圾收集器
+
+<div align="center"> <img src="/image/01/jvm/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/> </div><br>
+
+以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
+
+### 1. Serial 收集器
+
+<div align="center"> <img src="/image/01/jvm/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/> </div><br>
+
+Serial 翻译为串行，可以理解为垃圾收集和用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序。除了 CMS 和 G1 之外，其它收集器都是以串行的方式执行。CMS 和 G1 可以使得垃圾收集和用户程序同时执行，被称为并发执行。
+
+它是单线程的收集器，只会使用一个线程进行垃圾收集工作。
+
+它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
+
+它是 Client 模式下的默认新生代收集器，因为在用户的桌面应用场景下，分配给虚拟机管理的内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
+
+### 2. ParNew 收集器
+
+<div align="center"> <img src="/image/01/jvm/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/> </div><br>
+
+它是 Serial 收集器的多线程版本。
+
+是 Server 模式下的虚拟机首选新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
+
+默认开始的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
+
+### 3. Parallel Scavenge 收集器
+
+与 ParNew 一样是并行的多线程收集器。
+
+其它收集器关注点是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户代码的时间占总时间的比值。
+
+停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。
+
+提供了两个参数用于精确控制吞吐量，分别是控制最大垃圾收集停顿时间 -XX:MaxGCPauseMillis 参数以及直接设置吞吐量大小的 -XX:GCTimeRatio 参数（值为大于 0 且小于 100 的整数）。缩短停顿时间是以牺牲吞吐量和新生代空间来换取的：新生代空间变小，垃圾回收变得频繁，导致吞吐量下降。
+
+还提供了一个参数 -XX:+UseAdaptiveSizePolicy，这是一个开关参数，打开参数后，就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例（-XX:SurvivorRatio）、晋升老年代对象年龄（-XX:PretenureSizeThreshold）等细节参数了，虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量，这种方式称为 GC 自适应的调节策略（GC Ergonomics）。
+
+### 4. Serial Old 收集器
+
+<div align="center"> <img src="/image/01/jvm/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/> </div><br>
+
+是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用。如果用在 Server 模式下，它有两大用途：
+
+- 在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
+- 作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。
+
+### 5. Parallel Old 收集器
+
+<div align="center"> <img src="/image/01/jvm/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/> </div><br>
+
+是 Parallel Scavenge 收集器的老年代版本。
+
+在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。
+
+### 6. CMS 收集器
+
+<div align="center"> <img src="/image/01/jvm/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/> </div><br>
+
+CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
+
+特点：并发收集、低停顿。并发指的是用户线程和 GC 线程同时运行。
+
+分为以下四个流程：
+
+- 初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
+- 并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
+- 重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
+- 并发清除：不需要停顿。
+
+在整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，不需要进行停顿。
+
+具有以下缺点：
+
+- 吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 CPU 利用率不够高。
+- 无法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。可以使用 -XX:CMSInitiatingOccupancyFraction 来改变触发 CMS 收集器工作的内存占用百分，如果这个值设置的太大，导致预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
+- 标记 - 清除算法导致的空间碎片，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。
+
+### 7. G1 收集器
+
+G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。
+
+Java 堆被分为新生代、老年代和永久代，其它收集器进行收集的范围都是整个新生代或者老生代，而 G1 可以直接对新生代和永久代一起回收。
+
+<div align="center"> <img src="/image/01/jvm/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/> </div><br>
+
+G1 把新生代和老年代划分成多个大小相等的独立区域（Region），新生代和永久代不再物理隔离。
+
+<div align="center"> <img src="/image/01/jvm/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/> </div><br>
+
+通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 记录垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
+
+每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
+
+<div align="center"> <img src="/image/01/jvm/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/> </div><br>
+
+如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
+
+- 初始标记
+- 并发标记
+- 最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
+- 筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿是时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。
+
+具备如下特点：
+
+- 空间整合：整体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
+- 可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。
+
+更详细内容请参考：[Getting Started with the G1 Garbage Collector](http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html)
+
+### 8. 比较
+
+| 收集器 | 串行/并行/并发 | 新生代/老年代 | 收集算法 | 目标 | 适用场景 |
+| :---: | :---: | :---: | :---: | :---: | :---: |
+|  **Serial**  | 串行 | 新生代 | 复制 | 响应速度优先 | 单 CPU 环境下的 Client 模式 |
+|  **Serial Old**  | 串行 | 老年代 | 标记-整理 | 响应速度优先 | 单 CPU 环境下的 Client 模式、CMS 的后备预案 |
+|  **ParNew**  | 串行 + 并行 | 新生代 | 复制算法 | 响应速度优先 | 多 CPU 环境时在 Server 模式下与 CMS 配合 |
+|  **Parallel Scavenge**  | 串行 + 并行 | 新生代 | 复制算法 | 吞吐量优先 | 在后台运算而不需要太多交互的任务 |
+|  **Parallel Old**  | 串行 + 并行 | 老年代 | 标记-整理 | 吞吐量优先 | 在后台运算而不需要太多交互的任务 |
+|  **CMS**  | 并行 + 并发 | 老年代 | 标记-清除 | 响应速度优先 | 集中在互联网站或 B/S 系统服务端上的 Java 应用 |
+|  **G1**  | 并行 + 并发 | 新生代 + 老年代 | 标记-整理 + 复制算法 | 响应速度优先 | 面向服务端应用，将来替换 CMS |
+
+## 内存分配与回收策略
+
+对象的内存分配，也就是在堆上分配。主要分配在新生代的 Eden 区上，少数情况下也可能直接分配在老年代中。
+
+### 1. Minor GC 和 Full GC
+
+- Minor GC：发生在新生代上，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
+- Full GC：发生在老年代上，老年代对象和新生代的相反，其存活时间长，因此 Full GC 很少执行，而且执行速度会比 Minor GC 慢很多。
+
+### 2. 内存分配策略
+
+**（一）对象优先在 Eden 分配**
+
+大多数情况下，对象在新生代 Eden 区分配，当 Eden 区空间不够时，发起 Minor GC。
+
+**（二）大对象直接进入老年代**
+
+大对象是指需要连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组。
+
+经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配给大对象。
+
+-XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制。
+
+**（三）长期存活的对象进入老年代**
+
+为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。
+
+-XX:MaxTenuringThreshold 用来定义年龄的阈值。
+
+**（四）动态对象年龄判定**
+
+虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 区中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
+
+**（五）空间分配担保**
+
+在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的；如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC，尽管这次 Minor GC 是有风险的；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那这时也要改为进行一次 Full GC。
+
+### 3. Full GC 的触发条件
+
+对于 Minor GC，其触发条件非常简单，当 Eden 区空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
+
+**（一）调用 System.gc()**
+
+此方法的调用是建议虚拟机进行 Full GC，虽然只是建议而非一定，但很多情况下它会触发 Full GC，从而增加 Full GC 的频率，也即增加了间歇性停顿的次数。因此强烈建议能不使用此方法就不要使用，让虚拟机自己去管理它的内存。可通过 -XX:DisableExplicitGC 来禁止 RMI 调用 System.gc()。
+
+**（二）老年代空间不足**
+
+老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等，当执行 Full GC 后空间仍然不足，则抛出 Java.lang.OutOfMemoryError。为避免以上原因引起的 Full GC，调优时应尽量做到让对象在 Minor GC 阶段被回收、让对象在新生代多存活一段时间以及不要创建过大的对象及数组。
+
+**（三）空间分配担保失败**
+
+使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果出现了 HandlePromotionFailure 担保失败，则会触发 Full GC。
+
+**（四）JDK 1.7 及以前的永久代空间不足**
+
+在 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 时当前的浮动垃圾过多导致暂时性的空间不足触发 Full GC），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
+
+# 三、类加载机制
+
+类是在运行期间动态加载的。
+
+## 类的生命周期
+
+<div align="center"> <img src="/image/01/jvm/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/> </div><br>
+
+包括以下 7 个阶段：
+
+-  **加载（Loading）**
+-  **验证（Verification）**
+-  **准备（Preparation）**
+-  **解析（Resolution）**
+-  **初始化（Initialization）**
+- 使用（Using）
+- 卸载（Unloading）
+
+其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
+
+## 类初始化时机
+
+虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随着发生）：
+
+- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
+
+- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
+
+- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
+
+- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
+
+- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
+
+以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
+
+- 通过子类引用父类的静态字段，不会导致子类初始化。
+
+```java
+System.out.println(SubClass.value); // value 字段在 SuperClass 中定义
+```
+
+- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
+
+```java
+SuperClass[] sca = new SuperClass[10];
+```
+
+- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
+
+```java
+System.out.println(ConstClass.HELLOWORLD);
+```
+
+## 类加载过程
+
+包含了加载、验证、准备、解析和初始化这 5 个阶段。
+
+### 1. 加载
+
+加载是类加载的一个阶段，注意不要混淆。
+
+加载过程完成以下三件事：
+
+- 通过一个类的全限定名来获取定义此类的二进制字节流。
+- 将这个字节流所代表的静态存储结构转化为方法区的运行时存储结构。
+- 在内存中生成一个代表这个类的 Class 对象，作为方法区这个类的各种数据的访问入口。
+
+其中二进制字节流可以从以下方式中获取：
+
+- 从 ZIP 包读取，这很常见，最终成为日后 JAR、EAR、WAR 格式的基础。
+- 从网络中获取，这种场景最典型的应用是 Applet。
+- 运行时计算生成，这种场景使用得最多得就是动态代理技术，在 java.lang.reflect.Proxy 中，就是用了 ProxyGenerator.generateProxyClass 的代理类的二进制字节流。
+- 由其他文件生成，典型场景是 JSP 应用，即由 JSP 文件生成对应的 Class 类。
+- 从数据库读取，这种场景相对少见，例如有些中间件服务器（如 SAP Netweaver）可以选择把程序安装到数据库中来完成程序代码在集群间的分发。
+...
+
+### 2. 验证
+
+确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
+
+- 文件格式验证：验证字节流是否符合 Class 文件格式的规范，并且能被当前版本的虚拟机处理。
+- 元数据验证：对字节码描述的信息进行语义分析，以保证其描述的信息符合 Java 语言规范的要求。
+- 字节码验证：通过数据流和控制流分析，确保程序语义是合法、符合逻辑的。
+- 符号引用验证：发生在虚拟机将符号引用转换为直接引用的时候，对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验。
+
+### 3. 准备
+
+类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存。
+
+实例变量不会在这阶段分配内存，它将会在对象实例化时随着对象一起分配在 Java 堆中。（实例化不是类加载的一个过程，类加载发生在所有实例化操作之前，并且类加载只进行一次，实例化可以进行多次）
+
+初始值一般为 0 值，例如下面的类变量 value 被初始化为 0 而不是 123。
+
+```java
+public static int value = 123;
+```
+
+如果类变量是常量，那么会按照表达式来进行初始化，而不是赋值为 0。
+
+```java
+public static final int value = 123;
+```
+
+### 4. 解析
+
+将常量池的符号引用替换为直接引用的过程。
+
+### 5. 初始化
+
+初始化阶段才真正开始执行类中的定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 &lt;clinit>() 方法的过程。
+
+在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
+
+&lt;clinit>() 方法具有以下特点：
+
+- 是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static{} 块）中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
+
+```java
+public class Test {
+    static {
+        i = 0;                // 给变量赋值可以正常编译通过
+        System.out.print(i);  // 这句编译器会提示“非法向前引用”
+    }
+    static int i = 1;
+}
+```
+
+- 与类的构造函数（或者说实例构造器 &lt;init>()）不同，不需要显式的调用父类的构造器。虚拟机会自动保证在子类的 &lt;clinit>() 方法运行之前，父类的 &lt;clinit>() 方法已经执行结束。因此虚拟机中第一个执行 &lt;clinit>() 方法的类肯定为 java.lang.Object。
+
+- 由于父类的 &lt;clinit>() 方法先执行，也就意味着父类中定义的静态语句块要优于子类的变量赋值操作。例如以下代码：
+
+```java
+static class Parent {
+    public static int A = 1;
+    static {
+        A = 2;
+    }
+}
+
+static class Sub extends Parent {
+    public static int B = A;
+}
+
+public static void main(String[] args) {
+     System.out.println(Sub.B);  // 输出结果是父类中的静态变量 A 的值，也就是 2。
+}
+```
+
+- &lt;clinit>() 方法对于类或接口不是必须的，如果一个类中不包含静态语句块，也没有对类变量的赋值操作，编译器可以不为该类生成 &lt;clinit>() 方法。
+
+- 接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 &lt;clinit>() 方法。但接口与类不同的是，执行接口的 &lt;clinit>() 方法不需要先执行父接口的 &lt;clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 &lt;clinit>() 方法。
+
+- 虚拟机会保证一个类的 &lt;clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 &lt;clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 &lt;clinit>() 方法完毕。如果在一个类的 &lt;clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
+
+## 类加载器
+
+实现类的加载动作。在 Java 虚拟机外部实现，以便让应用程序自己决定如何去获取所需要的类。
+
+### 1. 类与类加载器
+
+两个类相等：类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
+
+这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
+
+### 2. 类加载器分类
+
+从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
+
+- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
+
+- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
+
+从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
+
+- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 &lt;JAVA_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
+
+- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 &lt;JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
+
+- 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
+
+### 3. 双亲委派模型
+
+应用程序都是由三种类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的类加载器。
+
+下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
+
+<div align="center"> <img src="/image/01/jvm/class_loader_hierarchy.png" width="600"/> </div><br>
+
+**（一）工作过程**
+
+一个类加载器首先将类加载请求传送到父类加载器，只有当父类加载器无法完成类加载请求时才尝试加载。
+
+**（二）好处**
+
+使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而是的基础类得到统一。
+
+例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。因为双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。正因为 rt.jar 中的 Object 优先级更高，因为程序中所有的 Object 都是这个 Object。
+
+**（三）实现**
+
+以下是抽象类 java.lang.ClassLoader 的代码片段，其中的 loadClass() 方法运行过程如下：先检查类是否已经加载过，如果没有则让父类加载器去加载。当父类加载器加载失败时抛出 ClassNotFoundException，此时尝试自己去加载。
+
+```java
+public abstract class ClassLoader {
+    // The parent class loader for delegation
+    private final ClassLoader parent;
+
+    public Class<?> loadClass(String name) throws ClassNotFoundException {
+        return loadClass(name, false);
+    }
+
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        synchronized (getClassLoadingLock(name)) {
+            // First, check if the class has already been loaded
+            Class<?> c = findLoadedClass(name);
+            if (c == null) {
+                try {
+                    if (parent != null) {
+                        c = parent.loadClass(name, false);
+                    } else {
+                        c = findBootstrapClassOrNull(name);
+                    }
+                } catch (ClassNotFoundException e) {
+                    // ClassNotFoundException thrown if class not found
+                    // from the non-null parent class loader
+                }
+
+                if (c == null) {
+                    // If still not found, then invoke findClass in order
+                    // to find the class.
+                    c = findClass(name);
+                }
+            }
+            if (resolve) {
+                resolveClass(c);
+            }
+            return c;
+        }
+    }
+
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        throw new ClassNotFoundException(name);
+    }
+}
+```
+
+### 4. 自定义类加载器实现
+
+FileSystemClassLoader 是自定义类加载器，继承自 java.lang.ClassLoader，用于加载文件系统上的类。它首先根据类的全名在文件系统上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。
+
+java.lang.ClassLoader 类的方法 loadClass() 实现了双亲委派模型的逻辑，因此自定义类加载器一般不去重写它，而是通过重写 findClass() 方法。
+
+```java
+public class FileSystemClassLoader extends ClassLoader {
+
+    private String rootDir;
+
+    public FileSystemClassLoader(String rootDir) {
+        this.rootDir = rootDir;
+    }
+
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        byte[] classData = getClassData(name);
+        if (classData == null) {
+            throw new ClassNotFoundException();
+        } else {
+            return defineClass(name, classData, 0, classData.length);
+        }
+    }
+
+    private byte[] getClassData(String className) {
+        String path = classNameToPath(className);
+        try {
+            InputStream ins = new FileInputStream(path);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            int bufferSize = 4096;
+            byte[] buffer = new byte[bufferSize];
+            int bytesNumRead;
+            while ((bytesNumRead = ins.read(buffer)) != -1) {
+                baos.write(buffer, 0, bytesNumRead);
+            }
+            return baos.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private String classNameToPath(String className) {
+        return rootDir + File.separatorChar
+                + className.replace('.', File.separatorChar) + ".class";
+    }
+}
+```
+
+# 四、JVM 参数
+
+## GC 优化配置
+
+| 配置 | 描述 |
+| --- | --- |
+| -Xms | 初始化堆内存大小 |
+| -Xmx | 堆内存最大值 |
+| -Xmn | 新生代大小 |
+| -XX:PermSize | 初始化永久代大小 |
+| -XX:MaxPermSize | 永久代最大容量 |
+
+## GC 类型设置
+
+| 配置 | 描述 |
+| --- | --- |
+| -XX:+UseSerialGC | 串行垃圾回收器 |
+| -XX:+UseParallelGC | 并行垃圾回收器 |
+| -XX:+UseConcMarkSweepGC | 并发标记扫描垃圾回收器 |
+| -XX:ParallelCMSThreads= | 并发标记扫描垃圾回收器 = 为使用的线程数量 |
+| -XX:+UseG1GC | G1 垃圾回收器 |
+
+```java
+java -Xmx12m -Xms3m -Xmn1m -XX:PermSize=20m -XX:MaxPermSize=20m -XX:+UseSerialGC -jar java-application.jar
+```
+
+# 参考资料
+
+- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
+- [Jvm memory](https://www.slideshare.net/benewu/jvm-memory)
+- [Memory Architecture Of JVM(Runtime Data Areas)](https://hackthejava.wordpress.com/2015/01/09/memory-architecture-by-jvmruntime-data-areas/)
+- [JVM Run-Time Data Areas](https://www.programcreek.com/2013/04/jvm-run-time-data-areas/)
+- [Android on x86: Java Native Interface and the Android Native Development Kit](http://www.drdobbs.com/architecture-and-design/android-on-x86-java-native-interface-and/240166271)
+- [深入理解 JVM(2)——GC 算法与内存分配策略](https://crowhawk.github.io/2017/08/10/jvm_2/)
+- [深入理解 JVM(3)——7 种垃圾收集器](https://crowhawk.github.io/2017/08/15/jvm_3/)
+- [JVM Internals](http://blog.jamesdbloom.com/JVMInternals.html)
+- [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
+- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
+- [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
diff --git a/01 - JavaSE/01 - JVM/all.md "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/all.md"
similarity index 95%
rename from 01 - JavaSE/01 - JVM/all.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/all.md"
index 8080935b..0275dc39 100644
--- a/01 - JavaSE/01 - JVM/all.md	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/all.md"	
@@ -1,69 +1,69 @@
-### 类加载
-  双亲委派模型
-  三种类加载器
-  类名相等且由同一个类加载器实例加载
-
-### 内存模型
-  多线程下的共享变量
-  工作内存与主内存交互协议
-    lock
-    unlock
-    read
-    load
-    use
-    assign
-    store
-    write
-
-### 虚拟内存结构
-
-### class二进制字节码结构
-
-### GC
-  对象存活判断
-    引用计数法
-    可达性分析
-      GCROOTs
-      (1). 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。
-      (2). 方法区中的类静态属性引用的对象。
-      (3). 方法区中常量引用的对象。
-      (4). 本地方法栈中JNI(Native方法)引用的对象。
-  回收策略
-    标记-清除
-    标记-复制
-    标记-整理
-    分代收集
-      新生代
-      老年代
-      永久代
-  按运行方式分类（参考 /10-readingNote/IT/深入理解Java虚拟机/第3章）
-    串行收集器：只有一条GC，会stop the world
-    并行收集器：多条GC,会stop the world
-    并发收集器：一条或多条GC线程，需要在部分阶段stop the world,部分阶段与程序并发
-  Hotspot具体
-    串行:serial,serial old
-    并行:ParNew,Parallel Scavenge,Parallel Old
-    并发:CMS
-  两种运行方式
-    client
-      开发默认
-      启动较快
-      不适合长时间运行
-    server
-      -server强制开启server模式
-      JVM在运行过程做较多优化，运行时间越长，运行速度越快
-      启动较慢
-
-### 四种引用类型
-  强引用
-  软引用
-  弱引用
-  虚引用
-
-### 生命周期
-  加载
-  链接
-    验证
-    准备
-    解析
-  初始化
+### 类加载
+  双亲委派模型
+  三种类加载器
+  类名相等且由同一个类加载器实例加载
+
+### 内存模型
+  多线程下的共享变量
+  工作内存与主内存交互协议
+    lock
+    unlock
+    read
+    load
+    use
+    assign
+    store
+    write
+
+### 虚拟内存结构
+
+### class二进制字节码结构
+
+### GC
+  对象存活判断
+    引用计数法
+    可达性分析
+      GCROOTs
+      (1). 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。
+      (2). 方法区中的类静态属性引用的对象。
+      (3). 方法区中常量引用的对象。
+      (4). 本地方法栈中JNI(Native方法)引用的对象。
+  回收策略
+    标记-清除
+    标记-复制
+    标记-整理
+    分代收集
+      新生代
+      老年代
+      永久代
+  按运行方式分类（参考 /10-readingNote/IT/深入理解Java虚拟机/第3章）
+    串行收集器：只有一条GC，会stop the world
+    并行收集器：多条GC,会stop the world
+    并发收集器：一条或多条GC线程，需要在部分阶段stop the world,部分阶段与程序并发
+  Hotspot具体
+    串行:serial,serial old
+    并行:ParNew,Parallel Scavenge,Parallel Old
+    并发:CMS
+  两种运行方式
+    client
+      开发默认
+      启动较快
+      不适合长时间运行
+    server
+      -server强制开启server模式
+      JVM在运行过程做较多优化，运行时间越长，运行速度越快
+      启动较慢
+
+### 四种引用类型
+  强引用
+  软引用
+  弱引用
+  虚引用
+
+### 生命周期
+  加载
+  链接
+    验证
+    准备
+    解析
+  初始化
diff --git "a/01 - JavaSE/01 - JVM/\345\206\205\345\255\230\345\214\272\345\237\237.jpg" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\345\206\205\345\255\230\345\214\272\345\237\237.jpg"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\345\206\205\345\255\230\345\214\272\345\237\237.jpg"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\345\206\205\345\255\230\345\214\272\345\237\237.jpg"
diff --git "a/01 - JavaSE/01 - JVM/\345\206\205\345\255\230\346\250\241\345\236\213.png" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\345\206\205\345\255\230\346\250\241\345\236\213.png"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\345\206\205\345\255\230\346\250\241\345\236\213.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\345\206\205\345\255\230\346\250\241\345\236\213.png"
diff --git "a/01 - JavaSE/01 - JVM/\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250jdk\347\211\210\346\234\254.png" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250jdk\347\211\210\346\234\254.png"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250jdk\347\211\210\346\234\254.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250jdk\347\211\210\346\234\254.png"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/JVM_Monitor.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/JVM_Monitor.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/JVM_Monitor.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/JVM_Monitor.md"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Java \350\277\233\347\250\213\345\215\240\347\224\250 VIRT \350\231\232\346\213\237\345\206\205\345\255\230\350\266\205\351\253\230\347\232\204\351\227\256\351\242\230\347\240\224\347\251\266.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Java \350\277\233\347\250\213\345\215\240\347\224\250 VIRT \350\231\232\346\213\237\345\206\205\345\255\230\350\266\205\351\253\230\347\232\204\351\227\256\351\242\230\347\240\224\347\251\266.txt"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Java \350\277\233\347\250\213\345\215\240\347\224\250 VIRT \350\231\232\346\213\237\345\206\205\345\255\230\350\266\205\351\253\230\347\232\204\351\227\256\351\242\230\347\240\224\347\251\266.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Java \350\277\233\347\250\213\345\215\240\347\224\250 VIRT \350\231\232\346\213\237\345\206\205\345\255\230\350\266\205\351\253\230\347\232\204\351\227\256\351\242\230\347\240\224\347\251\266.txt"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Jstat.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Jstat.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Jstat.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/Jstat.md"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmap_histo_pid.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmap_histo_pid.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmap_histo_pid.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmap_histo_pid.md"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmeter_server_polling_pressure_test.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmeter_server_polling_pressure_test.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmeter_server_polling_pressure_test.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jmeter_server_polling_pressure_test.md"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstack.md" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstack.md"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstack.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstack.md"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstat.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstat.txt"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstat.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/jstat.txt"
diff --git "a/01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/wenti.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/wenti.txt"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/wenti.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\200\247\350\203\275\346\243\200\346\265\213/wenti.txt"
diff --git "a/01 - JavaSE/01 - JVM/\346\226\260\347\224\237\344\273\243\350\200\201\345\271\264\344\273\243 \345\236\203\345\234\276\345\233\236\346\224\266\345\231\250.png" "b/01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\226\260\347\224\237\344\273\243\350\200\201\345\271\264\344\273\243 \345\236\203\345\234\276\345\233\236\346\224\266\345\231\250.png"
similarity index 100%
rename from "01 - JavaSE/01 - JVM/\346\226\260\347\224\237\344\273\243\350\200\201\345\271\264\344\273\243 \345\236\203\345\234\276\345\233\236\346\224\266\345\231\250.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/01 - JVM/\346\226\260\347\224\237\344\273\243\350\200\201\345\271\264\344\273\243 \345\236\203\345\234\276\345\233\236\346\224\266\345\231\250.png"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/BigDecimal.md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/BigDecimal.md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/BigDecimal.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/BigDecimal.md"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/Object\347\261\273/Object \347\261\273\344\270\255\347\232\204\346\226\271\346\263\225.md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/Object\347\261\273/Object \347\261\273\344\270\255\347\232\204\346\226\271\346\263\225.md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/Object\347\261\273/Object \347\261\273\344\270\255\347\232\204\346\226\271\346\263\225.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/Object\347\261\273/Object \347\261\273\344\270\255\347\232\204\346\226\271\346\263\225.md"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/Object\347\261\273/Object-hashCode().md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/Object\347\261\273/Object-hashCode().md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/Object\347\261\273/Object-hashCode().md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/Object\347\261\273/Object-hashCode().md"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/String.md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/String.md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/String.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/String.md"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/java\346\225\260\345\255\227\347\261\273\345\236\213\345\220\210\346\263\225\350\275\254\346\215\242.png" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/java\346\225\260\345\255\227\347\261\273\345\236\213\345\220\210\346\263\225\350\275\254\346\215\242.png"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/java\346\225\260\345\255\227\347\261\273\345\236\213\345\220\210\346\263\225\350\275\254\346\215\242.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/java\346\225\260\345\255\227\347\261\273\345\236\213\345\220\210\346\263\225\350\275\254\346\215\242.png"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/question.md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/question.md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/question.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/question.md"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/\345\237\272\346\234\254\347\261\273\345\236\213 \345\214\205\350\243\205\347\261\273\345\236\213.md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/\345\237\272\346\234\254\347\261\273\345\236\213 \345\214\205\350\243\205\347\261\273\345\236\213.md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/\345\237\272\346\234\254\347\261\273\345\236\213 \345\214\205\350\243\205\347\261\273\345\236\213.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/\345\237\272\346\234\254\347\261\273\345\236\213 \345\214\205\350\243\205\347\261\273\345\236\213.md"
diff --git "a/01 - JavaSE/02 - \347\261\273\345\236\213/\346\257\224\350\276\203.md" "b/01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/\346\257\224\350\276\203.md"
similarity index 100%
rename from "01 - JavaSE/02 - \347\261\273\345\236\213/\346\257\224\350\276\203.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/02 - \347\261\273\345\236\213/\346\257\224\350\276\203.md"
diff --git "a/01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-clone().md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-clone().md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-clone().md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-clone().md"
diff --git "a/01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-equals().md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-equals().md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-equals().md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-equals().md"
diff --git "a/01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-toString().md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-toString().md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-toString().md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object-toString().md"
diff --git "a/01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/Object.md"
diff --git "a/01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/README.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\230\205\350\257\273\346\272\220\344\273\243\347\240\201/README.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/01 Collection Map.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/01 Collection Map.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/01 Collection Map.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/01 Collection Map.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/02 \345\256\271\345\231\250\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/02 \345\256\271\345\231\250\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/02 \345\256\271\345\231\250\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/02 \345\256\271\345\231\250\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ArrayList.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ArrayList.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ArrayList.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ArrayList.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ConcurrentHashMap.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ConcurrentHashMap.md"
similarity index 97%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ConcurrentHashMap.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ConcurrentHashMap.md"
index 5f34a06a..5c4fcc7f 100644
--- "a/01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ConcurrentHashMap.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -ConcurrentHashMap.md"	
@@ -1,144 +1,144 @@
-## ConcurrentHashMap
-
-[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/1.7/ConcurrentHashMap.java)
-
-### 1. 存储结构
-
-```java
-static final class HashEntry<K,V> {
-    final int hash;
-    final K key;
-    volatile V value;
-    volatile HashEntry<K,V> next;
-}
-```
-
-Segment 继承自 ReentrantLock，每个 Segment 维护着多个 HashEntry。
-
-ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
-
-```java
-static final class Segment<K,V> extends ReentrantLock implements Serializable {
-
-    private static final long serialVersionUID = 2249069246763182397L;
-
-    static final int MAX_SCAN_RETRIES =
-        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
-
-    transient volatile HashEntry<K,V>[] table;
-
-    transient int count;
-
-    transient int modCount;
-
-    transient int threshold;
-
-    final float loadFactor;
-}
-```
-
-```java
-final Segment<K,V>[] segments;
-```
-
-默认的并发级别为 16，也就是说默认创建 16 个 Segment。
-
-```java
-static final int DEFAULT_CONCURRENCY_LEVEL = 16;
-```
-
-<div align="center"> <img src="/image/01/Iterator/image005.jpg"/> </div><br>
-
-### 2. size 操作
-
-每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。
-
-```java
-/**
- * The number of elements. Accessed only either within locks
- * or among other volatile reads that maintain visibility.
- */
-transient int count;
-```
-
-在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
-
-ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
-
-尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。
-
-如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
-
-```java
-
-/**
- * Number of unsynchronized retries in size and containsValue
- * methods before resorting to locking. This is used to avoid
- * unbounded retries if tables undergo continuous modification
- * which would make it impossible to obtain an accurate result.
- */
-static final int RETRIES_BEFORE_LOCK = 2;
-
-public int size() {
-    // Try a few times to get accurate count. On failure due to
-    // continuous async changes in table, resort to locking.
-    final Segment<K,V>[] segments = this.segments;
-    int size;
-    boolean overflow; // true if size overflows 32 bits
-    long sum;         // sum of modCounts
-    long last = 0L;   // previous sum
-    int retries = -1; // first iteration isn't retry
-    try {
-        for (;;) {
-            // 超过尝试次数，则对每个 Segment 加锁
-            if (retries++ == RETRIES_BEFORE_LOCK) {
-                for (int j = 0; j < segments.length; ++j)
-                    ensureSegment(j).lock(); // force creation
-            }
-            sum = 0L;
-            size = 0;
-            overflow = false;
-            for (int j = 0; j < segments.length; ++j) {
-                Segment<K,V> seg = segmentAt(segments, j);
-                if (seg != null) {
-                    sum += seg.modCount;
-                    int c = seg.count;
-                    if (c < 0 || (size += c) < 0)
-                        overflow = true;
-                }
-            }
-            // 连续两次得到的结果一致，则认为这个结果是正确的
-            if (sum == last)
-                break;
-            last = sum;
-        }
-    } finally {
-        if (retries > RETRIES_BEFORE_LOCK) {
-            for (int j = 0; j < segments.length; ++j)
-                segmentAt(segments, j).unlock();
-        }
-    }
-    return overflow ? Integer.MAX_VALUE : size;
-}
-```
-
-
-### 3. JDK 1.8 的改动
-
-[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/ConcurrentHashMap.java)
-
-从JDK1.7版本的ReentrantLock+Segment+HashEntry，到JDK1.8版本中synchronized+CAS+HashEntry+红黑树
-
-JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。
-
-JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
-
-并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
-
-* JDK1.8的实现降低锁的粒度，JDK1.7版本锁的粒度是基于Segment的，包含多个HashEntry，而JDK1.8锁的粒度就是HashEntry（首节点）
-* JDK1.8版本的数据结构变得更加简单，使得操作也更加清晰流畅，因为已经使用synchronized来进行同步，所以不需要分段锁的概念，也就不需要Segment这种数据结构了，由于粒度的降低，实现的复杂度也增加了
-* JDK1.8使用红黑树来优化链表，基于长度很长的链表的遍历是一个很漫长的过程，而红黑树的遍历效率是很快的，代替一定阈值的链表，这样形成一个最佳拍档
-* JDK1.8为什么使用内置锁synchronized来代替重入锁ReentrantLock，我觉得有以下几点
-  * 因为粒度降低了，在相对而言的低粒度加锁方式，synchronized并不比ReentrantLock差，在粗粒度加锁中ReentrantLock可能通过Condition来控制各个低粒度的边界，更加的灵活，而在低粒度中，Condition的优势就没有了
-  * JVM的开发团队从来都没有放弃synchronized，而且基于JVM的synchronized优化空间更大，使用内嵌的关键字比使用API更加自然
-  * 在大量的数据操作下，对于JVM的内存压力，基于API的ReentrantLock会开销更多的内存，虽然不是瓶颈，但是也是一个选择依据
+## ConcurrentHashMap
+
+[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/1.7/ConcurrentHashMap.java)
+
+### 1. 存储结构
+
+```java
+static final class HashEntry<K,V> {
+    final int hash;
+    final K key;
+    volatile V value;
+    volatile HashEntry<K,V> next;
+}
+```
+
+Segment 继承自 ReentrantLock，每个 Segment 维护着多个 HashEntry。
+
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
+
+```java
+static final class Segment<K,V> extends ReentrantLock implements Serializable {
+
+    private static final long serialVersionUID = 2249069246763182397L;
+
+    static final int MAX_SCAN_RETRIES =
+        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+
+    transient volatile HashEntry<K,V>[] table;
+
+    transient int count;
+
+    transient int modCount;
+
+    transient int threshold;
+
+    final float loadFactor;
+}
+```
+
+```java
+final Segment<K,V>[] segments;
+```
+
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+
+```java
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+```
+
+<div align="center"> <img src="/image/01/Iterator/image005.jpg"/> </div><br>
+
+### 2. size 操作
+
+每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。
+
+```java
+/**
+ * The number of elements. Accessed only either within locks
+ * or among other volatile reads that maintain visibility.
+ */
+transient int count;
+```
+
+在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
+
+ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
+
+尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。
+
+如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
+
+```java
+
+/**
+ * Number of unsynchronized retries in size and containsValue
+ * methods before resorting to locking. This is used to avoid
+ * unbounded retries if tables undergo continuous modification
+ * which would make it impossible to obtain an accurate result.
+ */
+static final int RETRIES_BEFORE_LOCK = 2;
+
+public int size() {
+    // Try a few times to get accurate count. On failure due to
+    // continuous async changes in table, resort to locking.
+    final Segment<K,V>[] segments = this.segments;
+    int size;
+    boolean overflow; // true if size overflows 32 bits
+    long sum;         // sum of modCounts
+    long last = 0L;   // previous sum
+    int retries = -1; // first iteration isn't retry
+    try {
+        for (;;) {
+            // 超过尝试次数，则对每个 Segment 加锁
+            if (retries++ == RETRIES_BEFORE_LOCK) {
+                for (int j = 0; j < segments.length; ++j)
+                    ensureSegment(j).lock(); // force creation
+            }
+            sum = 0L;
+            size = 0;
+            overflow = false;
+            for (int j = 0; j < segments.length; ++j) {
+                Segment<K,V> seg = segmentAt(segments, j);
+                if (seg != null) {
+                    sum += seg.modCount;
+                    int c = seg.count;
+                    if (c < 0 || (size += c) < 0)
+                        overflow = true;
+                }
+            }
+            // 连续两次得到的结果一致，则认为这个结果是正确的
+            if (sum == last)
+                break;
+            last = sum;
+        }
+    } finally {
+        if (retries > RETRIES_BEFORE_LOCK) {
+            for (int j = 0; j < segments.length; ++j)
+                segmentAt(segments, j).unlock();
+        }
+    }
+    return overflow ? Integer.MAX_VALUE : size;
+}
+```
+
+
+### 3. JDK 1.8 的改动
+
+[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/ConcurrentHashMap.java)
+
+从JDK1.7版本的ReentrantLock+Segment+HashEntry，到JDK1.8版本中synchronized+CAS+HashEntry+红黑树
+
+JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发程度与 Segment 数量相等。
+
+JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
+
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
+
+* JDK1.8的实现降低锁的粒度，JDK1.7版本锁的粒度是基于Segment的，包含多个HashEntry，而JDK1.8锁的粒度就是HashEntry（首节点）
+* JDK1.8版本的数据结构变得更加简单，使得操作也更加清晰流畅，因为已经使用synchronized来进行同步，所以不需要分段锁的概念，也就不需要Segment这种数据结构了，由于粒度的降低，实现的复杂度也增加了
+* JDK1.8使用红黑树来优化链表，基于长度很长的链表的遍历是一个很漫长的过程，而红黑树的遍历效率是很快的，代替一定阈值的链表，这样形成一个最佳拍档
+* JDK1.8为什么使用内置锁synchronized来代替重入锁ReentrantLock，我觉得有以下几点
+  * 因为粒度降低了，在相对而言的低粒度加锁方式，synchronized并不比ReentrantLock差，在粗粒度加锁中ReentrantLock可能通过Condition来控制各个低粒度的边界，更加的灵活，而在低粒度中，Condition的优势就没有了
+  * JVM的开发团队从来都没有放弃synchronized，而且基于JVM的synchronized优化空间更大，使用内嵌的关键字比使用API更加自然
+  * 在大量的数据操作下，对于JVM的内存压力，基于API的ReentrantLock会开销更多的内存，虽然不是瓶颈，但是也是一个选择依据
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -HashMap.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -HashMap.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -HashMap.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -HashMap.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -LinkedList.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -LinkedList.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -LinkedList.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -LinkedList.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -Vector.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -Vector.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -Vector.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/03 \346\272\220\347\240\201\345\210\206\346\236\220 -Vector.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/ArrayList VS LinkedList.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/ArrayList VS LinkedList.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/ArrayList VS LinkedList.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/ArrayList VS LinkedList.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/ArrayList \343\200\201 LinkedList \343\200\201 Vector \347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/ArrayList \343\200\201 LinkedList \343\200\201 Vector \347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/ArrayList \343\200\201 LinkedList \343\200\201 Vector \347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/ArrayList \343\200\201 LinkedList \343\200\201 Vector \347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/ArrayList\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/ArrayList\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/ArrayList\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/ArrayList\346\272\220\347\240\201\345\211\226\346\236\220.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Arraylist.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Arraylist.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Arraylist.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Arraylist.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Arraylist\345\222\214Hashmap\345\246\202\344\275\225\346\211\251\345\256\271\347\255\211.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Arraylist\345\222\214Hashmap\345\246\202\344\275\225\346\211\251\345\256\271\347\255\211.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Arraylist\345\222\214Hashmap\345\246\202\344\275\225\346\211\251\345\256\271\347\255\211.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Arraylist\345\222\214Hashmap\345\246\202\344\275\225\346\211\251\345\256\271\347\255\211.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Collection2.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Collection2.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Collection2.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Collection2.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/HashMap\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashMap\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/HashMap\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashMap\346\272\220\347\240\201\345\211\226\346\236\220.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/HashSet VS TreeSet.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashSet VS TreeSet.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/HashSet VS TreeSet.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashSet VS TreeSet.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/HashSet VS TreeSet2.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashSet VS TreeSet2.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/HashSet VS TreeSet2.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashSet VS TreeSet2.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/HashTable\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashTable\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/HashTable\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/HashTable\346\272\220\347\240\201\345\211\226\346\236\220.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Hashmap\347\232\204hashcode\347\232\204\344\275\234\347\224\250\347\255\211.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Hashmap\347\232\204hashcode\347\232\204\344\275\234\347\224\250\347\255\211.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Hashmap\347\232\204hashcode\347\232\204\344\275\234\347\224\250\347\255\211.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Hashmap\347\232\204hashcode\347\232\204\344\275\234\347\224\250\347\255\211.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Iterator.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Iterator.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Iterator.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Iterator.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\236\266\346\236\204\345\233\276.png" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\236\266\346\236\204\345\233\276.png"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\236\266\346\236\204\345\233\276.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\236\266\346\236\204\345\233\276.png"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\241\206\346\236\266.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\241\206\346\236\266.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\241\206\346\236\266.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Java\351\233\206\345\220\210\346\241\206\346\236\266.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/LinkedHashMap\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/LinkedHashMap\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/LinkedHashMap\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/LinkedHashMap\346\272\220\347\240\201\345\211\226\346\236\220.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/LinkedList\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/LinkedList\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/LinkedList\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/LinkedList\346\272\220\347\240\201\345\211\226\346\236\220.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Linkedlist.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Linkedlist.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Linkedlist.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Linkedlist.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/List.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/List.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/List.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/List.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Queue.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Queue.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Queue.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Queue.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/Set.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Set.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/Set.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/Set.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/collection.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/collection.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/collection.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/collection.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashMap.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashMap.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/hashMap.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashMap.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashMap_vs_hashTable.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashMap_vs_hashTable.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/hashMap_vs_hashTable.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashMap_vs_hashTable.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashmap1.8.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap1.8.md"
similarity index 98%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/hashmap1.8.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap1.8.md"
index 23d074bc..8f8d58dd 100644
--- "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashmap1.8.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap1.8.md"	
@@ -1,11 +1,11 @@
- 数组 + 链表 + 红黑树
-
- 红黑树节点，有父亲、左右孩子、前一个元素的节点，还有个颜色值。
-
- 提高效率
-
- 添加、删除、查找、扩容方法都增加了一种 节点为 TreeNode
-
-* 添加时，当桶中链表个数超过 8 时会转换成红黑树；
-* 删除、扩容时，如果桶中结构为红黑树，并且树中元素个数太少的话，会进行修剪或者直接还原成链表结构；
-* 查找时即使哈希函数不优，大量元素集中在一个桶中，由于有红黑树结构，性能也不会差。
+ 数组 + 链表 + 红黑树
+
+ 红黑树节点，有父亲、左右孩子、前一个元素的节点，还有个颜色值。
+
+ 提高效率
+
+ 添加、删除、查找、扩容方法都增加了一种 节点为 TreeNode
+
+* 添加时，当桶中链表个数超过 8 时会转换成红黑树；
+* 删除、扩容时，如果桶中结构为红黑树，并且树中元素个数太少的话，会进行修剪或者直接还原成链表结构；
+* 查找时即使哈希函数不优，大量元素集中在一个桶中，由于有红黑树结构，性能也不会差。
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2061 .md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2061 .md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2061 .md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2061 .md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2062 .md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2062 .md"
similarity index 98%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2062 .md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2062 .md"
index 997d8fc0..40631a09 100644
--- "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2062 .md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\345\272\225\345\261\202\345\216\237\347\220\2062 .md"	
@@ -1,51 +1,51 @@
-
-和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
-Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
-Hashtable 的函数都是 **同步** 的，这意味着它是 **线程安全** 的。它的 **key、value都不可以为null**。此外，Hashtable中的映射不是有序的。
-
-Hashtable 的实例有两个参数影响其性能：**初始容量** 和 **加载因子**。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。
-通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数 Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。
-
-modCount++;
-
-```java
-public synchronized V put(K key, V value) {
-    // Hashtable中不能插入value为null的元素！！！
-    if (value == null) {
-        throw new NullPointerException();
-    }
-    // 若“Hashtable中已存在键为key的键值对”，
-    // 则用“新的value”替换“旧的value”
-    Entry tab[] = table;
-    int hash = key.hashCode();
-    int index = (hash & 0x7FFFFFFF) % tab.length;
-    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-        if ((e.hash == hash) && e.key.equals(key)) {
-            V old = e.value;
-            e.value = value;
-            return old;
-            }
-    }
-
-    // 若“Hashtable中不存在键为key的键值对”，
-    // (01) 将“修改统计数”+1
-    modCount++;
-    // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
-    //  则调整Hashtable的大小
-    if (count >= threshold) {
-        // Rehash the table if the threshold is exceeded
-        rehash();
-
-        tab = table;
-        index = (hash & 0x7FFFFFFF) % tab.length;
-    }
-
-    // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中
-    Entry<K,V> e = tab[index];
-    // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。        
-    tab[index] = new Entry<K,V>(hash, key, value, e);
-    // (05) 将“Hashtable的实际容量”+1
-    count++;
-    return null;
-}
-```
+
+和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
+Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
+Hashtable 的函数都是 **同步** 的，这意味着它是 **线程安全** 的。它的 **key、value都不可以为null**。此外，Hashtable中的映射不是有序的。
+
+Hashtable 的实例有两个参数影响其性能：**初始容量** 和 **加载因子**。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。
+通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数 Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。
+
+modCount++;
+
+```java
+public synchronized V put(K key, V value) {
+    // Hashtable中不能插入value为null的元素！！！
+    if (value == null) {
+        throw new NullPointerException();
+    }
+    // 若“Hashtable中已存在键为key的键值对”，
+    // 则用“新的value”替换“旧的value”
+    Entry tab[] = table;
+    int hash = key.hashCode();
+    int index = (hash & 0x7FFFFFFF) % tab.length;
+    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+        if ((e.hash == hash) && e.key.equals(key)) {
+            V old = e.value;
+            e.value = value;
+            return old;
+            }
+    }
+
+    // 若“Hashtable中不存在键为key的键值对”，
+    // (01) 将“修改统计数”+1
+    modCount++;
+    // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
+    //  则调整Hashtable的大小
+    if (count >= threshold) {
+        // Rehash the table if the threshold is exceeded
+        rehash();
+
+        tab = table;
+        index = (hash & 0x7FFFFFFF) % tab.length;
+    }
+
+    // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中
+    Entry<K,V> e = tab[index];
+    // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。        
+    tab[index] = new Entry<K,V>(hash, key, value, e);
+    // (05) 将“Hashtable的实际容量”+1
+    count++;
+    return null;
+}
+```
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253\357\274\214\344\270\244\350\200\205\345\222\214concurrenthashmap\347\232\204\345\214\272\345\210\253\343\200\202.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253\357\274\214\344\270\244\350\200\205\345\222\214concurrenthashmap\347\232\204\345\214\272\345\210\253\343\200\202.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253\357\274\214\344\270\244\350\200\205\345\222\214concurrenthashmap\347\232\204\345\214\272\345\210\253\343\200\202.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/hashmap\345\222\214hashtable\347\232\204\345\272\225\345\261\202\345\256\236\347\216\260\345\222\214\345\214\272\345\210\253\357\274\214\344\270\244\350\200\205\345\222\214concurrenthashmap\347\232\204\345\214\272\345\210\253\343\200\202.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/\344\273\216\346\272\220\347\240\201\345\210\206\346\236\220HashMap.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\344\273\216\346\272\220\347\240\201\345\210\206\346\236\220HashMap.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/\344\273\216\346\272\220\347\240\201\345\210\206\346\236\220HashMap.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\344\273\216\346\272\220\347\240\201\345\210\206\346\236\220HashMap.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/\346\240\210\345\222\214\351\230\237\344\275\277\347\224\250.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\346\240\210\345\222\214\351\230\237\344\275\277\347\224\250.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/\346\240\210\345\222\214\351\230\237\344\275\277\347\224\250.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\346\240\210\345\222\214\351\230\237\344\275\277\347\224\250.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/\351\233\206\345\220\210ArrayList\345\257\271\350\261\241\346\216\222\345\272\217.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\351\233\206\345\220\210ArrayList\345\257\271\350\261\241\346\216\222\345\272\217.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/\351\233\206\345\220\210ArrayList\345\257\271\350\261\241\346\216\222\345\272\217.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\351\233\206\345\220\210ArrayList\345\257\271\350\261\241\346\216\222\345\272\217.md"
diff --git "a/01 - JavaSE/03 - \351\233\206\345\220\210/\351\233\206\345\220\210\351\200\211\345\217\226.md" "b/01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\351\233\206\345\220\210\351\200\211\345\217\226.md"
similarity index 100%
rename from "01 - JavaSE/03 - \351\233\206\345\220\210/\351\233\206\345\220\210\351\200\211\345\217\226.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/03 - \351\233\206\345\220\210/\351\233\206\345\220\210\351\200\211\345\217\226.md"
diff --git "a/01 - JavaSE/04 - String\347\233\270\345\205\263/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/README.md"
similarity index 100%
rename from "01 - JavaSE/04 - String\347\233\270\345\205\263/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/README.md"
diff --git "a/01 - JavaSE/04 - String\347\233\270\345\205\263/String \344\270\215\345\217\257\345\217\230\347\232\204\345\216\237\345\233\240.md" "b/01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/String \344\270\215\345\217\257\345\217\230\347\232\204\345\216\237\345\233\240.md"
similarity index 100%
rename from "01 - JavaSE/04 - String\347\233\270\345\205\263/String \344\270\215\345\217\257\345\217\230\347\232\204\345\216\237\345\233\240.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/String \344\270\215\345\217\257\345\217\230\347\232\204\345\216\237\345\233\240.md"
diff --git "a/01 - JavaSE/04 - String\347\233\270\345\205\263/String, StringBuffer and StringBuilder.md" "b/01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/String, StringBuffer and StringBuilder.md"
similarity index 100%
rename from "01 - JavaSE/04 - String\347\233\270\345\205\263/String, StringBuffer and StringBuilder.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/String, StringBuffer and StringBuilder.md"
diff --git "a/01 - JavaSE/04 - String\347\233\270\345\205\263/String.intern().md" "b/01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/String.intern().md"
similarity index 100%
rename from "01 - JavaSE/04 - String\347\233\270\345\205\263/String.intern().md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/04 - String\347\233\270\345\205\263/String.intern().md"
diff --git "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/README.md"
similarity index 100%
rename from "01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/README.md"
diff --git "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/Transient\345\205\263\351\224\256\345\255\227.md" "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/Transient\345\205\263\351\224\256\345\255\227.md"
similarity index 100%
rename from "01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/Transient\345\205\263\351\224\256\345\255\227.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/Transient\345\205\263\351\224\256\345\255\227.md"
diff --git "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/Volatile\345\205\263\351\224\256\345\255\227.md" "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/Volatile\345\205\263\351\224\256\345\255\227.md"
similarity index 100%
rename from "01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/Volatile\345\205\263\351\224\256\345\255\227.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/Volatile\345\205\263\351\224\256\345\255\227.md"
diff --git "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/final.md" "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/final.md"
similarity index 100%
rename from "01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/final.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/final.md"
diff --git "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/static.md" "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/static.md"
similarity index 100%
rename from "01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/static.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/static.md"
diff --git "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/strictfp.md" "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/strictfp.md"
similarity index 99%
rename from "01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/strictfp.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/strictfp.md"
index 6c690e68..647096a8 100644
--- "a/01 - JavaSE/05 - \345\205\263\351\224\256\345\255\227/strictfp.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/05 - \345\205\263\351\224\256\345\255\227/strictfp.md"	
@@ -1,3 +1,3 @@
-### strictfp, 即 strict float point (精确浮点)。
-　　strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。
-　　如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.
+### strictfp, 即 strict float point (精确浮点)。
+　　strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。
+　　如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.
diff --git "a/01 - JavaSE/06 - \345\217\215\345\260\204/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/README.md"
similarity index 100%
rename from "01 - JavaSE/06 - \345\217\215\345\260\204/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/README.md"
diff --git "a/01 - JavaSE/06 - \345\217\215\345\260\204/all.md" "b/01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/all.md"
similarity index 100%
rename from "01 - JavaSE/06 - \345\217\215\345\260\204/all.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/all.md"
diff --git "a/01 - JavaSE/06 - \345\217\215\345\260\204/\345\217\215\345\260\204.md" "b/01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/\345\217\215\345\260\204.md"
similarity index 100%
rename from "01 - JavaSE/06 - \345\217\215\345\260\204/\345\217\215\345\260\204.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/\345\217\215\345\260\204.md"
diff --git "a/01 - JavaSE/06 - \345\217\215\345\260\204/\345\272\224\347\224\250.md" "b/01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/\345\272\224\347\224\250.md"
similarity index 94%
rename from "01 - JavaSE/06 - \345\217\215\345\260\204/\345\272\224\347\224\250.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/\345\272\224\347\224\250.md"
index 7c1cf277..4be86f85 100644
--- "a/01 - JavaSE/06 - \345\217\215\345\260\204/\345\272\224\347\224\250.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/06 - \345\217\215\345\260\204/\345\272\224\347\224\250.md"	
@@ -1,5 +1,5 @@
-类加载器（类加载的工具）
-
-Class.forName(classStr);  
-
-Spring IOC中的应用  
+类加载器（类加载的工具）
+
+Class.forName(classStr);  
+
+Spring IOC中的应用  
diff --git "a/01 - JavaSE/07 - \345\272\217\345\210\227\345\214\226/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/07 - \345\272\217\345\210\227\345\214\226/README.md"
similarity index 100%
rename from "01 - JavaSE/07 - \345\272\217\345\210\227\345\214\226/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/07 - \345\272\217\345\210\227\345\214\226/README.md"
diff --git "a/01 - JavaSE/08 - JMS/JMS01 -- JMS\345\237\272\347\241\200.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS01 -- JMS\345\237\272\347\241\200.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS01 -- JMS\345\237\272\347\241\200.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS01 -- JMS\345\237\272\347\241\200.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS02 -- \344\270\200\344\270\252JMS\344\276\213\345\255\220.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS02 -- \344\270\200\344\270\252JMS\344\276\213\345\255\220.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS02 -- \344\270\200\344\270\252JMS\344\276\213\345\255\220.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS02 -- \344\270\200\344\270\252JMS\344\276\213\345\255\220.txt"
diff --git a/01 - JavaSE/08 - JMS/JMS03 -- MessageListener.txt "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS03 -- MessageListener.txt"
similarity index 100%
rename from 01 - JavaSE/08 - JMS/JMS03 -- MessageListener.txt
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS03 -- MessageListener.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS04 -- \345\256\236\346\210\230Queue.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS04 -- \345\256\236\346\210\230Queue.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS04 -- \345\256\236\346\210\230Queue.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS04 -- \345\256\236\346\210\230Queue.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS05 -- \345\256\236\346\210\230Topic.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS05 -- \345\256\236\346\210\230Topic.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS05 -- \345\256\236\346\210\230Topic.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS05 -- \345\256\236\346\210\230Topic.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS06 -- \346\266\210\346\201\257\345\244\264.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS06 -- \346\266\210\346\201\257\345\244\264.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS06 -- \346\266\210\346\201\257\345\244\264.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS06 -- \346\266\210\346\201\257\345\244\264.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS07 -- DeliveryMode\344\276\213\345\255\220.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS07 -- DeliveryMode\344\276\213\345\255\220.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS07 -- DeliveryMode\344\276\213\345\255\220.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS07 -- DeliveryMode\344\276\213\345\255\220.txt"
diff --git a/01 - JavaSE/08 - JMS/JMS08 -- JMSReplyTo.txt "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS08 -- JMSReplyTo.txt"
similarity index 100%
rename from 01 - JavaSE/08 - JMS/JMS08 -- JMSReplyTo.txt
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS08 -- JMSReplyTo.txt"
diff --git a/01 - JavaSE/08 - JMS/JMS09 -- Selector.txt "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS09 -- Selector.txt"
similarity index 100%
rename from 01 - JavaSE/08 - JMS/JMS09 -- Selector.txt
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS09 -- Selector.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS10 -- JMSCorrelationID\344\270\216Selector.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS10 -- JMSCorrelationID\344\270\216Selector.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS10 -- JMSCorrelationID\344\270\216Selector.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS10 -- JMSCorrelationID\344\270\216Selector.txt"
diff --git "a/01 - JavaSE/08 - JMS/JMS11 -- TemporaryQueue\345\222\214TemporaryTopic.txt" "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS11 -- TemporaryQueue\345\222\214TemporaryTopic.txt"
similarity index 100%
rename from "01 - JavaSE/08 - JMS/JMS11 -- TemporaryQueue\345\222\214TemporaryTopic.txt"
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS11 -- TemporaryQueue\345\222\214TemporaryTopic.txt"
diff --git a/01 - JavaSE/08 - JMS/JMS12 -- MDB.txt "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS12 -- MDB.txt"
similarity index 100%
rename from 01 - JavaSE/08 - JMS/JMS12 -- MDB.txt
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/JMS12 -- MDB.txt"
diff --git a/01 - JavaSE/08 - JMS/README.md "b/01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/README.md"
similarity index 100%
rename from 01 - JavaSE/08 - JMS/README.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/08 - JMS/README.md"
diff --git "a/01 - JavaSE/09 - \346\263\233\345\236\213/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/09 - \346\263\233\345\236\213/README.md"
similarity index 100%
rename from "01 - JavaSE/09 - \346\263\233\345\236\213/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/09 - \346\263\233\345\236\213/README.md"
diff --git "a/01 - JavaSE/10 - \345\270\270\347\224\250Java\345\267\245\345\205\267\345\272\223/README.md" "b/01 - JavaSE Java\346\240\270\345\277\203/10 - \345\270\270\347\224\250Java\345\267\245\345\205\267\345\272\223/README.md"
similarity index 100%
rename from "01 - JavaSE/10 - \345\270\270\347\224\250Java\345\267\245\345\205\267\345\272\223/README.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/10 - \345\270\270\347\224\250Java\345\267\245\345\205\267\345\272\223/README.md"
diff --git a/01 - JavaSE/IO/IO.png "b/01 - JavaSE Java\346\240\270\345\277\203/IO/IO.png"
similarity index 100%
rename from 01 - JavaSE/IO/IO.png
rename to "01 - JavaSE Java\346\240\270\345\277\203/IO/IO.png"
diff --git a/01 - JavaSE/IO/JavaIO.md "b/01 - JavaSE Java\346\240\270\345\277\203/IO/JavaIO.md"
similarity index 97%
rename from 01 - JavaSE/IO/JavaIO.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/IO/JavaIO.md"
index 036ea1e1..b914cf05 100644
--- a/01 - JavaSE/IO/JavaIO.md	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/IO/JavaIO.md"	
@@ -1,468 +1,468 @@
-<!-- GFM-TOC -->
-* [一、概览](#一概览)
-* [二、磁盘操作](#二磁盘操作)
-* [三、字节操作](#三字节操作)
-* [四、字符操作](#四字符操作)
-* [五、对象操作](#五对象操作)
-* [六、网络操作](#六网络操作)
-    * [InetAddress](#inetaddress)
-    * [URL](#url)
-    * [Sockets](#sockets)
-    * [Datagram](#datagram)
-* [七、NIO](#七nio)
-    * [流与块](#流与块)
-    * [通道与缓冲区](#通道与缓冲区)
-    * [缓冲区状态变量](#缓冲区状态变量)
-    * [文件 NIO 实例](#文件-nio-实例)
-    * [选择器](#选择器)
-    * [套接字 NIO 实例](#套接字-nio-实例)
-    * [内存映射文件](#内存映射文件)
-    * [对比](#对比)
-* [八、参考资料](#八参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、概览
-
-Java 的 I/O 大概可以分成以下几类：
-
-1. 磁盘操作：`File`
-2. 字节操作：`InputStream` 和 `OutputStream`
-3. 字符操作：`Reader` 和 `Writer`
-4. 对象操作：`Serializable`
-5. 网络操作：`Socket`
-6. 新的输入/输出：`NIO`
-
-# 二、磁盘操作
-
-`File` 类可以用于表示文件和目录，但是它只用于表示文件的信息，而不表示文件的内容。
-
-# 三、字节操作
-
-<div align="center"> <img src="/image/01/io/DP-Decorator-java.io.png" width="500"/> </div><br>
-
-Java I/O 使用了`装饰者模式`来实现。以 `InputStream` 为例，InputStream 是`抽象组件`，`FileInputStream` 是 InputStream 的子类，属于`具体组件`，提供了字节流的输入操作。FilterInputStream 属于`抽象装饰者`，装饰者用于装饰组件，为组件提供额外的功能，例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
-
-`实例化一个具有缓存功能的字节流对象`时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
-
-```java
-BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
-```
-
-DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
-
-批量读入文件内容到字节数组：
-
-```java
-byte[] buf = new byte[20*1024];
-int bytes = 0;
-// 最多读取 buf.length 个字节，返回的是实际读取的个数，返回 -1 的时候表示读到 eof，即文件尾
-while((bytes = in.read(buf, 0 , buf.length)) != -1) {
-    // ...
-}
-```
-
-# 四、字符操作
-
-不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符，所以 I/O 操作的都是字节而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。
-
-`InputStreamReader` 实现从文本文件的字节流解码成字符流；`OutputStreamWriter `实现字符流编码成为文本文件的字节流。它们继承自 Reader 和 Writer。
-
-编码就是把字符转换为字节，而解码是把字节重新组合成字符。
-
-``` js
-byte[] bytes = str.getBytes(encoding);     // 编码
-String str = new String(bytes, encoding)； // 解码
-```
-
-如果编码和解码过程使用不同的编码方式那么就出现了乱码。
-
-- `GBK` 编码中，中文占 2 个字节，英文占 1 个字节；
-- `UTF-8` 编码中，中文占 3 个字节，英文占 1 个字节；
-- `UTF-16be` 编码中，中文和英文都占 2 个字节。
-
-UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
-
-Java 使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码正是为了让一个中文或者一个英文都能使用一个 char 来存储。
-
-# 五、对象操作
-
-序列化就是将一个对象转换成字节序列，方便存储和传输。
-
-序列化：ObjectOutputStream.writeObject()
-
-反序列化：ObjectInputStream.readObject()
-
-序列化的类需要实现 `Serializable 接口`，它只是一个标准，没有任何方法需要实现。
-
-`transient 关键字`可以使一些属性不会被序列化。
-
-**ArrayList 序列化和反序列化的实现** ：ArrayList 中存储数据的数组是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。
-
-```java
-private transient Object[] elementData;
-```
-
-# 六、网络操作
-
-Java 中的网络支持：
-
-1. `InetAddress`：用于表示网络上的硬件资源，即 IP 地址；
-2. `URL`：统一资源定位符，通过 URL 可以直接读取或者写入网络上的数据；
-3. `Sockets`：使用 TCP 协议实现网络通信；
-4. `Datagram`：使用 UDP 协议实现网络通信。
-
-## InetAddress
-
-没有公有构造函数，只能通过静态方法来创建实例。
-
-```java
-InetAddress.getByName(String host);
-InetAddress.getByAddress(byte[] addr);
-```
-
-## URL
-
-可以直接从 URL 中读取字节流数据
-
-```java
-URL url = new URL("http://www.baidu.com");
-InputStream is = url.openStream();                           // 字节流
-InputStreamReader isr = new InputStreamReader(is, "utf-8");  // 字符流
-BufferedReader br = new BufferedReader(isr);
-String line = br.readLine();
-while (line != null) {
-    System.out.println(line);
-    line = br.readLine();
-}
-br.close();
-isr.close();
-is.close();
-```
-
-## Sockets
-
-- `ServerSocket`：服务器端类
-- `Socket`：客户端类
-- 服务器和客户端通过 `InputStream` 和 `OutputStream` 进行输入输出。
-
-<div align="center"> <img src="/image/01/io/ClienteServidorSockets1521731145260.jpg"/> </div><br>
-
-## Datagram
-
-- DatagramPacket：数据包类
-- DatagramSocket：通信类
-
-# 七、NIO
-
-- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
-- [Java NIO 浅析](https://tech.meituan.com/nio.html)
-- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
-
-新的输入/输出 (`NIO`) 库是在 `JDK 1.4` 中引入的。NIO 弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
-
-## 流与块
-
-I/O 与 NIO 最重要的区别是数据打包和传输的方式，`I/O 以流的方式`处理数据，而 `NIO 以块的方式`处理数据。
-
-`面向流`的 I/O `一次处理一个字节数据`，一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器`非常容易`，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
-
-`面向块`的 I/O `一次处理一个数据块`，按块处理数据比按流处理数据要`快`得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
-
-I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.\* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
-
-## 通道与缓冲区
-
-### 1. 通道
-
-通道 `Channel` 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
-
-通道与流的不同之处在于，流只能在一个方向上移动，(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是`双向`的，可以用于`读`、`写`或者同时用于`读写`。
-
-通道包括以下类型：
-
-- `FileChannel`：从文件中读写数据；
-- `DatagramChannel`：通过 UDP 读写网络中数据；
-- `SocketChannel`：通过 TCP 读写网络中数据；
-- `ServerSocketChannel`：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
-
-### 2. 缓冲区
-
-发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。也就是说，不会直接对通道进行读写数据，而是要先经过缓冲区。
-
-缓冲区实质上是一个数组，但它不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。
-
-缓冲区包括以下类型：
-
-- `ByteBuffer`
-- `CharBuffer`
-- `ShortBuffer`
-- `IntBuffer`
-- `LongBuffer`
-- `FloatBuffer`
-- `DoubleBuffer`
-
-## 缓冲区状态变量
-
-- `capacity`：最大容量；
-- `position`：当前已经读写的字节数；
-- `limit`：还可以读写的字节数。
-
-状态变量的改变过程举例：
-
-① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
-
-<div align="center"> <img src="/image/01/io/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png"/> </div><br>
-
-② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 移动设置为 5，limit 保持不变。
-
-<div align="center"> <img src="/image/01/io/80804f52-8815-4096-b506-48eef3eed5c6.png"/> </div><br>
-
-③ 在将缓冲区的数据写到输出通道之前，需要先调用 `flip()` 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
-
-<div align="center"> <img src="/image/01/io/952e06bd-5a65-4cab-82e4-dd1536462f38.png"/> </div><br>
-
-④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
-
-<div align="center"> <img src="/image/01/io/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png"/> </div><br>
-
-⑤ 最后需要调用 `clear()` 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
-
-<div align="center"> <img src="/image/01/io/67bf5487-c45d-49b6-b9c0-a058d8c68902.png"/> </div><br>
-
-## 文件 NIO 实例
-
-以下展示了使用 NIO 快速复制文件的实例：
-
-```java
-public class FastCopyFile {
-    public static void main(String args[]) throws Exception {
-
-        String inFile = "data/abc.txt";
-        String outFile = "data/abc-copy.txt";
-
-        // 获得源文件的输入字节流
-        FileInputStream fin = new FileInputStream(inFile);
-        // 获取输入字节流的文件通道
-        FileChannel fcin = fin.getChannel();
-
-        // 获取目标文件的输出字节流
-        FileOutputStream fout = new FileOutputStream(outFile);
-        // 获取输出字节流的通道
-        FileChannel fcout = fout.getChannel();
-
-        // 为缓冲区分配 1024 个字节
-        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
-
-        while (true) {
-            // 从输入通道中读取数据到缓冲区中
-            int r = fcin.read(buffer);
-            // read() 返回 -1 表示 EOF
-            if (r == -1)
-                break;
-            // 切换读写
-            buffer.flip();
-            // 把缓冲区的内容写入输出文件中
-            fcout.write(buffer);
-            // 清空缓冲区
-            buffer.clear();
-        }
-    }
-}
-```
-
-## 选择器
-
-一个线程 Thread 使用一个选择器 `Selector` 通过轮询的方式去检查多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
-
-因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件具有更好的性能。
-
-<div align="center"> <img src="/image/01/io/4d930e22-f493-49ae-8dff-ea21cd6895dc.png"/> </div><br>
-
-### 1. 创建选择器
-
-```java
-Selector selector = Selector.open();
-```
-
-### 2. 将通道注册到选择器上
-
-```java
-ServerSocketChannel ssChannel = ServerSocketChannel.open();
-ssChannel.configureBlocking(false);
-ssChannel.register(selector, SelectionKey.OP_ACCEPT);
-```
-
-通道必须配置为``非阻塞模式``，否则使用选择器就没有任何意义了，因为如果通道在某个事件上被阻塞，那么服务器就不能响应其它时间，必须等待这个事件处理完毕才能去处理其它事件，显然这和选择器的作用背道而驰。
-
-在将通道注册到选择器上时，还需要指定要注册的具体事件，主要有以下几类：
-
-- SelectionKey.OP_CONNECT
-- SelectionKey.OP_ACCEPT
-- SelectionKey.OP_READ
-- SelectionKey.OP_WRITE
-
-它们在 SelectionKey 的定义如下：
-
-```java
-public static final int OP_READ = 1 << 0;
-public static final int OP_WRITE = 1 << 2;
-public static final int OP_CONNECT = 1 << 3;
-public static final int OP_ACCEPT = 1 << 4;
-```
-
-可以看出每个事件可以被当成一个位域，从而组成事件集整数。例如：
-
-```java
-int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
-```
-
-### 3. 监听事件
-
-```java
-int num = selector.select();
-```
-
-使用 select() 来监听事件到达，它会一直阻塞直到有至少一个事件到达。
-
-### 4. 获取到达的事件
-
-```java
-Set<SelectionKey> keys = selector.selectedKeys();
-Iterator<SelectionKey> keyIterator = keys.iterator();
-while (keyIterator.hasNext()) {
-    SelectionKey key = keyIterator.next();
-    if (key.isAcceptable()) {
-        // ...
-    } else if (key.isReadable()) {
-        // ...
-    }
-    keyIterator.remove();
-}
-```
-
-### 5. 事件循环
-
-因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
-
-```java
-while (true) {
-    int num = selector.select();
-    Set<SelectionKey> keys = selector.selectedKeys();
-    Iterator<SelectionKey> keyIterator = keys.iterator();
-    while (keyIterator.hasNext()) {
-        SelectionKey key = keyIterator.next();
-        if (key.isAcceptable()) {
-            // ...
-        } else if (key.isReadable()) {
-            // ...
-        }
-        keyIterator.remove();
-    }
-}
-```
-
-## 套接字 NIO 实例
-
-```java
-public class NIOServer {
-
-    public static void main(String[] args) throws IOException {
-        Selector selector = Selector.open();
-
-        ServerSocketChannel ssChannel = ServerSocketChannel.open();
-        ssChannel.configureBlocking(false);
-        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
-
-        ServerSocket serverSocket = ssChannel.socket();
-        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
-        serverSocket.bind(address);
-
-        while (true) {
-            selector.select();
-            Set<SelectionKey> keys = selector.selectedKeys();
-            Iterator<SelectionKey> keyIterator = keys.iterator();
-            while (keyIterator.hasNext()) {
-                SelectionKey key = keyIterator.next();
-                if (key.isAcceptable()) {
-                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
-                    // 服务器会为每个新连接创建一个 SocketChannel
-                    SocketChannel sChannel = ssChannel1.accept();
-                    sChannel.configureBlocking(false);
-                    // 这个新连接主要用于从客户端读取数据
-                    sChannel.register(selector, SelectionKey.OP_READ);
-                } else if (key.isReadable()) {
-                    SocketChannel sChannel = (SocketChannel) key.channel();
-                    System.out.println(readDataFromSocketChannel(sChannel));
-                    sChannel.close();
-                }
-                keyIterator.remove();
-            }
-        }
-    }
-
-    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
-        ByteBuffer buffer = ByteBuffer.allocate(1024);
-        StringBuffer data = new StringBuffer();
-        while (true) {
-            buffer.clear();
-            int n = sChannel.read(buffer);
-            if (n == -1)
-                break;
-            buffer.flip();
-            int limit = buffer.limit();
-            char[] dst = new char[limit];
-            for (int i = 0; i < limit; i++)
-                dst[i] = (char) buffer.get(i);
-            data.append(dst);
-            buffer.clear();
-        }
-        return data.toString();
-    }
-}
-```
-
-```java
-public class NIOClient {
-
-    public static void main(String[] args) throws IOException {
-        Socket socket = new Socket("127.0.0.1", 8888);
-        OutputStream out = socket.getOutputStream();
-        String s = "hello world";
-        out.write(s.getBytes());
-        out.close();
-    }
-}
-```
-
-## 内存映射文件
-
-内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
-
-只有文件中实际读取或者写入的部分才会映射到内存中。
-
-现代操作系统一般会根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制只不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。
-
-向内存映射文件写入可能是危险的，仅只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
-
-下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，您可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
-
-```java
-MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
-```
-
-## 对比
-
-NIO 与普通 I/O 的区别主要有以下两点：
-
-- NIO 是非阻塞的。应当注意，`FileChannel 不能切换到非阻塞模式`，`套接字 Channel 可以`。
-- NIO 面向块，I/O 面向流。
-
-# 八、参考资料
-
-- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
-- [深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
-- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
-- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
-- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+<!-- GFM-TOC -->
+* [一、概览](#一概览)
+* [二、磁盘操作](#二磁盘操作)
+* [三、字节操作](#三字节操作)
+* [四、字符操作](#四字符操作)
+* [五、对象操作](#五对象操作)
+* [六、网络操作](#六网络操作)
+    * [InetAddress](#inetaddress)
+    * [URL](#url)
+    * [Sockets](#sockets)
+    * [Datagram](#datagram)
+* [七、NIO](#七nio)
+    * [流与块](#流与块)
+    * [通道与缓冲区](#通道与缓冲区)
+    * [缓冲区状态变量](#缓冲区状态变量)
+    * [文件 NIO 实例](#文件-nio-实例)
+    * [选择器](#选择器)
+    * [套接字 NIO 实例](#套接字-nio-实例)
+    * [内存映射文件](#内存映射文件)
+    * [对比](#对比)
+* [八、参考资料](#八参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、概览
+
+Java 的 I/O 大概可以分成以下几类：
+
+1. 磁盘操作：`File`
+2. 字节操作：`InputStream` 和 `OutputStream`
+3. 字符操作：`Reader` 和 `Writer`
+4. 对象操作：`Serializable`
+5. 网络操作：`Socket`
+6. 新的输入/输出：`NIO`
+
+# 二、磁盘操作
+
+`File` 类可以用于表示文件和目录，但是它只用于表示文件的信息，而不表示文件的内容。
+
+# 三、字节操作
+
+<div align="center"> <img src="/image/01/io/DP-Decorator-java.io.png" width="500"/> </div><br>
+
+Java I/O 使用了`装饰者模式`来实现。以 `InputStream` 为例，InputStream 是`抽象组件`，`FileInputStream` 是 InputStream 的子类，属于`具体组件`，提供了字节流的输入操作。FilterInputStream 属于`抽象装饰者`，装饰者用于装饰组件，为组件提供额外的功能，例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
+
+`实例化一个具有缓存功能的字节流对象`时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
+
+```java
+BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
+```
+
+DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
+
+批量读入文件内容到字节数组：
+
+```java
+byte[] buf = new byte[20*1024];
+int bytes = 0;
+// 最多读取 buf.length 个字节，返回的是实际读取的个数，返回 -1 的时候表示读到 eof，即文件尾
+while((bytes = in.read(buf, 0 , buf.length)) != -1) {
+    // ...
+}
+```
+
+# 四、字符操作
+
+不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符，所以 I/O 操作的都是字节而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。
+
+`InputStreamReader` 实现从文本文件的字节流解码成字符流；`OutputStreamWriter `实现字符流编码成为文本文件的字节流。它们继承自 Reader 和 Writer。
+
+编码就是把字符转换为字节，而解码是把字节重新组合成字符。
+
+``` js
+byte[] bytes = str.getBytes(encoding);     // 编码
+String str = new String(bytes, encoding)； // 解码
+```
+
+如果编码和解码过程使用不同的编码方式那么就出现了乱码。
+
+- `GBK` 编码中，中文占 2 个字节，英文占 1 个字节；
+- `UTF-8` 编码中，中文占 3 个字节，英文占 1 个字节；
+- `UTF-16be` 编码中，中文和英文都占 2 个字节。
+
+UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
+
+Java 使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码正是为了让一个中文或者一个英文都能使用一个 char 来存储。
+
+# 五、对象操作
+
+序列化就是将一个对象转换成字节序列，方便存储和传输。
+
+序列化：ObjectOutputStream.writeObject()
+
+反序列化：ObjectInputStream.readObject()
+
+序列化的类需要实现 `Serializable 接口`，它只是一个标准，没有任何方法需要实现。
+
+`transient 关键字`可以使一些属性不会被序列化。
+
+**ArrayList 序列化和反序列化的实现** ：ArrayList 中存储数据的数组是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。
+
+```java
+private transient Object[] elementData;
+```
+
+# 六、网络操作
+
+Java 中的网络支持：
+
+1. `InetAddress`：用于表示网络上的硬件资源，即 IP 地址；
+2. `URL`：统一资源定位符，通过 URL 可以直接读取或者写入网络上的数据；
+3. `Sockets`：使用 TCP 协议实现网络通信；
+4. `Datagram`：使用 UDP 协议实现网络通信。
+
+## InetAddress
+
+没有公有构造函数，只能通过静态方法来创建实例。
+
+```java
+InetAddress.getByName(String host);
+InetAddress.getByAddress(byte[] addr);
+```
+
+## URL
+
+可以直接从 URL 中读取字节流数据
+
+```java
+URL url = new URL("http://www.baidu.com");
+InputStream is = url.openStream();                           // 字节流
+InputStreamReader isr = new InputStreamReader(is, "utf-8");  // 字符流
+BufferedReader br = new BufferedReader(isr);
+String line = br.readLine();
+while (line != null) {
+    System.out.println(line);
+    line = br.readLine();
+}
+br.close();
+isr.close();
+is.close();
+```
+
+## Sockets
+
+- `ServerSocket`：服务器端类
+- `Socket`：客户端类
+- 服务器和客户端通过 `InputStream` 和 `OutputStream` 进行输入输出。
+
+<div align="center"> <img src="/image/01/io/ClienteServidorSockets1521731145260.jpg"/> </div><br>
+
+## Datagram
+
+- DatagramPacket：数据包类
+- DatagramSocket：通信类
+
+# 七、NIO
+
+- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
+- [Java NIO 浅析](https://tech.meituan.com/nio.html)
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+
+新的输入/输出 (`NIO`) 库是在 `JDK 1.4` 中引入的。NIO 弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
+
+## 流与块
+
+I/O 与 NIO 最重要的区别是数据打包和传输的方式，`I/O 以流的方式`处理数据，而 `NIO 以块的方式`处理数据。
+
+`面向流`的 I/O `一次处理一个字节数据`，一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器`非常容易`，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
+
+`面向块`的 I/O `一次处理一个数据块`，按块处理数据比按流处理数据要`快`得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
+
+I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.\* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
+
+## 通道与缓冲区
+
+### 1. 通道
+
+通道 `Channel` 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
+
+通道与流的不同之处在于，流只能在一个方向上移动，(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是`双向`的，可以用于`读`、`写`或者同时用于`读写`。
+
+通道包括以下类型：
+
+- `FileChannel`：从文件中读写数据；
+- `DatagramChannel`：通过 UDP 读写网络中数据；
+- `SocketChannel`：通过 TCP 读写网络中数据；
+- `ServerSocketChannel`：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
+
+### 2. 缓冲区
+
+发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。也就是说，不会直接对通道进行读写数据，而是要先经过缓冲区。
+
+缓冲区实质上是一个数组，但它不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。
+
+缓冲区包括以下类型：
+
+- `ByteBuffer`
+- `CharBuffer`
+- `ShortBuffer`
+- `IntBuffer`
+- `LongBuffer`
+- `FloatBuffer`
+- `DoubleBuffer`
+
+## 缓冲区状态变量
+
+- `capacity`：最大容量；
+- `position`：当前已经读写的字节数；
+- `limit`：还可以读写的字节数。
+
+状态变量的改变过程举例：
+
+① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
+
+<div align="center"> <img src="/image/01/io/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png"/> </div><br>
+
+② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 移动设置为 5，limit 保持不变。
+
+<div align="center"> <img src="/image/01/io/80804f52-8815-4096-b506-48eef3eed5c6.png"/> </div><br>
+
+③ 在将缓冲区的数据写到输出通道之前，需要先调用 `flip()` 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
+
+<div align="center"> <img src="/image/01/io/952e06bd-5a65-4cab-82e4-dd1536462f38.png"/> </div><br>
+
+④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
+
+<div align="center"> <img src="/image/01/io/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png"/> </div><br>
+
+⑤ 最后需要调用 `clear()` 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
+
+<div align="center"> <img src="/image/01/io/67bf5487-c45d-49b6-b9c0-a058d8c68902.png"/> </div><br>
+
+## 文件 NIO 实例
+
+以下展示了使用 NIO 快速复制文件的实例：
+
+```java
+public class FastCopyFile {
+    public static void main(String args[]) throws Exception {
+
+        String inFile = "data/abc.txt";
+        String outFile = "data/abc-copy.txt";
+
+        // 获得源文件的输入字节流
+        FileInputStream fin = new FileInputStream(inFile);
+        // 获取输入字节流的文件通道
+        FileChannel fcin = fin.getChannel();
+
+        // 获取目标文件的输出字节流
+        FileOutputStream fout = new FileOutputStream(outFile);
+        // 获取输出字节流的通道
+        FileChannel fcout = fout.getChannel();
+
+        // 为缓冲区分配 1024 个字节
+        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
+
+        while (true) {
+            // 从输入通道中读取数据到缓冲区中
+            int r = fcin.read(buffer);
+            // read() 返回 -1 表示 EOF
+            if (r == -1)
+                break;
+            // 切换读写
+            buffer.flip();
+            // 把缓冲区的内容写入输出文件中
+            fcout.write(buffer);
+            // 清空缓冲区
+            buffer.clear();
+        }
+    }
+}
+```
+
+## 选择器
+
+一个线程 Thread 使用一个选择器 `Selector` 通过轮询的方式去检查多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
+
+因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件具有更好的性能。
+
+<div align="center"> <img src="/image/01/io/4d930e22-f493-49ae-8dff-ea21cd6895dc.png"/> </div><br>
+
+### 1. 创建选择器
+
+```java
+Selector selector = Selector.open();
+```
+
+### 2. 将通道注册到选择器上
+
+```java
+ServerSocketChannel ssChannel = ServerSocketChannel.open();
+ssChannel.configureBlocking(false);
+ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+```
+
+通道必须配置为``非阻塞模式``，否则使用选择器就没有任何意义了，因为如果通道在某个事件上被阻塞，那么服务器就不能响应其它时间，必须等待这个事件处理完毕才能去处理其它事件，显然这和选择器的作用背道而驰。
+
+在将通道注册到选择器上时，还需要指定要注册的具体事件，主要有以下几类：
+
+- SelectionKey.OP_CONNECT
+- SelectionKey.OP_ACCEPT
+- SelectionKey.OP_READ
+- SelectionKey.OP_WRITE
+
+它们在 SelectionKey 的定义如下：
+
+```java
+public static final int OP_READ = 1 << 0;
+public static final int OP_WRITE = 1 << 2;
+public static final int OP_CONNECT = 1 << 3;
+public static final int OP_ACCEPT = 1 << 4;
+```
+
+可以看出每个事件可以被当成一个位域，从而组成事件集整数。例如：
+
+```java
+int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
+```
+
+### 3. 监听事件
+
+```java
+int num = selector.select();
+```
+
+使用 select() 来监听事件到达，它会一直阻塞直到有至少一个事件到达。
+
+### 4. 获取到达的事件
+
+```java
+Set<SelectionKey> keys = selector.selectedKeys();
+Iterator<SelectionKey> keyIterator = keys.iterator();
+while (keyIterator.hasNext()) {
+    SelectionKey key = keyIterator.next();
+    if (key.isAcceptable()) {
+        // ...
+    } else if (key.isReadable()) {
+        // ...
+    }
+    keyIterator.remove();
+}
+```
+
+### 5. 事件循环
+
+因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
+
+```java
+while (true) {
+    int num = selector.select();
+    Set<SelectionKey> keys = selector.selectedKeys();
+    Iterator<SelectionKey> keyIterator = keys.iterator();
+    while (keyIterator.hasNext()) {
+        SelectionKey key = keyIterator.next();
+        if (key.isAcceptable()) {
+            // ...
+        } else if (key.isReadable()) {
+            // ...
+        }
+        keyIterator.remove();
+    }
+}
+```
+
+## 套接字 NIO 实例
+
+```java
+public class NIOServer {
+
+    public static void main(String[] args) throws IOException {
+        Selector selector = Selector.open();
+
+        ServerSocketChannel ssChannel = ServerSocketChannel.open();
+        ssChannel.configureBlocking(false);
+        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+
+        ServerSocket serverSocket = ssChannel.socket();
+        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
+        serverSocket.bind(address);
+
+        while (true) {
+            selector.select();
+            Set<SelectionKey> keys = selector.selectedKeys();
+            Iterator<SelectionKey> keyIterator = keys.iterator();
+            while (keyIterator.hasNext()) {
+                SelectionKey key = keyIterator.next();
+                if (key.isAcceptable()) {
+                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
+                    // 服务器会为每个新连接创建一个 SocketChannel
+                    SocketChannel sChannel = ssChannel1.accept();
+                    sChannel.configureBlocking(false);
+                    // 这个新连接主要用于从客户端读取数据
+                    sChannel.register(selector, SelectionKey.OP_READ);
+                } else if (key.isReadable()) {
+                    SocketChannel sChannel = (SocketChannel) key.channel();
+                    System.out.println(readDataFromSocketChannel(sChannel));
+                    sChannel.close();
+                }
+                keyIterator.remove();
+            }
+        }
+    }
+
+    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+        StringBuffer data = new StringBuffer();
+        while (true) {
+            buffer.clear();
+            int n = sChannel.read(buffer);
+            if (n == -1)
+                break;
+            buffer.flip();
+            int limit = buffer.limit();
+            char[] dst = new char[limit];
+            for (int i = 0; i < limit; i++)
+                dst[i] = (char) buffer.get(i);
+            data.append(dst);
+            buffer.clear();
+        }
+        return data.toString();
+    }
+}
+```
+
+```java
+public class NIOClient {
+
+    public static void main(String[] args) throws IOException {
+        Socket socket = new Socket("127.0.0.1", 8888);
+        OutputStream out = socket.getOutputStream();
+        String s = "hello world";
+        out.write(s.getBytes());
+        out.close();
+    }
+}
+```
+
+## 内存映射文件
+
+内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
+
+只有文件中实际读取或者写入的部分才会映射到内存中。
+
+现代操作系统一般会根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制只不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。
+
+向内存映射文件写入可能是危险的，仅只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
+
+下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，您可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
+
+```java
+MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
+```
+
+## 对比
+
+NIO 与普通 I/O 的区别主要有以下两点：
+
+- NIO 是非阻塞的。应当注意，`FileChannel 不能切换到非阻塞模式`，`套接字 Channel 可以`。
+- NIO 面向块，I/O 面向流。
+
+# 八、参考资料
+
+- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+- [深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
+- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
+- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
+- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
diff --git a/01 - JavaSE/IO/all.md "b/01 - JavaSE Java\346\240\270\345\277\203/IO/all.md"
similarity index 96%
rename from 01 - JavaSE/IO/all.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/IO/all.md"
index 53462190..cbc99bfe 100644
--- a/01 - JavaSE/IO/all.md	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/IO/all.md"	
@@ -1,38 +1,38 @@
-### 1. 文件对象
-File
-RandomAccessFile
-  特点：智能操作文件,实例化时如果不存在,则会自动创建
-  场景：构建多线程下载器
-### 2. 输入流
-### 3. 输出流
-### 4. 序列化
-  对象转为字节序列的过程
-  ObjectOutputStream代表对象输出流
-  默认序列化Serialzable
-  自定义序列化Externalizable
-    writeObject
-    readObject
-
-  serialVersionUID
-### 5. 反序列化
-  字节序列转为对象的过程
-  ObjectInputStream代表对象输入流
-
-### NIO
-  **NIO简介:**
-  Java NIO 是 java 1.4, 之后新出的一套IO接口NIO中的N可以理解为Non-blocking，不单纯是New。
-
-  **NIO的特性/NIO与IO区别:**
-  1)IO是面向流的，NIO是面向缓冲区的；
-  2)IO流是阻塞的，NIO流是不阻塞的;
-  3)NIO有选择器，而IO没有。
-
-  **读数据和写数据方式:**
-
-  从通道进行数据读取 ：创建一个缓冲区，然后请求通道读取数据。
-  从通道进行数据写入 ：创建一个缓冲区，填充数据，并要求通道写入数据。
-
-  **NIO核心组件简单介绍**
-  Channels
-  Buffers
-  Selectors
+### 1. 文件对象
+File
+RandomAccessFile
+  特点：智能操作文件,实例化时如果不存在,则会自动创建
+  场景：构建多线程下载器
+### 2. 输入流
+### 3. 输出流
+### 4. 序列化
+  对象转为字节序列的过程
+  ObjectOutputStream代表对象输出流
+  默认序列化Serialzable
+  自定义序列化Externalizable
+    writeObject
+    readObject
+
+  serialVersionUID
+### 5. 反序列化
+  字节序列转为对象的过程
+  ObjectInputStream代表对象输入流
+
+### NIO
+  **NIO简介:**
+  Java NIO 是 java 1.4, 之后新出的一套IO接口NIO中的N可以理解为Non-blocking，不单纯是New。
+
+  **NIO的特性/NIO与IO区别:**
+  1)IO是面向流的，NIO是面向缓冲区的；
+  2)IO流是阻塞的，NIO流是不阻塞的;
+  3)NIO有选择器，而IO没有。
+
+  **读数据和写数据方式:**
+
+  从通道进行数据读取 ：创建一个缓冲区，然后请求通道读取数据。
+  从通道进行数据写入 ：创建一个缓冲区，填充数据，并要求通道写入数据。
+
+  **NIO核心组件简单介绍**
+  Channels
+  Buffers
+  Selectors
diff --git a/01 - JavaSE/IO/io.md "b/01 - JavaSE Java\346\240\270\345\277\203/IO/io.md"
similarity index 100%
rename from 01 - JavaSE/IO/io.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/IO/io.md"
diff --git "a/01 - JavaSE/IO/\346\223\215\344\275\234\345\257\271\350\261\241\345\210\206\347\261\273.jpg" "b/01 - JavaSE Java\346\240\270\345\277\203/IO/\346\223\215\344\275\234\345\257\271\350\261\241\345\210\206\347\261\273.jpg"
similarity index 100%
rename from "01 - JavaSE/IO/\346\223\215\344\275\234\345\257\271\350\261\241\345\210\206\347\261\273.jpg"
rename to "01 - JavaSE Java\346\240\270\345\277\203/IO/\346\223\215\344\275\234\345\257\271\350\261\241\345\210\206\347\261\273.jpg"
diff --git "a/01 - JavaSE/IO/\346\223\215\344\275\234\346\226\271\345\274\217\345\210\206\347\261\273.jpg" "b/01 - JavaSE Java\346\240\270\345\277\203/IO/\346\223\215\344\275\234\346\226\271\345\274\217\345\210\206\347\261\273.jpg"
similarity index 100%
rename from "01 - JavaSE/IO/\346\223\215\344\275\234\346\226\271\345\274\217\345\210\206\347\261\273.jpg"
rename to "01 - JavaSE Java\346\240\270\345\277\203/IO/\346\223\215\344\275\234\346\226\271\345\274\217\345\210\206\347\261\273.jpg"
diff --git "a/01 - JavaSE/JavaSE/Java\344\270\255\347\232\204\345\206\205\345\255\230\346\263\204\346\274\217.md" "b/01 - JavaSE Java\346\240\270\345\277\203/JavaSE/Java\344\270\255\347\232\204\345\206\205\345\255\230\346\263\204\346\274\217.md"
similarity index 100%
rename from "01 - JavaSE/JavaSE/Java\344\270\255\347\232\204\345\206\205\345\255\230\346\263\204\346\274\217.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/JavaSE/Java\344\270\255\347\232\204\345\206\205\345\255\230\346\263\204\346\274\217.md"
diff --git "a/01 - JavaSE/JavaSE/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/01 - JavaSE Java\346\240\270\345\277\203/JavaSE/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
similarity index 100%
rename from "01 - JavaSE/JavaSE/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/JavaSE/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
diff --git "a/01 - JavaSE/JavaSE/String\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/JavaSE/String\346\272\220\347\240\201\345\210\206\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/JavaSE/String\346\272\220\347\240\201\345\210\206\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/JavaSE/String\346\272\220\347\240\201\345\210\206\346\236\220.md"
diff --git "a/01 - JavaSE/JavaSE/Vector\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/JavaSE/Vector\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 100%
rename from "01 - JavaSE/JavaSE/Vector\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/JavaSE/Vector\346\272\220\347\240\201\345\211\226\346\236\220.md"
diff --git "a/01 - JavaSE/JavaSE/\345\217\215\345\260\204\346\234\272\345\210\266.md" "b/01 - JavaSE Java\346\240\270\345\277\203/JavaSE/\345\217\215\345\260\204\346\234\272\345\210\266.md"
similarity index 100%
rename from "01 - JavaSE/JavaSE/\345\217\215\345\260\204\346\234\272\345\210\266.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/JavaSE/\345\217\215\345\260\204\346\234\272\345\210\266.md"
diff --git "a/01 - JavaSE/JavaSE/\345\246\202\344\275\225\350\241\250\350\276\276\345\207\272Collection\345\217\212\345\205\266\345\255\220\347\261\273.md" "b/01 - JavaSE Java\346\240\270\345\277\203/JavaSE/\345\246\202\344\275\225\350\241\250\350\276\276\345\207\272Collection\345\217\212\345\205\266\345\255\220\347\261\273.md"
similarity index 100%
rename from "01 - JavaSE/JavaSE/\345\246\202\344\275\225\350\241\250\350\276\276\345\207\272Collection\345\217\212\345\205\266\345\255\220\347\261\273.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/JavaSE/\345\246\202\344\275\225\350\241\250\350\276\276\345\207\272Collection\345\217\212\345\205\266\345\255\220\347\261\273.md"
diff --git "a/01 - JavaSE/Java\344\270\255Comparable\345\222\214Comparator\346\257\224\350\276\203.md" "b/01 - JavaSE Java\346\240\270\345\277\203/Java\344\270\255Comparable\345\222\214Comparator\346\257\224\350\276\203.md"
similarity index 100%
rename from "01 - JavaSE/Java\344\270\255Comparable\345\222\214Comparator\346\257\224\350\276\203.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/Java\344\270\255Comparable\345\222\214Comparator\346\257\224\350\276\203.md"
diff --git "a/01 - JavaSE/Java\351\235\242\350\257\225\347\273\217\345\205\270\351\242\230\347\233\256\351\233\206\345\220\210-nowcoder.md" "b/01 - JavaSE Java\346\240\270\345\277\203/Java\351\235\242\350\257\225\347\273\217\345\205\270\351\242\230\347\233\256\351\233\206\345\220\210-nowcoder.md"
similarity index 100%
rename from "01 - JavaSE/Java\351\235\242\350\257\225\347\273\217\345\205\270\351\242\230\347\233\256\351\233\206\345\220\210-nowcoder.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/Java\351\235\242\350\257\225\347\273\217\345\205\270\351\242\230\347\233\256\351\233\206\345\220\210-nowcoder.md"
diff --git a/01 - JavaSE/Lambda.md "b/01 - JavaSE Java\346\240\270\345\277\203/Lambda.md"
similarity index 100%
rename from 01 - JavaSE/Lambda.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/Lambda.md"
diff --git a/01 - JavaSE/README.md "b/01 - JavaSE Java\346\240\270\345\277\203/README.md"
similarity index 100%
rename from 01 - JavaSE/README.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/README.md"
diff --git a/01 - JavaSE/base.md "b/01 - JavaSE Java\346\240\270\345\277\203/base.md"
similarity index 100%
rename from 01 - JavaSE/base.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/base.md"
diff --git a/01 - JavaSE/cai.txt "b/01 - JavaSE Java\346\240\270\345\277\203/cai.txt"
similarity index 99%
rename from 01 - JavaSE/cai.txt
rename to "01 - JavaSE Java\346\240\270\345\277\203/cai.txt"
index c43a57e6..b7e08e62 100644
--- a/01 - JavaSE/cai.txt	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/cai.txt"	
@@ -1,21 +1,21 @@
-
-synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，
-	能够保证在同一时刻最多只有一个线程执行该段代码。synchronized就是针对内存区块申请内存锁。 
-	
-（1）JAVA中的Object类型都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。//所以叫做内存锁 
-（2）this关键字代表类的一个对象，所以其内存锁是针对相同对象的互斥操作，而static成员属于类专有，其内存空间为该类所有成员共有，
-	这就导致synchronized()对static成员加锁，相当于对类加锁，也就是在该类的所有成员间实现互斥，在同一时间只有一个线程可访问该类的实例。
-
-在使用wait和notify的时候必须注意：
-	Obj.wait()与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait与notify是针对已经获取了Obj锁的对象来进行操作。
-	也就是调用wait或者notify方法都必须先获取该对象的锁，不然报错，所以这个两个方法必须放在synchronized封装体体中
-	
-（1）Obj.wait()、Obj.notify必须在synchronized(Obj){…}语句块内。 
-（2）wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。
-	相应的notify()就是对对象锁的唤醒操作。 
-（3）notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，
-	赋予其对象锁，唤醒线程，继续执行。如果是notifyAll()就会释放所有的锁。
-
-注意1：如果notify的对象没有wait，会报IllegalMonitorStateException错误
-注意2：Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
-
+
+synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，
+	能够保证在同一时刻最多只有一个线程执行该段代码。synchronized就是针对内存区块申请内存锁。 
+	
+（1）JAVA中的Object类型都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。//所以叫做内存锁 
+（2）this关键字代表类的一个对象，所以其内存锁是针对相同对象的互斥操作，而static成员属于类专有，其内存空间为该类所有成员共有，
+	这就导致synchronized()对static成员加锁，相当于对类加锁，也就是在该类的所有成员间实现互斥，在同一时间只有一个线程可访问该类的实例。
+
+在使用wait和notify的时候必须注意：
+	Obj.wait()与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait与notify是针对已经获取了Obj锁的对象来进行操作。
+	也就是调用wait或者notify方法都必须先获取该对象的锁，不然报错，所以这个两个方法必须放在synchronized封装体体中
+	
+（1）Obj.wait()、Obj.notify必须在synchronized(Obj){…}语句块内。 
+（2）wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。
+	相应的notify()就是对对象锁的唤醒操作。 
+（3）notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，
+	赋予其对象锁，唤醒线程，继续执行。如果是notifyAll()就会释放所有的锁。
+
+注意1：如果notify的对象没有wait，会报IllegalMonitorStateException错误
+注意2：Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
+
diff --git a/01 - JavaSE/core.md "b/01 - JavaSE Java\346\240\270\345\277\203/core.md"
similarity index 100%
rename from 01 - JavaSE/core.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/core.md"
diff --git "a/01 - JavaSE/from \351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/from \351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.md"
similarity index 100%
rename from "01 - JavaSE/from \351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/from \351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/1.png" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/1.png"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/1.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/1.png"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\237\272\346\234\254\347\250\213\345\272\217\350\256\276\350\256\241\347\273\223\346\236\204.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\237\272\346\234\254\347\250\213\345\272\217\350\256\276\350\256\241\347\273\223\346\236\204.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\237\272\346\234\254\347\250\213\345\272\217\350\256\276\350\256\241\347\273\223\346\236\204.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\237\272\346\234\254\347\250\213\345\272\217\350\256\276\350\256\241\347\273\223\346\236\204.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\232\347\272\277\347\250\213.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\232\347\272\277\347\250\213.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\232\347\272\277\347\250\213.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\232\347\272\277\347\250\213.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\247\346\225\260\345\200\274.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\247\346\225\260\345\200\274.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\247\346\225\260\345\200\274.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\244\247\346\225\260\345\200\274.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\255\227\347\254\246\344\270\262.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\255\227\347\254\246\344\270\262.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\255\227\347\254\246\344\270\262.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\255\227\347\254\246\344\270\262.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\257\271\350\261\241\344\270\216\347\261\273.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\257\271\350\261\241\344\270\216\347\261\273.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\257\271\350\261\241\344\270\216\347\261\273.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\257\271\350\261\241\344\270\216\347\261\273.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\274\202\345\270\270\343\200\201\346\226\255\350\250\200\343\200\201\346\227\245\345\277\227\343\200\201\350\260\203\350\257\225.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\274\202\345\270\270\343\200\201\346\226\255\350\250\200\343\200\201\346\227\245\345\277\227\343\200\201\350\260\203\350\257\225.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\274\202\345\270\270\343\200\201\346\226\255\350\250\200\343\200\201\346\227\245\345\277\227\343\200\201\350\260\203\350\257\225.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\345\274\202\345\270\270\343\200\201\346\226\255\350\250\200\343\200\201\346\227\245\345\277\227\343\200\201\350\260\203\350\257\225.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\245\345\217\243\344\270\216\345\206\205\351\203\250\347\261\273.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\245\345\217\243\344\270\216\345\206\205\351\203\250\347\261\273.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\245\345\217\243\344\270\216\345\206\205\351\203\250\347\261\273.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\245\345\217\243\344\270\216\345\206\205\351\203\250\347\261\273.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\247\345\210\266\346\265\201\347\250\213.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\247\345\210\266\346\265\201\347\250\213.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\247\345\210\266\346\265\201\347\250\213.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\216\247\345\210\266\346\265\201\347\250\213.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\225\260\347\273\204.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\225\260\347\273\204.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\225\260\347\273\204.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\225\260\347\273\204.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\263\233\345\236\213\347\250\213\345\272\217\350\256\276\350\256\241.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\263\233\345\236\213\347\250\213\345\272\217\350\256\276\350\256\241.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\263\233\345\236\213\347\250\213\345\272\217\350\256\276\350\256\241.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\346\263\233\345\236\213\347\250\213\345\272\217\350\256\276\350\256\241.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\350\276\223\345\205\245\350\276\223\345\207\272.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\350\276\223\345\205\245\350\276\223\345\207\272.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\350\276\223\345\205\245\350\276\223\345\207\272.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\350\276\223\345\205\245\350\276\223\345\207\272.md"
diff --git "a/01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\351\203\250\347\275\262\345\272\224\347\224\250\347\250\213\345\272\217.md" "b/01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\351\203\250\347\275\262\345\272\224\347\224\250\347\250\213\345\272\217.md"
similarity index 100%
rename from "01 - JavaSE/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\351\203\250\347\275\262\345\272\224\347\224\250\347\250\213\345\272\217.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/java\346\240\270\345\277\203\345\215\267I\345\255\246\344\271\240\347\254\224\350\256\260/\351\203\250\347\275\262\345\272\224\347\224\250\347\250\213\345\272\217.md"
diff --git a/01 - JavaSE/nowcode java.md "b/01 - JavaSE Java\346\240\270\345\277\203/nowcode java.md"
similarity index 100%
rename from 01 - JavaSE/nowcode java.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/nowcode java.md"
diff --git a/01 - JavaSE/object.md "b/01 - JavaSE Java\346\240\270\345\277\203/object.md"
similarity index 100%
rename from 01 - JavaSE/object.md
rename to "01 - JavaSE Java\346\240\270\345\277\203/object.md"
diff --git "a/01 - JavaSE/\344\277\256\351\245\260\347\254\246.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\344\277\256\351\245\260\347\254\246.md"
similarity index 100%
rename from "01 - JavaSE/\344\277\256\351\245\260\347\254\246.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\344\277\256\351\245\260\347\254\246.md"
diff --git "a/01 - JavaSE/\345\206\205\345\255\230\346\263\204\346\274\217.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\345\206\205\345\255\230\346\263\204\346\274\217.md"
similarity index 100%
rename from "01 - JavaSE/\345\206\205\345\255\230\346\263\204\346\274\217.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\345\206\205\345\255\230\346\263\204\346\274\217.md"
diff --git "a/01 - JavaSE/\345\274\202\345\270\270 throwable(Error&Exception)/all.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\345\274\202\345\270\270 throwable(Error&Exception)/all.md"
similarity index 100%
rename from "01 - JavaSE/\345\274\202\345\270\270 throwable(Error&Exception)/all.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\345\274\202\345\270\270 throwable(Error&Exception)/all.md"
diff --git "a/01 - JavaSE/\345\274\202\345\270\270 throwable(Error&Exception)/throwable.png" "b/01 - JavaSE Java\346\240\270\345\277\203/\345\274\202\345\270\270 throwable(Error&Exception)/throwable.png"
similarity index 100%
rename from "01 - JavaSE/\345\274\202\345\270\270 throwable(Error&Exception)/throwable.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\345\274\202\345\270\270 throwable(Error&Exception)/throwable.png"
diff --git "a/01 - JavaSE/\345\274\202\345\270\270 throwable(Error&Exception)/\345\274\202\345\270\270\345\210\206\347\261\273.png" "b/01 - JavaSE Java\346\240\270\345\277\203/\345\274\202\345\270\270 throwable(Error&Exception)/\345\274\202\345\270\270\345\210\206\347\261\273.png"
similarity index 100%
rename from "01 - JavaSE/\345\274\202\345\270\270 throwable(Error&Exception)/\345\274\202\345\270\270\345\210\206\347\261\273.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\345\274\202\345\270\270 throwable(Error&Exception)/\345\274\202\345\270\270\345\210\206\347\261\273.png"
diff --git "a/01 - JavaSE/\346\230\223\351\224\231\347\202\271.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\346\230\223\351\224\231\347\202\271.md"
similarity index 100%
rename from "01 - JavaSE/\346\230\223\351\224\231\347\202\271.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\346\230\223\351\224\231\347\202\271.md"
diff --git "a/01 - JavaSE/\346\263\250\350\247\243/readme.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\346\263\250\350\247\243/readme.md"
similarity index 100%
rename from "01 - JavaSE/\346\263\250\350\247\243/readme.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\346\263\250\350\247\243/readme.md"
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/super.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/super.md"
similarity index 100%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/super.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/super.md"
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\345\206\205\351\203\250\347\261\273.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\345\206\205\351\203\250\347\261\273.md"
similarity index 97%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\345\206\205\351\203\250\347\261\273.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\345\206\205\351\203\250\347\261\273.md"
index 05c90656..a08391e4 100644
--- "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\345\206\205\351\203\250\347\261\273.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\345\206\205\351\203\250\347\261\273.md"	
@@ -1,192 +1,192 @@
-### 1. 静态嵌套类(Static Nested Classes)
-```java
-class Outer {
-	static class Inner {
-		void go() {
-			System.out.println("Inner class reference is: " + this);
-		}
-	}
-}
-
-public class Test {
-	public static void main(String[] args) {
-		Outer.Inner n = new Outer.Inner();
-		n.go();
-	}
-}
-```
-输出：Inner class reference is: Outer$Inner@19e7ce87
-
-### 2.成员内部类(Member Inner Class)
-成员类是特定于实例的。它可以访问所有方法，字段和外部类本身的引用。
-```java
-public class Outer {
-    private int x = 100;
-    public void makeInner(){
-        Inner in = new Inner();
-        in.seeOuter();
-    }
-    class Inner{
-        public void seeOuter(){
-            System.out.println("Outer x is " + x);
-            System.out.println("Inner class reference is " + this);
-            System.out.println("Outer class reference is " + Outer.this);
-        }
-    }
-    public static void main(String [] args){
-    		Outer o = new Outer();
-        Inner i = o.new Inner();
-        i.seeOuter();
-    }
-}
-```
-输出：
-Outer x is 100
-Inner class reference is Outer$Inner@4dfd9726
-Outer class reference is Outer@43ce67ca
-
-### 3.局部方法内部类(Method-Local Inner Classes
-```java
-public class Outer {
-	private String x = "outer";
-
-	public void doStuff() {
-		class MyInner {
-			public void seeOuter() {
-				System.out.println("x is " + x);
-			}
-		}
-
-		MyInner i = new MyInner();
-		i.seeOuter();
-	}
-
-	public static void main(String[] args) {
-		Outer o = new Outer();
-		o.doStuff();
-	}
-}
-```
-输出：x is outer
-```java
-public class Outer {
-	private static String x = "static outer";
-
-	public static void doStuff() {
-		class MyInner {
-			public void seeOuter() {
-				System.out.println("x is " + x);
-			}
-		}
-
-		MyInner i = new MyInner();
-		i.seeOuter();
-	}
-
-	public static void main(String[] args) {
-		Outer.doStuff();
-	}
-}
-```
-输出：x is static outer
-### 4.匿名内部类(Anonymous Inner Classes)
-当您需要给一个GUI应用程序窗口小部件加一个动作监听器时，匿名内部类就会经常被用到。
-```java
-button.addActionListener(new ActionListener(){
-     public void actionPerformed(ActionEvent e){
-         comp.setText("Button has been clicked");
-     }
-});
-```
-
-
-####
-在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
-广泛意义上的内部类一般来说包括这三种：成员内部类（静态内部类、非静态内部类）、局部内部类、匿名内部类，
-
-使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
-
-接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
-
-```java
-public class InnerClassTest {
-	public static void main(String[] args) {
-		/*
-		 * 创建静态内部类对象的一般形式为：  外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
-		 * 创建成员内部类对象的一般形式为：  外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
-		 */
-		// 初始化Bean1
-		InnerClassTest t = new InnerClassTest();
-		InnerClassTest.Bean1 b1 = t.new Bean1();
-		b1.I++;
-		// 初始化Bean2
-		InnerClassTest.Bean2 b2 = new InnerClassTest.Bean2();
-		b2.J++;
-		// 初始化Bean3
-		Bean b = new Bean();
-		Bean.Bean3 b3 = b.new Bean3();
-		b3.k++;
-	}
-	class Bean1 {
-		public int I = 0;
-	}
-	static class Bean2 {
-		public int J = 0;
-	}
-
-}
-class Bean {
-	class Bean3 {
-		public int k = 0;
-	}
-}
-```
-创建静态内部类对象的一般形式为：  **外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()**
-
-创建成员内部类对象的一般形式为：  **外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()**
-
-
-###  变量
-
-```java
-/要求：使用已知的变量，在控制台输出30，20，10。
-　class Outer {
-    public int num = 10;
-    class Inner {
-        public int num = 20;
-        public void show() {
-            int num = 30;
-            System.out.println(?);
-            System.out.println(??);
-            System.out.println(???);
-        }
-    }
-}
-
-class InnerClassTest {
-    public static void main(String[] args) {
-        Outer.Inner oi = new Outer().new Inner();
-        oi.show();
-    }    
-}
-```
-1、局部变量 2、this，和3、Outer.this，也就是内部类访问外部类属性方法的原理。这考察三个东西，
-
-1、在一个方法中，使用直接使用变量名，肯定使用的是局部变量，因为会把大的成员变量给隐藏掉，这题中，也就是说show方法中的num会将内部类中的成员变量num隐藏掉，而内部类中的成员变量num又会把外部类中的成员变量num隐藏掉，所以通过直接输出num，会是show方法中的局部变量的值30.   
-
-2、使用this.num调用，其this代表的是调用该方法的对象，调用show方法的是oi，oi也就是内部类对象，所以oi.num也就标识内部类的成员变量num的值20
-
-3、Outer.this.num，调用的外部类中的成员变量num的值也就是10，这个如果不清楚就看上面总结中的第二点，就是那个原理。
-
-
-### 为什么内部类调用的外部变量必须是final修饰的？
-
-因为生命周期的原因。方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。
-首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。
-问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。
-如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。
-为了解决：局部变量的生命周期与局部内部类的对象的生命周期的不一致性问题
-
-然而，在`Java7`中，这段代码不能通过编译，会报如下错误：
-Cannot refer to a non-final variable wordYouSay inside an inner class defined in a different method
-这算是`Java8(编译器)`提供的一项改进吧。想想，总是要无缘无故给传给局部内部类的局部变量添加一个final修饰，也确实有点儿恼人，这点儿改进多少让人省点心（语法糖的妙处）。
+### 1. 静态嵌套类(Static Nested Classes)
+```java
+class Outer {
+	static class Inner {
+		void go() {
+			System.out.println("Inner class reference is: " + this);
+		}
+	}
+}
+
+public class Test {
+	public static void main(String[] args) {
+		Outer.Inner n = new Outer.Inner();
+		n.go();
+	}
+}
+```
+输出：Inner class reference is: Outer$Inner@19e7ce87
+
+### 2.成员内部类(Member Inner Class)
+成员类是特定于实例的。它可以访问所有方法，字段和外部类本身的引用。
+```java
+public class Outer {
+    private int x = 100;
+    public void makeInner(){
+        Inner in = new Inner();
+        in.seeOuter();
+    }
+    class Inner{
+        public void seeOuter(){
+            System.out.println("Outer x is " + x);
+            System.out.println("Inner class reference is " + this);
+            System.out.println("Outer class reference is " + Outer.this);
+        }
+    }
+    public static void main(String [] args){
+    		Outer o = new Outer();
+        Inner i = o.new Inner();
+        i.seeOuter();
+    }
+}
+```
+输出：
+Outer x is 100
+Inner class reference is Outer$Inner@4dfd9726
+Outer class reference is Outer@43ce67ca
+
+### 3.局部方法内部类(Method-Local Inner Classes
+```java
+public class Outer {
+	private String x = "outer";
+
+	public void doStuff() {
+		class MyInner {
+			public void seeOuter() {
+				System.out.println("x is " + x);
+			}
+		}
+
+		MyInner i = new MyInner();
+		i.seeOuter();
+	}
+
+	public static void main(String[] args) {
+		Outer o = new Outer();
+		o.doStuff();
+	}
+}
+```
+输出：x is outer
+```java
+public class Outer {
+	private static String x = "static outer";
+
+	public static void doStuff() {
+		class MyInner {
+			public void seeOuter() {
+				System.out.println("x is " + x);
+			}
+		}
+
+		MyInner i = new MyInner();
+		i.seeOuter();
+	}
+
+	public static void main(String[] args) {
+		Outer.doStuff();
+	}
+}
+```
+输出：x is static outer
+### 4.匿名内部类(Anonymous Inner Classes)
+当您需要给一个GUI应用程序窗口小部件加一个动作监听器时，匿名内部类就会经常被用到。
+```java
+button.addActionListener(new ActionListener(){
+     public void actionPerformed(ActionEvent e){
+         comp.setText("Button has been clicked");
+     }
+});
+```
+
+
+####
+在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
+广泛意义上的内部类一般来说包括这三种：成员内部类（静态内部类、非静态内部类）、局部内部类、匿名内部类，
+
+使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
+
+接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
+
+```java
+public class InnerClassTest {
+	public static void main(String[] args) {
+		/*
+		 * 创建静态内部类对象的一般形式为：  外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
+		 * 创建成员内部类对象的一般形式为：  外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
+		 */
+		// 初始化Bean1
+		InnerClassTest t = new InnerClassTest();
+		InnerClassTest.Bean1 b1 = t.new Bean1();
+		b1.I++;
+		// 初始化Bean2
+		InnerClassTest.Bean2 b2 = new InnerClassTest.Bean2();
+		b2.J++;
+		// 初始化Bean3
+		Bean b = new Bean();
+		Bean.Bean3 b3 = b.new Bean3();
+		b3.k++;
+	}
+	class Bean1 {
+		public int I = 0;
+	}
+	static class Bean2 {
+		public int J = 0;
+	}
+
+}
+class Bean {
+	class Bean3 {
+		public int k = 0;
+	}
+}
+```
+创建静态内部类对象的一般形式为：  **外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()**
+
+创建成员内部类对象的一般形式为：  **外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()**
+
+
+###  变量
+
+```java
+/要求：使用已知的变量，在控制台输出30，20，10。
+　class Outer {
+    public int num = 10;
+    class Inner {
+        public int num = 20;
+        public void show() {
+            int num = 30;
+            System.out.println(?);
+            System.out.println(??);
+            System.out.println(???);
+        }
+    }
+}
+
+class InnerClassTest {
+    public static void main(String[] args) {
+        Outer.Inner oi = new Outer().new Inner();
+        oi.show();
+    }    
+}
+```
+1、局部变量 2、this，和3、Outer.this，也就是内部类访问外部类属性方法的原理。这考察三个东西，
+
+1、在一个方法中，使用直接使用变量名，肯定使用的是局部变量，因为会把大的成员变量给隐藏掉，这题中，也就是说show方法中的num会将内部类中的成员变量num隐藏掉，而内部类中的成员变量num又会把外部类中的成员变量num隐藏掉，所以通过直接输出num，会是show方法中的局部变量的值30.   
+
+2、使用this.num调用，其this代表的是调用该方法的对象，调用show方法的是oi，oi也就是内部类对象，所以oi.num也就标识内部类的成员变量num的值20
+
+3、Outer.this.num，调用的外部类中的成员变量num的值也就是10，这个如果不清楚就看上面总结中的第二点，就是那个原理。
+
+
+### 为什么内部类调用的外部变量必须是final修饰的？
+
+因为生命周期的原因。方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。
+首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。
+问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。
+如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。
+为了解决：局部变量的生命周期与局部内部类的对象的生命周期的不一致性问题
+
+然而，在`Java7`中，这段代码不能通过编译，会报如下错误：
+Cannot refer to a non-final variable wordYouSay inside an inner class defined in a different method
+这算是`Java8(编译器)`提供的一项改进吧。想想，总是要无缘无故给传给局部内部类的局部变量添加一个final修饰，也确实有点儿恼人，这点儿改进多少让人省点心（语法糖的妙处）。
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\211\247\350\241\214\351\241\272\345\272\217.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\211\247\350\241\214\351\241\272\345\272\217.md"
similarity index 96%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\211\247\350\241\214\351\241\272\345\272\217.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\211\247\350\241\214\351\241\272\345\272\217.md"
index a14b8661..fb91f490 100644
--- "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\211\247\350\241\214\351\241\272\345\272\217.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\211\247\350\241\214\351\241\272\345\272\217.md"	
@@ -1,6 +1,6 @@
-1. 父类静态代码块
-2. 子类静态代码块
-3. 父类构造代码块
-4. 父类构造方法
-5. 子类构造代码块
-6. 子类构造方法
+1. 父类静态代码块
+2. 子类静态代码块
+3. 父类构造代码块
+4. 父类构造方法
+5. 子类构造代码块
+6. 子类构造方法
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241 vs \346\216\245\345\217\243.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241 vs \346\216\245\345\217\243.md"
similarity index 98%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241 vs \346\216\245\345\217\243.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241 vs \346\216\245\345\217\243.md"
index aec3c1c2..80af23a0 100644
--- "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241 vs \346\216\245\345\217\243.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241 vs \346\216\245\345\217\243.md"	
@@ -1,57 +1,57 @@
-一个抽象类可以没有抽象方法
-一个接口可以继承任意数量的接口，一个抽象类只能继承一个抽象类。
-
-1.8以后接口有默认方法， default修饰
-
-接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。
-接口中的方法定义默认为`public abstract`类型，接口中的成员变量类型默认为`public static final`。
-
-另外，接口和抽象类在方法上有区别：    
-1. 抽象类可以有构造方法，接口中不能有构造方法。  
-2. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
-3. 抽象类中可以有普通成员变量，接口中没有普通成员变量
-4. 抽象类中的抽象方法的访问类型可以是`public，protected`和`默认类型`
-5. 抽象类中可以包含静态方法，接口中不能包含静态方法
-6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为`public static final`类型
-7. 一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。
-
-
-1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
-2、抽象方法必须由子类来进行重写。
-3、只要包含一个抽象方法的类，该类必须要定义成抽象类，不管是否还包含有其他方法。
-4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
-5、abstract不能与final并列修饰同一个类。
-6、**abstract 不能与private、static、final或native并列修饰同一个方法。、**
-
-1、abstract类不能用来创建abstract类的对象；
-2、final类不能用来派生子类，因为用final修饰的类不能被继承；
-3、final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
-4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。
-
-
-final修饰的类为终态类，不能被继承，而 抽象类是必须被继承的才有其意义的，因此，**final是不能用来修饰抽象类的。**
-final修饰的方法为终态方法，不能被重写。而继承抽象类，必须重写其方法。
-抽象方法是仅声明，并不做实现的方法。
-
-1、一个类可以有多个接口；
-2、一个类只能继承一个父类；
-3、接口中可以不声明任何方法，和成员变量
-interface testinterface{
-
-}
-4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类
- abstract class abstclass{
-	abstract void meth();
-}
-
-
-在java8以前的版本中，定义一个接口时，所有的方法必须是抽象方法，不能有具体实现，这是java语法规定的。
-但是在java8中定义一个接口时，在满足特定的前提下，可以有方法的具体实现。
-这样一个接口中可以有属性，可以有抽象方法，也可以有具体的方法，这跟java8以前的接口比，明显接口的功能变得强大了。
-
-
-
-1、抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个吧方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
-
-
-2、接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用，因为接口可以让所有的类去实现（非继承），不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。
+一个抽象类可以没有抽象方法
+一个接口可以继承任意数量的接口，一个抽象类只能继承一个抽象类。
+
+1.8以后接口有默认方法， default修饰
+
+接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。
+接口中的方法定义默认为`public abstract`类型，接口中的成员变量类型默认为`public static final`。
+
+另外，接口和抽象类在方法上有区别：    
+1. 抽象类可以有构造方法，接口中不能有构造方法。  
+2. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
+3. 抽象类中可以有普通成员变量，接口中没有普通成员变量
+4. 抽象类中的抽象方法的访问类型可以是`public，protected`和`默认类型`
+5. 抽象类中可以包含静态方法，接口中不能包含静态方法
+6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为`public static final`类型
+7. 一个类可以实现多个接口，但只能继承一个抽象类。二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码。
+
+
+1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
+2、抽象方法必须由子类来进行重写。
+3、只要包含一个抽象方法的类，该类必须要定义成抽象类，不管是否还包含有其他方法。
+4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
+5、abstract不能与final并列修饰同一个类。
+6、**abstract 不能与private、static、final或native并列修饰同一个方法。、**
+
+1、abstract类不能用来创建abstract类的对象；
+2、final类不能用来派生子类，因为用final修饰的类不能被继承；
+3、final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
+4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。
+
+
+final修饰的类为终态类，不能被继承，而 抽象类是必须被继承的才有其意义的，因此，**final是不能用来修饰抽象类的。**
+final修饰的方法为终态方法，不能被重写。而继承抽象类，必须重写其方法。
+抽象方法是仅声明，并不做实现的方法。
+
+1、一个类可以有多个接口；
+2、一个类只能继承一个父类；
+3、接口中可以不声明任何方法，和成员变量
+interface testinterface{
+
+}
+4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类
+ abstract class abstclass{
+	abstract void meth();
+}
+
+
+在java8以前的版本中，定义一个接口时，所有的方法必须是抽象方法，不能有具体实现，这是java语法规定的。
+但是在java8中定义一个接口时，在满足特定的前提下，可以有方法的具体实现。
+这样一个接口中可以有属性，可以有抽象方法，也可以有具体的方法，这跟java8以前的接口比，明显接口的功能变得强大了。
+
+
+
+1、抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个吧方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
+
+
+2、接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用，因为接口可以让所有的类去实现（非继承），不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241\347\261\273\344\270\216\346\216\245\345\217\243.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241\347\261\273\344\270\216\346\216\245\345\217\243.md"
similarity index 100%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241\347\261\273\344\270\216\346\216\245\345\217\243.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\212\275\350\261\241\347\261\273\344\270\216\346\216\245\345\217\243.md"
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.md"
similarity index 100%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.md"
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.png" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.png"
similarity index 100%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\346\236\232\344\270\276.png"
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\246\206\347\233\226\344\270\216\351\207\215\350\275\275.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\246\206\347\233\226\344\270\216\351\207\215\350\275\275.md"
similarity index 100%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\246\206\347\233\226\344\270\216\351\207\215\350\275\275.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\246\206\347\233\226\344\270\216\351\207\215\350\275\275.md"
diff --git "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\256\277\351\227\256\346\235\203\351\231\220.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\256\277\351\227\256\346\235\203\351\231\220.md"
similarity index 97%
rename from "01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\256\277\351\227\256\346\235\203\351\231\220.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\256\277\351\227\256\346\235\203\351\231\220.md"
index ad235d08..1d1f04e3 100644
--- "a/01 - JavaSE/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\256\277\351\227\256\346\235\203\351\231\220.md"	
+++ "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273 \346\216\245\345\217\243 \346\236\232\344\270\276/\350\256\277\351\227\256\346\235\203\351\231\220.md"	
@@ -1,52 +1,52 @@
-访问权限
-Java 中有三个访问权限修饰符：`private`、`protected` 以及 `public`，如果不加访问修饰符(`默认`)，表示包级可见。
-
-可以对类或类中的成员（字段以及方法）加上访问修饰符。
-
-`成员可见`表示其它类可以用这个类的实例访问到该成员；
-`类可见`表示其它类可以用这个类创建对象。
-
-`protected` 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
-
-设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
-
-**如果子类的方法覆盖了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。** 这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
-
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。可以使用公有的 getter 和 setter 方法来替换公有字段。
-``` java
-public class AccessExample {
-    public int x;
-}
-```
-``` java
-public class AccessExample {
-    private int x;
-
-    public int getX() {
-        return x;
-    }
-
-    public void setX(int x) {
-        this.x = x;
-    }
-}
-```
-但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
-
-``` java
-public class AccessWithInnerClassExample {
-    private class InnerClass {
-        int x;
-    }
-
-    private InnerClass innerClass;
-
-    public AccessWithInnerClassExample() {
-        innerClass = new InnerClass();
-    }
-
-    public int getValue() {
-        return innerClass.x; // 直接访问
-    }
-}
-```
+访问权限
+Java 中有三个访问权限修饰符：`private`、`protected` 以及 `public`，如果不加访问修饰符(`默认`)，表示包级可见。
+
+可以对类或类中的成员（字段以及方法）加上访问修饰符。
+
+`成员可见`表示其它类可以用这个类的实例访问到该成员；
+`类可见`表示其它类可以用这个类创建对象。
+
+`protected` 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
+
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
+
+**如果子类的方法覆盖了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。** 这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
+
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。可以使用公有的 getter 和 setter 方法来替换公有字段。
+``` java
+public class AccessExample {
+    public int x;
+}
+```
+``` java
+public class AccessExample {
+    private int x;
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+}
+```
+但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
+
+``` java
+public class AccessWithInnerClassExample {
+    private class InnerClass {
+        int x;
+    }
+
+    private InnerClass innerClass;
+
+    public AccessWithInnerClassExample() {
+        innerClass = new InnerClass();
+    }
+
+    public int getValue() {
+        return innerClass.x; // 直接访问
+    }
+}
+```
diff --git "a/01 - JavaSE/\347\261\273\344\277\256\351\245\260\347\254\246 .png" "b/01 - JavaSE Java\346\240\270\345\277\203/\347\261\273\344\277\256\351\245\260\347\254\246 .png"
similarity index 100%
rename from "01 - JavaSE/\347\261\273\344\277\256\351\245\260\347\254\246 .png"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\347\261\273\344\277\256\351\245\260\347\254\246 .png"
diff --git "a/01 - JavaSE/\350\266\205\350\257\246\347\273\206\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223\357\274\210\344\270\200\357\274\211\344\271\213Java\345\237\272\346\234\254\347\237\245\350\257\206.md" "b/01 - JavaSE Java\346\240\270\345\277\203/\350\266\205\350\257\246\347\273\206\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223\357\274\210\344\270\200\357\274\211\344\271\213Java\345\237\272\346\234\254\347\237\245\350\257\206.md"
similarity index 100%
rename from "01 - JavaSE/\350\266\205\350\257\246\347\273\206\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223\357\274\210\344\270\200\357\274\211\344\271\213Java\345\237\272\346\234\254\347\237\245\350\257\206.md"
rename to "01 - JavaSE Java\346\240\270\345\277\203/\350\266\205\350\257\246\347\273\206\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223\357\274\210\344\270\200\357\274\211\344\271\213Java\345\237\272\346\234\254\347\237\245\350\257\206.md"
diff --git a/02 - Java-High-Ranking/lambda/all.md "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/lambda/all.md"
similarity index 97%
rename from 02 - Java-High-Ranking/lambda/all.md
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/lambda/all.md"
index 5d305230..346aab0f 100644
--- a/02 - Java-High-Ranking/lambda/all.md	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/lambda/all.md"	
@@ -1,156 +1,156 @@
-http://www.importnew.com/15873.html
-http://www.runoob.com/java/java8-lambda-expressions.html
-Lambda表达式`只能针对函数式接口使用`。(**函数式接口是只包含一个方法的接口。**)
-
-## Java为何需要Lambda
-1996年1月，Java 1.0发布了，此后计算机编程领域发生了翻天覆地的变化。商业发展需要更复杂的应用，大多数程序都跑在更强大的装备多核CPU的机器上。带有高效运行期编译器的Java虚拟机（JVM）的出现，使得程序员将精力更多放在编写干净、易于维护的代码上，而不是思考如何将每一个CPU时钟、每一字节内存物尽其用。
-
-多核CPU的出现成了“房间里的大象”，无法忽视却没人愿意正视。算法中引入锁不但容易出错，而且消耗时间。人们开发了java.util.concurrent包和很多第三方类库，试图将并发抽象化，用以帮助程序员写出在多核CPU上运行良好的程序。不幸的是，到目前为止，我们走得还不够远。
-
-那些类库的开发者使用Java时，发现抽象的级别还不够。处理大数据就是个很好的例子，面对大数据，Java还欠缺高效的并行操作。**Java 8允许开发者编写复杂的集合处理算法**，只需要简单修改一个方法，就能让代码在多核CPU上高效运行。**为了编写并行处理这些大数据的类库**，需要在语言层面上修改现有的Java：增加lambda表达式。
-
-java 8引入lambda迫切需求是因为 **lambda 表达式能简化集合上数据的多线程或者多核的处理，提供更快的集合处理速度**
-
-当然，这样做是有代价的，程序员必须学习如何编写和阅读包含lambda表达式的代码，但是，这不是一桩赔本的买卖。与手写一大段复杂的、线程安全的代码相比，学习一点新语法和一些新习惯容易很多。开发企业级应用时，好的类库和框架极大地降低了开发时间和成本，也扫清了开发易用且高效的类库的障碍。
-
-[Java 8新特性探究（一）通往lambda之路_语法篇](https://my.oschina.net/benhaile/blog/175012)
-
-## Lambda语法
-包含三个部分
-
-    (parameters) -> expression 或者 (parameters) -> { statements; }
-
-* 一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数
-
-* 一个箭头符号：->
-
-* 方法体，可以是`表达式`和`代码块`，方法体函数式接口里面方法的实现，如果是代码块，则必须用`{}`来包裹起来，且需要一个`return` 返回值，但有个例外，若函数式接口里面方法返回值是`void`，则无需{}
-
-### 方法引用
-其实是lambda表达式的一个简化写法，所引用的方法其实是lambda表达式的方法体实现，语法也很简单，左边是容器（可以是类名，实例名），中间是"::"，右边是相应的方法名。
-    ObjectReference::methodName
-
-一般方法的引用格式是
-
-如果是静态方法，则是ClassName::methodName。如 Object ::equals
-
-如果是实例方法，则是Instance::methodName。如Object obj=new Object();obj::equals;
-
-构造函数.则是ClassName::new
-
-如果你觉得lambda的方法体会很长，影响代码可读性，方法引用就是个解决办法
-
-### 1.使用() -> {} 替代匿名类
-  现在Runnable线程，Swing，JavaFX的事件监听器代码等，在java 8中你可以使用Lambda表达式替代丑陋的匿名类。
-```java
-//Before Java 8:
-new Thread(new Runnable() {
-    @Override
-    public void run() {
-        System.out.println("Before Java8 ");
-    }
-}).start();
-
-//Java 8 way:
-new Thread(() -> System.out.println("In Java8!"));
-
-// Before Java 8:
-JButton show =  new JButton("Show");
-show.addActionListener(new ActionListener() {
-     @Override
-     public void actionPerformed(ActionEvent e) {
-           System.out.println("without lambda expression is boring");
-        }
-     });
-
-
-// Java 8 way:
-show.addActionListener((e) -> {
-    System.out.println("Action !! Lambda expressions Rocks");
-});
-```
-### 2.使用内循环替代外循环
-外循环：描述怎么干，代码里嵌套2个以上的for循环的都比较难读懂；只能顺序处理List中的元素；
-
-内循环：描述要干什么，而不是怎么干；不一定需要顺序处理List中的元素
-```java
-//Prior Java 8 :
-List features = Arrays.asList("Lambdas", "Default Method",
-"Stream API", "Date and Time API");
-for (String feature : features) {
-   System.out.println(feature);
-}
-
-//In Java 8:
-List features = Arrays.asList("Lambdas", "Default Method", "Stream API",
- "Date and Time API");
-features.forEach(n -> System.out.println(n));
-
-// Even better use Method reference feature of Java 8
-// method reference is denoted by :: (double colon) operator
-// looks similar to score resolution operator of C++
-features.forEach(System.out::println);
-
-Output:
-Lambdas
-Default Method
-Stream API
-Date and Time API
-```
-### 3.支持函数编程
-
-为了支持函数编程，Java 8加入了一个新的包`java.util.function`，其中有一个接口`java.util.function.Predicate`是支持Lambda函数编程：
-
-```java
-public static void main(args[]){
-  List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
-
-  System.out.println("Languages which starts with J :");
-  filter(languages, (str)->str.startsWith("J"));
-
-  System.out.println("Languages which ends with a ");
-  filter(languages, (str)->str.endsWith("a"));
-
-  System.out.println("Print all languages :");
-  filter(languages, (str)->true);
-
-   System.out.println("Print no language : ");
-   filter(languages, (str)->false);
-
-   System.out.println("Print language whose length greater than 4:");
-   filter(languages, (str)->str.length() > 4);
-}
-
- public static void filter(List names, Predicate condition) {
-    names.stream().filter((name) -> (condition.test(name)))
-        .forEach((name) -> {System.out.println(name + " ");
-    });
- }
-
-Output:
-Languages which starts with J :
-Java
-Languages which ends with a
-Java
-Scala
-Print all languages :
-Java
-Scala
-C++
-Haskell
-Lisp
-Print no language :
-Print language whose length greater than 4:
-Scala
-Haskell
-```
-
-4.处理数据？用管道的方式更加简洁
-```java
-final BigDecimal totalOfDiscountedPrices = prices.stream()
-.filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0)
-.map(price -> price.multiply(BigDecimal.valueOf(0.9)))
-.reduce(BigDecimal.ZERO,BigDecimal::add);
-
-System.out.println("Total of discounted prices: " + totalOfDiscountedPrices);
-```
+http://www.importnew.com/15873.html
+http://www.runoob.com/java/java8-lambda-expressions.html
+Lambda表达式`只能针对函数式接口使用`。(**函数式接口是只包含一个方法的接口。**)
+
+## Java为何需要Lambda
+1996年1月，Java 1.0发布了，此后计算机编程领域发生了翻天覆地的变化。商业发展需要更复杂的应用，大多数程序都跑在更强大的装备多核CPU的机器上。带有高效运行期编译器的Java虚拟机（JVM）的出现，使得程序员将精力更多放在编写干净、易于维护的代码上，而不是思考如何将每一个CPU时钟、每一字节内存物尽其用。
+
+多核CPU的出现成了“房间里的大象”，无法忽视却没人愿意正视。算法中引入锁不但容易出错，而且消耗时间。人们开发了java.util.concurrent包和很多第三方类库，试图将并发抽象化，用以帮助程序员写出在多核CPU上运行良好的程序。不幸的是，到目前为止，我们走得还不够远。
+
+那些类库的开发者使用Java时，发现抽象的级别还不够。处理大数据就是个很好的例子，面对大数据，Java还欠缺高效的并行操作。**Java 8允许开发者编写复杂的集合处理算法**，只需要简单修改一个方法，就能让代码在多核CPU上高效运行。**为了编写并行处理这些大数据的类库**，需要在语言层面上修改现有的Java：增加lambda表达式。
+
+java 8引入lambda迫切需求是因为 **lambda 表达式能简化集合上数据的多线程或者多核的处理，提供更快的集合处理速度**
+
+当然，这样做是有代价的，程序员必须学习如何编写和阅读包含lambda表达式的代码，但是，这不是一桩赔本的买卖。与手写一大段复杂的、线程安全的代码相比，学习一点新语法和一些新习惯容易很多。开发企业级应用时，好的类库和框架极大地降低了开发时间和成本，也扫清了开发易用且高效的类库的障碍。
+
+[Java 8新特性探究（一）通往lambda之路_语法篇](https://my.oschina.net/benhaile/blog/175012)
+
+## Lambda语法
+包含三个部分
+
+    (parameters) -> expression 或者 (parameters) -> { statements; }
+
+* 一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数
+
+* 一个箭头符号：->
+
+* 方法体，可以是`表达式`和`代码块`，方法体函数式接口里面方法的实现，如果是代码块，则必须用`{}`来包裹起来，且需要一个`return` 返回值，但有个例外，若函数式接口里面方法返回值是`void`，则无需{}
+
+### 方法引用
+其实是lambda表达式的一个简化写法，所引用的方法其实是lambda表达式的方法体实现，语法也很简单，左边是容器（可以是类名，实例名），中间是"::"，右边是相应的方法名。
+    ObjectReference::methodName
+
+一般方法的引用格式是
+
+如果是静态方法，则是ClassName::methodName。如 Object ::equals
+
+如果是实例方法，则是Instance::methodName。如Object obj=new Object();obj::equals;
+
+构造函数.则是ClassName::new
+
+如果你觉得lambda的方法体会很长，影响代码可读性，方法引用就是个解决办法
+
+### 1.使用() -> {} 替代匿名类
+  现在Runnable线程，Swing，JavaFX的事件监听器代码等，在java 8中你可以使用Lambda表达式替代丑陋的匿名类。
+```java
+//Before Java 8:
+new Thread(new Runnable() {
+    @Override
+    public void run() {
+        System.out.println("Before Java8 ");
+    }
+}).start();
+
+//Java 8 way:
+new Thread(() -> System.out.println("In Java8!"));
+
+// Before Java 8:
+JButton show =  new JButton("Show");
+show.addActionListener(new ActionListener() {
+     @Override
+     public void actionPerformed(ActionEvent e) {
+           System.out.println("without lambda expression is boring");
+        }
+     });
+
+
+// Java 8 way:
+show.addActionListener((e) -> {
+    System.out.println("Action !! Lambda expressions Rocks");
+});
+```
+### 2.使用内循环替代外循环
+外循环：描述怎么干，代码里嵌套2个以上的for循环的都比较难读懂；只能顺序处理List中的元素；
+
+内循环：描述要干什么，而不是怎么干；不一定需要顺序处理List中的元素
+```java
+//Prior Java 8 :
+List features = Arrays.asList("Lambdas", "Default Method",
+"Stream API", "Date and Time API");
+for (String feature : features) {
+   System.out.println(feature);
+}
+
+//In Java 8:
+List features = Arrays.asList("Lambdas", "Default Method", "Stream API",
+ "Date and Time API");
+features.forEach(n -> System.out.println(n));
+
+// Even better use Method reference feature of Java 8
+// method reference is denoted by :: (double colon) operator
+// looks similar to score resolution operator of C++
+features.forEach(System.out::println);
+
+Output:
+Lambdas
+Default Method
+Stream API
+Date and Time API
+```
+### 3.支持函数编程
+
+为了支持函数编程，Java 8加入了一个新的包`java.util.function`，其中有一个接口`java.util.function.Predicate`是支持Lambda函数编程：
+
+```java
+public static void main(args[]){
+  List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
+
+  System.out.println("Languages which starts with J :");
+  filter(languages, (str)->str.startsWith("J"));
+
+  System.out.println("Languages which ends with a ");
+  filter(languages, (str)->str.endsWith("a"));
+
+  System.out.println("Print all languages :");
+  filter(languages, (str)->true);
+
+   System.out.println("Print no language : ");
+   filter(languages, (str)->false);
+
+   System.out.println("Print language whose length greater than 4:");
+   filter(languages, (str)->str.length() > 4);
+}
+
+ public static void filter(List names, Predicate condition) {
+    names.stream().filter((name) -> (condition.test(name)))
+        .forEach((name) -> {System.out.println(name + " ");
+    });
+ }
+
+Output:
+Languages which starts with J :
+Java
+Languages which ends with a
+Java
+Scala
+Print all languages :
+Java
+Scala
+C++
+Haskell
+Lisp
+Print no language :
+Print language whose length greater than 4:
+Scala
+Haskell
+```
+
+4.处理数据？用管道的方式更加简洁
+```java
+final BigDecimal totalOfDiscountedPrices = prices.stream()
+.filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0)
+.map(price -> price.multiply(BigDecimal.valueOf(0.9)))
+.reduce(BigDecimal.ZERO,BigDecimal::add);
+
+System.out.println("Total of discounted prices: " + totalOfDiscountedPrices);
+```
diff --git "a/02 - Java-High-Ranking/\344\272\213\345\212\241/Spring hibernate\344\272\213\345\212\241.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\344\272\213\345\212\241/Spring hibernate\344\272\213\345\212\241.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\344\272\213\345\212\241/Spring hibernate\344\272\213\345\212\241.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\344\272\213\345\212\241/Spring hibernate\344\272\213\345\212\241.txt"
diff --git "a/02 - Java-High-Ranking/\344\272\213\345\212\241/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\344\272\213\345\212\241/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\344\272\213\345\212\241/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\344\272\213\345\212\241/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.txt"
diff --git "a/02 - Java-High-Ranking/\344\272\213\345\212\241/\346\225\260\346\215\256\345\272\223\344\272\213\345\212\241.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\344\272\213\345\212\241/\346\225\260\346\215\256\345\272\223\344\272\213\345\212\241.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\344\272\213\345\212\241/\346\225\260\346\215\256\345\272\223\344\272\213\345\212\241.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\344\272\213\345\212\241/\346\225\260\346\215\256\345\272\223\344\272\213\345\212\241.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.docx" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.docx"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.docx"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.docx"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Concurrent.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Concurrent.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Concurrent.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Concurrent.md"
index 0677ed18..1dc58e2b 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Concurrent.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Concurrent.md"	
@@ -1,1690 +1,1690 @@
-<!-- GFM-TOC -->
-* [一、线程状态转换](#一线程状态转换)
-    * [新建（New）](#新建new)
-    * [可运行（Runnable）](#可运行runnable)
-    * [阻塞（Blocking）](#阻塞blocking)
-    * [无限期等待（Waiting）](#无限期等待waiting)
-    * [限期等待（Timed Waiting）](#限期等待timed-waiting)
-    * [死亡（Terminated）](#死亡terminated)
-* [二、使用线程](#二使用线程)
-    * [实现 Runnable 接口](#实现-runnable-接口)
-    * [实现 Callable 接口](#实现-callable-接口)
-    * [继承 Thread 类](#继承-thread-类)
-    * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
-* [三、基础线程机制](#三基础线程机制)
-    * [Executor](#executor)
-    * [Daemon](#daemon)
-    * [sleep()](#sleep)
-    * [yield()](#yield)
-* [四、中断](#四中断)
-    * [InterruptedException](#interruptedexception)
-    * [interrupted()](#interrupted)
-    * [Executor 的中断操作](#executor-的中断操作)
-* [五、互斥同步](#五互斥同步)
-    * [synchronized](#synchronized)
-    * [ReentrantLock](#reentrantlock)
-    * [synchronized 和 ReentrantLock 比较](#synchronized-和-reentrantlock-比较)
-* [六、线程之间的协作](#六线程之间的协作)
-    * [join()](#join)
-    * [wait() notify() notifyAll()](#wait-notify-notifyall)
-    * [await() signal() signalAll()](#await-signal-signalall)
-* [七、J.U.C - AQS](#七juc---aqs)
-    * [CountdownLatch](#countdownlatch)
-    * [CyclicBarrier](#cyclicbarrier)
-    * [Semaphore](#semaphore)
-* [八、J.U.C - 其它组件](#八juc---其它组件)
-    * [FutureTask](#futuretask)
-    * [BlockingQueue](#blockingqueue)
-    * [ForkJoin](#forkjoin)
-* [九、线程不安全示例](#九线程不安全示例)
-* [十、Java 内存模型](#十java-内存模型)
-    * [主内存与工作内存](#主内存与工作内存)
-    * [内存间交互操作](#内存间交互操作)
-    * [内存模型三大特性](#内存模型三大特性)
-    * [先行发生原则](#先行发生原则)
-* [十一、线程安全](#十一线程安全)
-    * [线程安全定义](#线程安全定义)
-    * [线程安全分类](#线程安全分类)
-    * [线程安全的实现方法](#线程安全的实现方法)
-* [十二、锁优化](#十二锁优化)
-    * [自旋锁](#自旋锁)
-    * [锁消除](#锁消除)
-    * [锁粗化](#锁粗化)
-    * [轻量级锁](#轻量级锁)
-    * [偏向锁](#偏向锁)
-* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、线程状态转换
-
-<div align="center"> <img src="/image/02/Concurrent/ace830df-9919-48ca-91b5-60b193f593d2.png" width=""/> </div><br>
-
-## 新建（New）
-
-创建后尚未启动。
-
-## 可运行（Runnable）
-
-可能正在运行，也可能正在等待 CPU 时间片。
-
-包含了操作系统线程状态中的 `Running` 和 `Ready`。
-
-## 阻塞（Blocking）
-
-等待获取一个`排它锁`，如果其线程释放了锁就会结束此状态。
-
-## 无限期等待（Waiting）
-
-等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
-
-| 进入方法 | 退出方法 |
-| --- | --- |
-| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
-| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
-| LockSupport.park() 方法 | - |
-
-## 限期等待（Timed Waiting）
-
-无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
-
-调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
-
-调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
-
-睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
-
-阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁；而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
-
-| 进入方法 | 退出方法 |
-| --- | --- |
-| Thread.sleep() 方法 | 时间结束 |
-| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll()  |
-| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
-| LockSupport.parkNanos() 方法 | - |
-| LockSupport.parkUntil() 方法 | - |
-
-## 死亡（Terminated）
-
-可以是线程结束任务之后自己结束，或者产生了异常而结束。
-
-# 二、使用线程
-
-有三种使用线程的方法：
-
-* 实现 `Runnable` 接口；
-* 实现 `Callable` 接口；
-* 继承 `Thread` 类。
-
-实现 `Runnable` 和 `Callable` 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
-
-## 实现 Runnable 接口
-
-需要实现 run() 方法。
-
-通过 Thread 调用 start() 方法来启动线程。
-
-```java
-public class MyRunnable implements Runnable {
-    public void run() {
-        // ...
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    MyRunnable instance = new MyRunnable();
-    Thread thread = new Thread(instance);
-    thread.start();
-}
-```
-
-## 实现 Callable 接口
-
-与 Runnable 相比，Callable 可以有返回值，返回值通过 `FutureTask` 进行封装。
-
-```java
-public class MyCallable implements Callable<Integer> {
-    public Integer call() {
-        return 123;
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
-    MyCallable mc = new MyCallable();
-    FutureTask<Integer> ft = new FutureTask<>(mc);
-    Thread thread = new Thread(ft);
-    thread.start();
-    System.out.println(ft.get());
-}
-```
-
-## 继承 Thread 类
-
-同样也是需要实现 run() 方法，并且最后也是调用 start() 方法来启动线程。
-
-```java
-public class MyThread extends Thread {
-    public void run() {
-        // ...
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    MyThread mt = new MyThread();
-    mt.start();
-}
-```
-
-## 实现接口 VS 继承 Thread
-
-实现接口会更好一些，因为：
-
-- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
-- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
-
-# 三、基础线程机制
-
-## Executor
-
-Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。
-
-主要有三种 Executor：
-
-- CachedThreadPool：一个任务创建一个线程；
-- FixedThreadPool：所有任务只能使用固定大小的线程；
-- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
-
-```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < 5; i++) {
-        executorService.execute(new MyRunnable());
-    }
-    executorService.shutdown();
-}
-```
-
-## Daemon
-
-守护线程是 **程序运行时在后台提供服务的线程**，不属于程序中不可或缺的部分。
-
-当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
-
-main() 属于非守护线程。
-
-使用 setDaemon() 方法将一个线程设置为守护线程。
-
-```java
-public static void main(String[] args) {
-    Thread thread = new Thread(new MyRunnable());
-    thread.setDaemon(true);
-}
-```
-
-## sleep()
-
-Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
-
-sleep() 可能会抛出 `InterruptedException`，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
-
-```java
-public void run() {
-    try {
-        Thread.sleep(3000);
-    } catch (InterruptedException e) {
-        e.printStackTrace();
-    }
-}
-```
-
-## yield()
-
-对静态方法 Thread.yield() 的调用声明了 **当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行**。该方法只是对线程调度器的一个建议，而且也只是建议具有 **相同优先级** 的其它线程可以运行。
-
-```java
-public void run() {
-    Thread.yield();
-}
-```
-
-# 四、中断
-
-一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
-
-## InterruptedException
-
-通过调用一个线程的 `interrupt()` 来中断该线程，如果该线程处于`阻塞`、`限期等待`或者`无限期等待`状态，那么就会抛出 `InterruptedException`，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
-
-对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
-
-```java
-public class InterruptExample {
-
-    private static class MyThread1 extends Thread {
-        @Override
-        public void run() {
-            try {
-                Thread.sleep(2000);
-                System.out.println("Thread run");
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws InterruptedException {
-    Thread thread1 = new MyThread1();
-    thread1.start();
-    thread1.interrupt();
-    System.out.println("Main run");
-}
-```
-
-```html
-Main run
-java.lang.InterruptedException: sleep interrupted
-    at java.lang.Thread.sleep(Native Method)
-    at InterruptExample.lambda$main$0(InterruptExample.java:5)
-    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
-    at java.lang.Thread.run(Thread.java:745)
-```
-
-## interrupted()
-
-如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 `InterruptedException` 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
-
-但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
-
-```java
-public class InterruptExample {
-
-    private static class MyThread2 extends Thread {
-        @Override
-        public void run() {
-            while (!interrupted()) {
-                // ..
-            }
-            System.out.println("Thread end");
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws InterruptedException {
-    Thread thread2 = new MyThread2();
-    thread2.start();
-    thread2.interrupt();
-}
-```
-
-```html
-Thread end
-```
-
-## Executor 的中断操作
-
-调用 Executor 的 `shutdown()` 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 `shutdownNow()` 方法，则相当于调用每个线程的 `interrupt()` 方法。
-
-以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
-
-```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> {
-        try {
-            Thread.sleep(2000);
-            System.out.println("Thread run");
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-    });
-    executorService.shutdownNow();
-    System.out.println("Main run");
-}
-```
-
-```html
-Main run
-java.lang.InterruptedException: sleep interrupted
-    at java.lang.Thread.sleep(Native Method)
-    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
-    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
-    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
-    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
-    at java.lang.Thread.run(Thread.java:745)
-```
-
-如果只想中断 Executor 中的一个线程，可以通过使用 `submit()` 方法来提交一个线程，它会返回一个 `Future<?>` 对象，通过调用该对象的 `cancel(true)` 方法就可以中断线程。
-
-```java
-Future<?> future = executorService.submit(() -> {
-    // ..
-});
-future.cancel(true);
-```
-
-# 五、互斥同步
-
-Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
-
-## synchronized
-
-**1. 同步一个代码块**
-
-```java
-public void func () {
-    synchronized (this) {
-        // ...
-    }
-}
-```
-
-它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
-
-对于以下代码，使用 ExecutorService 执行了两个线程（这两个线程使用 Lambda 创建），由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
-
-```java
-public class SynchronizedExample {
-
-    public void func1() {
-        synchronized (this) {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func1());
-    executorService.execute(() -> e1.func1());
-}
-```
-
-```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
-```
-
-对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
-
-```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    SynchronizedExample e2 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func1());
-    executorService.execute(() -> e2.func1());
-}
-```
-
-```html
-0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
-```
-
-
-**2. 同步一个方法**
-
-```java
-public synchronized void func () {
-    // ...
-}
-```
-
-它和同步代码块一样，只作用于同一个对象。
-
-**3. 同步一个类**
-
-```java
-public void func() {
-    synchronized (SynchronizedExample.class) {
-        // ...
-    }
-}
-```
-
-**作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也需要进行同步。**
-
-```java
-public class SynchronizedExample {
-
-    public void func2() {
-        synchronized (SynchronizedExample.class) {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    SynchronizedExample e2 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func2());
-    executorService.execute(() -> e2.func2());
-}
-```
-
-```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
-```
-
-**4. 同步一个静态方法**
-
-```java
-public synchronized static void fun() {
-    // ...
-}
-```
-
-作用于整个类。
-
-## ReentrantLock
-
-```java
-public class LockExample {
-
-    private Lock lock = new ReentrantLock();
-
-    public void func() {
-        lock.lock();
-        try {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        } finally {
-            lock.unlock(); // 确保释放锁，从而避免发生死锁。
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    LockExample lockExample = new LockExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> lockExample.func());
-    executorService.execute(() -> lockExample.func());
-}
-```
-
-```html
-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）包中的锁，
-**ReentrantLock 相比于 synchronized**，它多了以下高级功能：
-
-**1. 等待可中断**
-
-当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
-
-**2. 可实现公平锁**
-
-公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
-
-**3. 锁绑定多个条件**
-
-一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。
-
-## synchronized 和 ReentrantLock 比较
-
-**1. 锁的实现**
-
-synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
-
-**2. 性能**
-
-从性能上来看，新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等。目前来看它和 ReentrantLock 的性能基本持平了，因此性能因素不再是选择 ReentrantLock 的理由。synchronized 有更大的性能优化空间，应该优先考虑 synchronized。
-
-**3. 功能**
-
-ReentrantLock 多了一些高级功能。
-
-**4. 使用选择**
-
-除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
-
-# 六、线程之间的协作
-
-当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
-
-## join()
-
-在线程中调用另一个线程的 `join()` 方法，会将当前线程挂起，而不是忙等待， 直到目标线程结束。
-
-对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，因此 b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先与 b 线程的输出。
-
-```java
-public class JoinExample {
-
-    private class A extends Thread {
-        @Override
-        public void run() {
-            System.out.println("A");
-        }
-    }
-
-    private class B extends Thread {
-
-        private A a;
-
-        B(A a) {
-            this.a = a;
-        }
-
-        @Override
-        public void run() {
-            try {
-                a.join();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.println("B");
-        }
-    }
-
-    public void test() {
-        A a = new A();
-        B b = new B(a);
-        b.start();
-        a.start();
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    JoinExample example = new JoinExample();
-    example.test();
-}
-```
-
-```
-A
-B
-```
-
-## wait() notify() notifyAll()
-
-调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
-
-它们都属于 Object 的一部分，而不属于 Thread。
-
-只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 **IllegalMonitorStateExeception**。
-
-使用 wait() 挂起期间，线程会 **释放锁**。这是 **因为**，如果 **没有释放锁**，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就 **无法执行** **notify()** 或者 **notifyAll()** 来唤醒挂起的线程，造成死锁。
-
-```java
-public class WaitNotifyExample {
-    public synchronized void before() {
-        System.out.println("before");
-        notifyAll();
-    }
-
-    public synchronized void after() {
-        try {
-            wait();
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-        System.out.println("after");
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    WaitNotifyExample example = new WaitNotifyExample();
-    executorService.execute(() -> example.after());
-    executorService.execute(() -> example.before());
-}
-```
-
-```html
-before
-after
-```
-
-**wait() 和 sleep() 的区别**
-
-1. wait() 是 Object 的方法，而 sleep() 是 Thread 的 **静态方法**；
-2. wait() 会释放锁，sleep() 不会。
-
-## await() signal() signalAll()
-
-java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
-
-使用 Lock 来获取一个 Condition 对象。
-
-```java
-public class AwaitSignalExample {
-    private Lock lock = new ReentrantLock();
-    private Condition condition = lock.newCondition();
-
-    public void before() {
-        lock.lock();
-        try {
-            System.out.println("before");
-            condition.signalAll();
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    public void after() {
-        lock.lock();
-        try {
-            condition.await();
-            System.out.println("after");
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        } finally {
-            lock.unlock();
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    AwaitSignalExample example = new AwaitSignalExample();
-    executorService.execute(() -> example.after());
-    executorService.execute(() -> example.before());
-}
-```
-
-```html
-before
-after
-```
-
-# 七、J.U.C - AQS
-
-java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
-
-## CountdownLatch
-
-用来控制 **一个线程等待多个线程** 。
-
-维护了一个计数器 `cnt`，每次调用 `countDown()` 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 `await()` 方法而在等待的线程就会被唤醒。
-
-<div align="center"> <img src="/image/02/Concurrent/CountdownLatch.png" width=""/> </div><br>
-
-```java
-public class CountdownLatchExample {
-
-    public static void main(String[] args) throws InterruptedException {
-        final int totalThread = 10;
-        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalThread; i++) {
-            executorService.execute(() -> {
-                System.out.print("run..");
-                countDownLatch.countDown();
-            });
-        }
-        countDownLatch.await();
-        System.out.println("end");
-        executorService.shutdown();
-    }
-}
-```
-
-```html
-run..run..run..run..run..run..run..run..run..run..end
-```
-
-## CyclicBarrier
-
-用来控制 **多个线程互相等待**，只有当多个线程都到达时，这些线程才会继续执行。
-
-和 CountdownLatch 相似，都是通过维护计数器来实现的。但是它的计数器是递增的，每次执行 `await()` 方法之后，计数器会加 1，直到计数器的值和设置的值相等，等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 的计数器可以`循环使用`，所以它才叫做循环屏障。
-
-下图应该从下往上看才正确。
-
-<div align="center"> <img src="/image/02/Concurrent/CyclicBarrier.png" width=""/> </div><br>
-
-```java
-public class CyclicBarrierExample {
-    public static void main(String[] args) throws InterruptedException {
-        final int totalThread = 10;
-        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalThread; i++) {
-            executorService.execute(() -> {
-                System.out.print("before..");
-                try {
-                    cyclicBarrier.await();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                } catch (BrokenBarrierException e) {
-                    e.printStackTrace();
-                }
-                System.out.print("after..");
-            });
-        }
-        executorService.shutdown();
-    }
-}
-```
-
-```html
-before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..
-```
-
-## Semaphore
-
-Semaphore 就是操作系统中的信号量，可以 **控制对互斥资源的访问线程数**。
-
-<div align="center"> <img src="/image/02/Concurrent/Semaphore.png" width=""/> </div><br>
-
-以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。
-
-```java
-public class SemaphoreExample {
-    public static void main(String[] args) {
-        final int clientCount = 3;
-        final int totalRequestCount = 10;
-        Semaphore semaphore = new Semaphore(clientCount);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalRequestCount; i++) {
-            executorService.execute(()->{
-                try {
-                    semaphore.acquire();
-                    System.out.print(semaphore.availablePermits() + " ");
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                } finally {
-                    semaphore.release();
-                }
-            });
-        }
-        executorService.shutdown();
-    }
-}
-```
-
-```html
-2 1 2 2 2 2 2 1 2 2
-```
-
-# 八、J.U.C - 其它组件
-
-## FutureTask
-
-在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future<V> 进行封装。FutureTask 实现了 `RunnableFuture` 接口，该接口继承自 `Runnable` 和 `Future<V>` 接口，这使得 `FutureTask` 既可以当做一个任务执行，也可以有返回值。
-
-```
-public class FutureTask<V> implements RunnableFuture<V>
-```
-
-```
-public interface RunnableFuture<V> extends Runnable, Future<V>
-```
-
-**当一个计算任务需要执行很长时间**，那么就可以用 FutureTask 来封装这个任务，用一个线程去执行该任务，然后其它线程继续执行其它任务。当需要该任务的计算结果时，再通过 FutureTask 的 get() 方法获取。
-
-```java
-public class FutureTaskExample {
-    public static void main(String[] args) throws ExecutionException, InterruptedException {
-        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
-            @Override
-            public Integer call() throws Exception {
-                int result = 0;
-                for (int i = 0; i < 100; i++) {
-                    Thread.sleep(10);
-                    result += i;
-                }
-                return result;
-            }
-        });
-
-        Thread computeThread = new Thread(futureTask);
-        computeThread.start();
-
-        Thread otherThread = new Thread(() -> {
-            System.out.println("other task is running...");
-            try {
-                Thread.sleep(1000);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        });
-        otherThread.start();
-        System.out.println(futureTask.get());
-    }
-}
-```
-
-```html
-other task is running...
-4950
-```
-
-## BlockingQueue
-
-java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
-
--  **FIFO 队列** ：`LinkedBlockingQueue`、`ArrayListBlockingQueue`（固定长度）
--  **优先级队列** ：`PriorityBlockingQueue`
-
-提供了阻塞的 `take()` 和 `put()` 方法：如果队列为空 `take()` 将阻塞，直到队列中有内容；如果队列为满 `put()` 将阻塞，指到队列有空闲位置。
-
-**使用 BlockingQueue 实现生产者消费者问题**
-
-```java
-public class ProducerConsumer {
-
-    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
-
-    private static class Producer extends Thread {
-        @Override
-        public void run() {
-            try {
-                queue.put("product");
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.print("produce..");
-        }
-    }
-
-    private static class Consumer extends Thread {
-
-        @Override
-        public void run() {
-            try {
-                String product = queue.take();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.print("consume..");
-        }
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    for (int i = 0; i < 2; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
-    for (int i = 0; i < 5; i++) {
-        Consumer consumer = new Consumer();
-        consumer.start();
-    }
-    for (int i = 0; i < 3; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
-}
-```
-
-```html
-produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
-```
-
-## ForkJoin
-
-主要用于并行计算中，和 MapReduce 原理类似，都是 把 **大的计算任务** **拆分** 成 **多个小任务** **并行计算**。
-
-```java
-public class ForkJoinExample extends RecursiveTask<Integer> {
-    private final int threhold = 5;
-    private int first;
-    private int last;
-
-    public ForkJoinExample(int first, int last) {
-        this.first = first;
-        this.last = last;
-    }
-
-    @Override
-    protected Integer compute() {
-        int result = 0;
-        if (last - first <= threhold) {
-            // 任务足够小则直接计算
-            for (int i = first; i <= last; i++) {
-                result += i;
-            }
-        } else {
-            // 拆分成小任务
-            int middle = first + (last - first) / 2;
-            ForkJoinExample leftTask = new ForkJoinExample(first, middle);
-            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
-            leftTask.fork();
-            rightTask.fork();
-            result = leftTask.join() + rightTask.join();
-        }
-        return result;
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
-    ForkJoinExample example = new ForkJoinExample(1, 10000);
-    ForkJoinPool forkJoinPool = new ForkJoinPool();
-    Future result = forkJoinPool.submit(example);
-    System.out.println(result.get());
-}
-```
-
-ForkJoin 使用 `ForkJoinPool` 来启动，它是一个特殊的线程池，`线程数量取决于 CPU 核数`。
-
-```
-public class ForkJoinPool extends AbstractExecutorService
-```
-
-ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
-
-<div align="center"> <img src="/image/02/Concurrent/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg" width=""/> </div><br>
-
-# 九、线程不安全示例
-
-如果 **多个线程对同一个共享数据进行访问而不采取同步操作** 的话，那么操作的结果是不一致的。
-
-以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值为 997 而不是 1000。
-
-```java
-public class ThreadUnsafeExample {
-
-    private int cnt = 0;
-
-    public void add() {
-        cnt++;
-    }
-
-    public int get() {
-        return cnt;
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    ThreadUnsafeExample example = new ThreadUnsafeExample();
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
-}
-```
-
-```html
-997
-```
-
-# 十、Java 内存模型
-
-Java 内存模型试图 **屏蔽各种硬件和操作系统的内存访问差异**，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
-
-## 主内存与工作内存
-
-处理器上的寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了 **高速缓存**。
-
-加入高速缓存带来了一个新的问题：**缓存一致性**。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
-
-<div align="center"> <img src="/image/02/Concurrent/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png" width=""/> </div><br>
-
-所有的变量都存储在`主内存`中，每个线程还有自己的`工作内存`，`工作内存`存储在高速缓存或者寄存器中，保存了该线程使用的变量的`主内存`副本拷贝。
-
-线程只能直接操作`工作内存`中的变量，不同线程之间的变量值传递需要通过`主内存`来完成。
-
-<div align="center"> <img src="/image/02/Concurrent/47358f87-bc4c-496f-9a90-8d696de94cee.png" width=""/> </div><br>
-
-## 内存间交互操作
-
-Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
-
-<div align="center"> <img src="/image/02/Concurrent/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png" width=""/> </div><br>
-
-- `read`：把一个变量的值从`主内存`传输到`工作内存`中
-- `load`：在 read 之后执行，把 read 得到的值放入`工作内存`的变量副本中
-- `use`：把`工作内存`中一个变量的值传递给`执行引擎`
-- `assign`：把一个从`执行引擎`接收到的值赋给`工作内存`的变量
-- `store`：把`工作内存`的一个变量的值传送到`主内存`中
-- `write`：在 store 之后执行，把 store 得到的值放入`主内存`的变量中
-- `lock`：作用于`主内存`的变量
-- `unlock`
-
-## 内存模型三大特性
-
-### 1. 原子性
-
-Java 内存模型保证了 `read`、`load`、`use`、`assign`、`store`、`write`、`lock` 和 `unlock` 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
-
-有一个错误认识就是，int 等原子性的变量在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 变量属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
-
-为了方便讨论，将内存间的交互操作简化为 3 个：`load`、`assign`、`store`。
-
-下图演示了两个线程同时对 cnt 变量进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入该变量的值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足 `原子性`只是说明 load、assign、store 这些单个操作具备原子性。
-
-<div align="center"> <img src="/image/02/Concurrent/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png" width=""/> </div><br>
-
-AtomicInteger 能保证多个线程修改的原子性。
-
-<div align="center"> <img src="/image/02/Concurrent/952afa9a-458b-44ce-bba9-463e60162945.png" width=""/> </div><br>
-
-使用 **AtomicInteger** 重写之前线程不安全的代码之后得到以下线程安全实现：
-
-```java
-public class AtomicExample {
-    private AtomicInteger cnt = new AtomicInteger();
-
-    public void add() {
-        cnt.incrementAndGet();
-    }
-
-    public int get() {
-        return cnt.get();
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    AtomicExample example = new AtomicExample(); // 只修改这条语句
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
-}
-```
-
-```html
-1000
-```
-
-除了使用原子类之外，也可以使用 `synchronized` 互斥锁来保证操作的完整性，它对应的内存间交互操作为：`lock` 和 `unlock`，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
-
-```java
-public class AtomicSynchronizedExample {
-    private int cnt = 0;
-
-    public synchronized void add() {
-        cnt++;
-    }
-
-    public synchronized int get() {
-        return cnt;
-    }
-}
-```
-
-```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    AtomicSynchronizedExample example = new AtomicSynchronizedExample();
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
-}
-```
-
-```html
-1000
-```
-
-### 2. 可见性
-
-可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量`修改后`将新值`同步`回`主内存`，在变量读取前从主内存刷新变量值来实现`可见性`的。
-
-`volatile` 可保证可见性。`synchronized` 也能够保证可见性，对一个变量执行 `unlock` 操作之前，必须把变量值同步回`主内存`。`final` 关键字也能保证可见性：被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程可以通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
-
-对前面的线程不安全示例中的 cnt 变量用 volatile 修饰，不能解决线程不安全问题，因为 `volatile` 并`不能`保证操作的 `原子性`。
-
-### 3. 有序性
-
-有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了`指令重排序`。
-
-在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程`不会影响`到`单线程`程序的执行，却会`影响`到`多线程并发执行`的正确性。
-
-`volatile` 关键字通过添加内存屏障的方式来 `禁止指令重排`，即重排序时不能把后面的指令放到内存屏障之前。
-
-也可以通过 `synchronized` 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让`线程顺序执行同步代码`。
-
-## 先行发生原则
-
-上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
-
-主要有以下这些原则：
-
-### 1. 单一线程原则
-
-> Single Thread rule
-
-在一个线程内，在程序 **前面的操作** **先行发生于后面的操作**。
-
-<div align="center"> <img src="/image/02/Concurrent/single-thread-rule.png" width=""/> </div><br>
-
-### 2. 管程锁定规则
-
-> Monitor Lock Rule
-
-一个 unlock 操作 **先行发生于后面对同一个锁的 lock 操作**。
-
-<div align="center"> <img src="/image/02/Concurrent/monitor-lock-rule.png" width=""/> </div><br>
-
-### 3. volatile 变量规则
-
-> Volatile Variable Rule
-
-对一个 volatile 变量的 **写操作**  **先行发生于后面对这个变量的读操作**。
-
-<div align="center"> <img src="/image/02/Concurrent/volatile-variable-rule.png" width=""/> </div><br>
-
-### 4. 线程启动规则
-
-> Thread Start Rule
-
-Thread 对象的 start() 方法调用 **先行发生于此线程的每一个动作**。
-
-<div align="center"> <img src="/image/02/Concurrent/thread-start-rule.png" width=""/> </div><br>
-
-### 5. 线程加入规则
-
-> Thread Join Rule
-
-join() 方法返回 **先行发生于 Thread 对象的结束**。
-
-<div align="center"> <img src="/image/02/Concurrent/thread-join-rule.png" width=""/> </div><br>
-
-### 6. 线程中断规则
-
-> Thread Interruption Rule
-
-对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 `Thread.interrupted()` 方法检测到是否有中断发生。
-
-### 7. 对象终结规则
-
-> Finalizer Rule
-
-一个对象的初始化完成（构造函数执行结束）先行发生于它的 `finalize()` 方法的开始。
-
-### 8. 传递性
-
-> Transitivity
-
-如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。
-
-# 十一、线程安全
-
-## 线程安全定义
-
-`一个类`在可以被`多个线程`安全调用时就是线程安全的。
-
-## 线程安全分类
-
-线程安全不是一个非真即假的命题，可以将共享数据按照安全程度的强弱顺序分成以下五类：`不可变`、`绝对线程安全`、`相对线程安全`、`线程兼容`和`线程对立`。
-
-### 1. 不可变
-
-`不可变（Immutable）`的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施，只要一个不可变的对象被正确地构建出来，那其外部的可见状态永远也不会改变，永远也不会看到它在多个线程之中处于不一致的状态。
-
-不可变的类型：
-
-- `final` 关键字修饰的基本数据类型；
-- `String`
-- `枚举类型`
-- `Number` 部分子类，如 `Long` 和 `Double` 等数值包装类型，`BigInteger` 和 `BigDecimal` 等大数据类型。但同为 Number 的子类型的原子类 `AtomicInteger` 和 `AtomicLong` 则并非不可变的。
-
-对于 `集合类型`，可以使用 `Collections.unmodifiableXXX()` 方法来获取一个不可变的集合。
-
-```java
-public class ImmutableExample {
-    public static void main(String[] args) {
-        Map<String, Integer> map = new HashMap<>();
-        Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(map);
-        unmodifiableMap.put("a", 1);
-    }
-}
-```
-
-```
-Exception in thread "main" java.lang.UnsupportedOperationException
-    at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
-    at ImmutableExample.main(ImmutableExample.java:9)
-```
-
-Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都`直接抛出异常`。
-
-```java
-public V put(K key, V value) {
-    throw new UnsupportedOperationException();
-}
-```
-
-多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
-
-### 2. 绝对线程安全
-
-不管运行时环境如何，调用者都不需要任何额外的同步措施。
-
-### 3. 相对线程安全
-
-相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
-
-在 Java 语言中，大部分的线程安全类都属于这种类型，例如 `Vector`、`HashTable`、Collections 的 `synchronizedCollection()` 方法包装的集合等。
-
-对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 `ArrayIndexOutOfBoundsException`。
-
-```java
-public class VectorUnsafeExample {
-    private static Vector<Integer> vector = new Vector<>();
-
-    public static void main(String[] args) {
-        while (true) {
-            for (int i = 0; i < 100; i++) {
-                vector.add(i);
-            }
-            ExecutorService executorService = Executors.newCachedThreadPool();
-            executorService.execute(() -> {
-                for (int i = 0; i < vector.size(); i++) {
-                    vector.remove(i);
-                }
-            });
-            executorService.execute(() -> {
-                for (int i = 0; i < vector.size(); i++) {
-                    vector.get(i);
-                }
-            });
-            executorService.shutdown();
-        }
-    }
-}
-```
-
-```html
-Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
-    at java.util.Vector.remove(Vector.java:831)
-    at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
-    at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
-    at java.lang.Thread.run(Thread.java:745)
-```
-
-
-如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。
-
-```java
-executorService.execute(() -> {
-    synchronized (vector) {
-        for (int i = 0; i < vector.size(); i++) {
-            vector.remove(i);
-        }
-    }
-});
-executorService.execute(() -> {
-    synchronized (vector) {
-        for (int i = 0; i < vector.size(); i++) {
-            vector.get(i);
-        }
-    }
-});
-```
-
-### 4. 线程兼容
-
-线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
-
-### 5. 线程对立
-
-线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
-
-## 线程安全的实现方法
-
-### 1. 互斥同步
-
-`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 的旧值，上述的处理过程是一个原子操作。
-
-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 是在一个循环中进行，发生冲突的做法是不断的进行重试。
-
-```java
-// 代码 1
-private AtomicInteger cnt = new AtomicInteger();
-
-public void add() {
-    cnt.incrementAndGet();
-}
-```
-
-```java
-// 代码 2
-public final int incrementAndGet() {
-    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
-}
-```
-
-```java
-// 代码 3
-public final int getAndAddInt(Object var1, long var2, int var4) {
-    int var5;
-    do {
-        var5 = this.getIntVolatile(var1, var2);
-    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
-
-    return var5;
-}
-```
-
-ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。J.U.C 包提供了一个带有标记的原子引用类“`AtomicStampedReference`”来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
-
-### 3. 无同步方案
-
-要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
-
-**（一）可重入代码（Reentrant Code）**
-
-这种代码也叫做`纯代码（Pure Code）`，可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
-
-可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
-
-**（二）栈封闭**
-
-多个线程访问同一个方法的`局部变量时`，不会出现线程安全问题，因为局部变量存储在栈中，属于`线程私有的`。
-
-```java
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-public class StackClosedExample {
-    public void add100() {
-        int cnt = 0;
-        for (int i = 0; i < 100; i++) {
-            cnt++;
-        }
-        System.out.println(cnt);
-    }
-}
-```
-
-```java
-public static void main(String[] args) {
-    StackClosedExample example = new StackClosedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> example.add100());
-    executorService.execute(() -> example.add100());
-    executorService.shutdown();
-}
-```
-
-```html
-100
-100
-```
-
-**（三）线程本地存储（Thread Local Storage）**
-
-如果一段代码中所需要的`数据`必须与其他`代码共享`，那就看看这些共享数据的代码是否能保证在`同一个线程中`执行。如果能保证，我们就可以把共享数据的可见范围限制在`同一个线程`之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
-
-符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
-
-可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
-
-对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
-
-```java
-public class ThreadLocalExample {
-    public static void main(String[] args) {
-        ThreadLocal threadLocal = new ThreadLocal();
-        Thread thread1 = new Thread(() -> {
-            threadLocal.set(1);
-            try {
-                Thread.sleep(1000);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.println(threadLocal.get());
-            threadLocal.remove();
-        });
-        Thread thread2 = new Thread(() -> {
-            threadLocal.set(2);
-            threadLocal.remove();
-        });
-        thread1.start();
-        thread2.start();
-    }
-}
-```
-
-```html
-1
-```
-
-为了理解 ThreadLocal，先看以下代码：
-
-```java
-public class ThreadLocalExample1 {
-    public static void main(String[] args) {
-        ThreadLocal threadLocal1 = new ThreadLocal();
-        ThreadLocal threadLocal2 = new ThreadLocal();
-        Thread thread1 = new Thread(() -> {
-            threadLocal1.set(1);
-            threadLocal2.set(1);
-        });
-        Thread thread2 = new Thread(() -> {
-            threadLocal1.set(2);
-            threadLocal2.set(2);
-        });
-        thread1.start();
-        thread2.start();
-    }
-}
-```
-
-它所对应的底层结构图为：
-
-<div align="center"> <img src="/image/02/Concurrent/3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/> </div><br>
-
-每个 Thread 都有一个 `ThreadLocal.ThreadLocalMap` 对象，Thread 类中就定义了 `ThreadLocal.ThreadLocalMap` 成员。
-
-```java
-/* ThreadLocal values pertaining to this thread. This map is maintained
- * by the ThreadLocal class. */
-ThreadLocal.ThreadLocalMap threadLocals = null;
-```
-
-当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 `ThreadLocalMap` 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。
-
-```java
-public void set(T value) {
-    Thread t = Thread.currentThread();
-    ThreadLocalMap map = getMap(t);
-    if (map != null)
-        map.set(this, value);
-    else
-        createMap(t, value);
-}
-```
-
-get() 方法类似。
-
-```java
-public T get() {
-    Thread t = Thread.currentThread();
-    ThreadLocalMap map = getMap(t);
-    if (map != null) {
-        ThreadLocalMap.Entry e = map.getEntry(this);
-        if (e != null) {
-            @SuppressWarnings("unchecked")
-            T result = (T)e.value;
-            return result;
-        }
-    }
-    return setInitialValue();
-}
-```
-
-ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，尽可能在每次使用 ThreadLocal 后手动调用 `remove()`，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
-
-# 十二、锁优化
-
-这里的锁优化主要是指虚拟机对 `synchronized` 的优化。
-
-## 自旋锁
-
-互斥同步的进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。`自旋锁的思想`是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
-
-自选锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。自旋次数的默认值是 10 次，用户可以使用虚拟机参数 `-XX:PreBlockSpin` 来更改。
-
-在 JDK 1.6 中引入了`自适应`的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
-
-## 锁消除
-
-锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。
-
-锁消除主要是通过逃逸分析来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们上的锁进行消除。
-
-对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：
-
-```java
-public static String concatString(String s1, String s2, String s3) {
-    return s1 + s2 + s3;
-}
-```
-
-String 是一个不可变的类，Javac 编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作，在 JDK 1.5 及以后的版本中，会转化为 StringBuilder 对象的连续 append() 操作，即上面的代码可能会变成下面的样子：
-
-```java
-public static String concatString(String s1, String s2, String s3) {
-    StringBuffer sb = new StringBuffer();
-    sb.append(s1);
-    sb.append(s2);
-    sb.append(s3);
-    return sb.toString();
-}
-```
-
-每个 StringBuffer.append() 方法中都有一个同步块，锁就是 `sb` 对象。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 `concatString()` 方法内部。也就是说，sb 的所有引用永远不会“逃逸”到 `concatString()` 方法之外，其他线程无法访问到它。因此，虽然这里有锁，但是可以被安全地消除掉。
-
-## 锁粗化
-
-如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。
-
-上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
-
-## 轻量级锁
-
-JDK 1.6 引入了`偏向锁`和`轻量级锁`，从而让锁拥有了四个状态：`无锁状态（unlocked）`、`偏向锁状态（biasble）`、`轻量级锁状态（lightweight locked）`和`重量级锁状态（inflated）`。
-
-以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 mark word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出，应该注意的是 state 表格不是存储在对象头中的。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
-
-<div align="center"> <img src="/image/02/Concurrent/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="600"/> </div><br>
-
-下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
-
-<div align="center"> <img src="/image/02/Concurrent/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/> </div><br>
-
-轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
-
-当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
-
-<div align="center"> <img src="/image/02/Concurrent/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="500"/> </div><br>
-
-如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
-
-## 偏向锁
-
-偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要。
-
-可以使用 `-XX:+UseBiasedLocking=true` 开启偏向锁，不过在 JDK 1.6 中它是默认开启的。
-
-当锁对象第一次被线程获得的时候，进入偏向状态，标记为 1 01。同时使用 CAS 操作将线程 ID 记录到 Mark Word 中，如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
-
-当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
-
-<div align="center"> <img src="/image/02/Concurrent/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/> </div><br>
-
-# 十三、多线程开发良好的实践
-
-- 给线程起个有意义的名字，这样可以方便找 Bug。
-
-- 缩小同步范围，例如对于 synchronized，应该尽量使用同步块而不是同步方法。
-
-- 多用同步类少用 `wait()` 和 `notify()`。首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现对复杂控制流的控制。其次，这些类是由最好的企业编写和维护，在后续的 JDK 中它们还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
-
-- 多用并发集合少用同步集合。并发集合比同步集合的可扩展性更好，例如应该使用 `ConcurrentHashMap` 而不是 `Hashtable。`
-
-- 使用本地变量和不可变类来保证线程安全。
-
-- `使用线程池`而不是直接创建 Thread 对象，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
-
-- 使用 `BlockingQueue` 实现生产者消费者问题。
-
-# 参考资料
-
-- BruceEckel. Java 编程思想: 第 4 版 [M]. 机械工业出版社, 2007.
-- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
-- [Threads and Locks](https://docs.oracle.com/javase/specs/jvms/se6/html/Threads.doc.html)
-- [线程通信](http://ifeve.com/thread-signaling/#missed_signal)
-- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
-- [BlockingQueue](http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html)
-- [thread state java](https://stackoverflow.com/questions/11265289/thread-state-java)
-- [CSC 456 Spring 2012/ch7 MN](http://wiki.expertiza.ncsu.edu/index.php/CSC_456_Spring_2012/ch7_MN)
-- [Java - Understanding Happens-before relationship](https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/happens-before.html)
-- [6장 Thread Synchronization](https://www.slideshare.net/novathinker/6-thread-synchronization)
-- [How is Java's ThreadLocal implemented under the hood?](https://stackoverflow.com/questions/1202444/how-is-javas-threadlocal-implemented-under-the-hood/15653015)
-- [Concurrent](https://sites.google.com/site/webdevelopart/21-compile/06-java/javase/concurrent?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F&showPrintDialog=1)
-- [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
-- [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
-- [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
+<!-- GFM-TOC -->
+* [一、线程状态转换](#一线程状态转换)
+    * [新建（New）](#新建new)
+    * [可运行（Runnable）](#可运行runnable)
+    * [阻塞（Blocking）](#阻塞blocking)
+    * [无限期等待（Waiting）](#无限期等待waiting)
+    * [限期等待（Timed Waiting）](#限期等待timed-waiting)
+    * [死亡（Terminated）](#死亡terminated)
+* [二、使用线程](#二使用线程)
+    * [实现 Runnable 接口](#实现-runnable-接口)
+    * [实现 Callable 接口](#实现-callable-接口)
+    * [继承 Thread 类](#继承-thread-类)
+    * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
+* [三、基础线程机制](#三基础线程机制)
+    * [Executor](#executor)
+    * [Daemon](#daemon)
+    * [sleep()](#sleep)
+    * [yield()](#yield)
+* [四、中断](#四中断)
+    * [InterruptedException](#interruptedexception)
+    * [interrupted()](#interrupted)
+    * [Executor 的中断操作](#executor-的中断操作)
+* [五、互斥同步](#五互斥同步)
+    * [synchronized](#synchronized)
+    * [ReentrantLock](#reentrantlock)
+    * [synchronized 和 ReentrantLock 比较](#synchronized-和-reentrantlock-比较)
+* [六、线程之间的协作](#六线程之间的协作)
+    * [join()](#join)
+    * [wait() notify() notifyAll()](#wait-notify-notifyall)
+    * [await() signal() signalAll()](#await-signal-signalall)
+* [七、J.U.C - AQS](#七juc---aqs)
+    * [CountdownLatch](#countdownlatch)
+    * [CyclicBarrier](#cyclicbarrier)
+    * [Semaphore](#semaphore)
+* [八、J.U.C - 其它组件](#八juc---其它组件)
+    * [FutureTask](#futuretask)
+    * [BlockingQueue](#blockingqueue)
+    * [ForkJoin](#forkjoin)
+* [九、线程不安全示例](#九线程不安全示例)
+* [十、Java 内存模型](#十java-内存模型)
+    * [主内存与工作内存](#主内存与工作内存)
+    * [内存间交互操作](#内存间交互操作)
+    * [内存模型三大特性](#内存模型三大特性)
+    * [先行发生原则](#先行发生原则)
+* [十一、线程安全](#十一线程安全)
+    * [线程安全定义](#线程安全定义)
+    * [线程安全分类](#线程安全分类)
+    * [线程安全的实现方法](#线程安全的实现方法)
+* [十二、锁优化](#十二锁优化)
+    * [自旋锁](#自旋锁)
+    * [锁消除](#锁消除)
+    * [锁粗化](#锁粗化)
+    * [轻量级锁](#轻量级锁)
+    * [偏向锁](#偏向锁)
+* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、线程状态转换
+
+<div align="center"> <img src="/image/02/Concurrent/ace830df-9919-48ca-91b5-60b193f593d2.png" width=""/> </div><br>
+
+## 新建（New）
+
+创建后尚未启动。
+
+## 可运行（Runnable）
+
+可能正在运行，也可能正在等待 CPU 时间片。
+
+包含了操作系统线程状态中的 `Running` 和 `Ready`。
+
+## 阻塞（Blocking）
+
+等待获取一个`排它锁`，如果其线程释放了锁就会结束此状态。
+
+## 无限期等待（Waiting）
+
+等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
+
+| 进入方法 | 退出方法 |
+| --- | --- |
+| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
+| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
+| LockSupport.park() 方法 | - |
+
+## 限期等待（Timed Waiting）
+
+无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
+
+调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
+
+调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
+
+睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
+
+阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁；而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
+
+| 进入方法 | 退出方法 |
+| --- | --- |
+| Thread.sleep() 方法 | 时间结束 |
+| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll()  |
+| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
+| LockSupport.parkNanos() 方法 | - |
+| LockSupport.parkUntil() 方法 | - |
+
+## 死亡（Terminated）
+
+可以是线程结束任务之后自己结束，或者产生了异常而结束。
+
+# 二、使用线程
+
+有三种使用线程的方法：
+
+* 实现 `Runnable` 接口；
+* 实现 `Callable` 接口；
+* 继承 `Thread` 类。
+
+实现 `Runnable` 和 `Callable` 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
+
+## 实现 Runnable 接口
+
+需要实现 run() 方法。
+
+通过 Thread 调用 start() 方法来启动线程。
+
+```java
+public class MyRunnable implements Runnable {
+    public void run() {
+        // ...
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    MyRunnable instance = new MyRunnable();
+    Thread thread = new Thread(instance);
+    thread.start();
+}
+```
+
+## 实现 Callable 接口
+
+与 Runnable 相比，Callable 可以有返回值，返回值通过 `FutureTask` 进行封装。
+
+```java
+public class MyCallable implements Callable<Integer> {
+    public Integer call() {
+        return 123;
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+    MyCallable mc = new MyCallable();
+    FutureTask<Integer> ft = new FutureTask<>(mc);
+    Thread thread = new Thread(ft);
+    thread.start();
+    System.out.println(ft.get());
+}
+```
+
+## 继承 Thread 类
+
+同样也是需要实现 run() 方法，并且最后也是调用 start() 方法来启动线程。
+
+```java
+public class MyThread extends Thread {
+    public void run() {
+        // ...
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    MyThread mt = new MyThread();
+    mt.start();
+}
+```
+
+## 实现接口 VS 继承 Thread
+
+实现接口会更好一些，因为：
+
+- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
+
+# 三、基础线程机制
+
+## Executor
+
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。
+
+主要有三种 Executor：
+
+- CachedThreadPool：一个任务创建一个线程；
+- FixedThreadPool：所有任务只能使用固定大小的线程；
+- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
+
+```java
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < 5; i++) {
+        executorService.execute(new MyRunnable());
+    }
+    executorService.shutdown();
+}
+```
+
+## Daemon
+
+守护线程是 **程序运行时在后台提供服务的线程**，不属于程序中不可或缺的部分。
+
+当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
+
+main() 属于非守护线程。
+
+使用 setDaemon() 方法将一个线程设置为守护线程。
+
+```java
+public static void main(String[] args) {
+    Thread thread = new Thread(new MyRunnable());
+    thread.setDaemon(true);
+}
+```
+
+## sleep()
+
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+
+sleep() 可能会抛出 `InterruptedException`，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+
+```java
+public void run() {
+    try {
+        Thread.sleep(3000);
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    }
+}
+```
+
+## yield()
+
+对静态方法 Thread.yield() 的调用声明了 **当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行**。该方法只是对线程调度器的一个建议，而且也只是建议具有 **相同优先级** 的其它线程可以运行。
+
+```java
+public void run() {
+    Thread.yield();
+}
+```
+
+# 四、中断
+
+一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
+
+## InterruptedException
+
+通过调用一个线程的 `interrupt()` 来中断该线程，如果该线程处于`阻塞`、`限期等待`或者`无限期等待`状态，那么就会抛出 `InterruptedException`，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
+
+对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
+
+```java
+public class InterruptExample {
+
+    private static class MyThread1 extends Thread {
+        @Override
+        public void run() {
+            try {
+                Thread.sleep(2000);
+                System.out.println("Thread run");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+    Thread thread1 = new MyThread1();
+    thread1.start();
+    thread1.interrupt();
+    System.out.println("Main run");
+}
+```
+
+```html
+Main run
+java.lang.InterruptedException: sleep interrupted
+    at java.lang.Thread.sleep(Native Method)
+    at InterruptExample.lambda$main$0(InterruptExample.java:5)
+    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+    at java.lang.Thread.run(Thread.java:745)
+```
+
+## interrupted()
+
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 `InterruptedException` 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+
+```java
+public class InterruptExample {
+
+    private static class MyThread2 extends Thread {
+        @Override
+        public void run() {
+            while (!interrupted()) {
+                // ..
+            }
+            System.out.println("Thread end");
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+    Thread thread2 = new MyThread2();
+    thread2.start();
+    thread2.interrupt();
+}
+```
+
+```html
+Thread end
+```
+
+## Executor 的中断操作
+
+调用 Executor 的 `shutdown()` 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 `shutdownNow()` 方法，则相当于调用每个线程的 `interrupt()` 方法。
+
+以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
+
+```java
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> {
+        try {
+            Thread.sleep(2000);
+            System.out.println("Thread run");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    });
+    executorService.shutdownNow();
+    System.out.println("Main run");
+}
+```
+
+```html
+Main run
+java.lang.InterruptedException: sleep interrupted
+    at java.lang.Thread.sleep(Native Method)
+    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
+    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
+    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
+    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
+    at java.lang.Thread.run(Thread.java:745)
+```
+
+如果只想中断 Executor 中的一个线程，可以通过使用 `submit()` 方法来提交一个线程，它会返回一个 `Future<?>` 对象，通过调用该对象的 `cancel(true)` 方法就可以中断线程。
+
+```java
+Future<?> future = executorService.submit(() -> {
+    // ..
+});
+future.cancel(true);
+```
+
+# 五、互斥同步
+
+Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
+
+## synchronized
+
+**1. 同步一个代码块**
+
+```java
+public void func () {
+    synchronized (this) {
+        // ...
+    }
+}
+```
+
+它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
+
+对于以下代码，使用 ExecutorService 执行了两个线程（这两个线程使用 Lambda 创建），由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
+
+```java
+public class SynchronizedExample {
+
+    public void func1() {
+        synchronized (this) {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func1());
+    executorService.execute(() -> e1.func1());
+}
+```
+
+```html
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+```
+
+对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
+
+```java
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    SynchronizedExample e2 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func1());
+    executorService.execute(() -> e2.func1());
+}
+```
+
+```html
+0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
+```
+
+
+**2. 同步一个方法**
+
+```java
+public synchronized void func () {
+    // ...
+}
+```
+
+它和同步代码块一样，只作用于同一个对象。
+
+**3. 同步一个类**
+
+```java
+public void func() {
+    synchronized (SynchronizedExample.class) {
+        // ...
+    }
+}
+```
+
+**作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也需要进行同步。**
+
+```java
+public class SynchronizedExample {
+
+    public void func2() {
+        synchronized (SynchronizedExample.class) {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    SynchronizedExample e2 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func2());
+    executorService.execute(() -> e2.func2());
+}
+```
+
+```html
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+```
+
+**4. 同步一个静态方法**
+
+```java
+public synchronized static void fun() {
+    // ...
+}
+```
+
+作用于整个类。
+
+## ReentrantLock
+
+```java
+public class LockExample {
+
+    private Lock lock = new ReentrantLock();
+
+    public void func() {
+        lock.lock();
+        try {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        } finally {
+            lock.unlock(); // 确保释放锁，从而避免发生死锁。
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    LockExample lockExample = new LockExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> lockExample.func());
+    executorService.execute(() -> lockExample.func());
+}
+```
+
+```html
+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）包中的锁，
+**ReentrantLock 相比于 synchronized**，它多了以下高级功能：
+
+**1. 等待可中断**
+
+当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
+
+**2. 可实现公平锁**
+
+公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
+
+**3. 锁绑定多个条件**
+
+一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。
+
+## synchronized 和 ReentrantLock 比较
+
+**1. 锁的实现**
+
+synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
+
+**2. 性能**
+
+从性能上来看，新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等。目前来看它和 ReentrantLock 的性能基本持平了，因此性能因素不再是选择 ReentrantLock 的理由。synchronized 有更大的性能优化空间，应该优先考虑 synchronized。
+
+**3. 功能**
+
+ReentrantLock 多了一些高级功能。
+
+**4. 使用选择**
+
+除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
+
+# 六、线程之间的协作
+
+当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
+
+## join()
+
+在线程中调用另一个线程的 `join()` 方法，会将当前线程挂起，而不是忙等待， 直到目标线程结束。
+
+对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，因此 b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先与 b 线程的输出。
+
+```java
+public class JoinExample {
+
+    private class A extends Thread {
+        @Override
+        public void run() {
+            System.out.println("A");
+        }
+    }
+
+    private class B extends Thread {
+
+        private A a;
+
+        B(A a) {
+            this.a = a;
+        }
+
+        @Override
+        public void run() {
+            try {
+                a.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println("B");
+        }
+    }
+
+    public void test() {
+        A a = new A();
+        B b = new B(a);
+        b.start();
+        a.start();
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    JoinExample example = new JoinExample();
+    example.test();
+}
+```
+
+```
+A
+B
+```
+
+## wait() notify() notifyAll()
+
+调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
+
+它们都属于 Object 的一部分，而不属于 Thread。
+
+只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 **IllegalMonitorStateExeception**。
+
+使用 wait() 挂起期间，线程会 **释放锁**。这是 **因为**，如果 **没有释放锁**，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就 **无法执行** **notify()** 或者 **notifyAll()** 来唤醒挂起的线程，造成死锁。
+
+```java
+public class WaitNotifyExample {
+    public synchronized void before() {
+        System.out.println("before");
+        notifyAll();
+    }
+
+    public synchronized void after() {
+        try {
+            wait();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println("after");
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    WaitNotifyExample example = new WaitNotifyExample();
+    executorService.execute(() -> example.after());
+    executorService.execute(() -> example.before());
+}
+```
+
+```html
+before
+after
+```
+
+**wait() 和 sleep() 的区别**
+
+1. wait() 是 Object 的方法，而 sleep() 是 Thread 的 **静态方法**；
+2. wait() 会释放锁，sleep() 不会。
+
+## await() signal() signalAll()
+
+java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
+
+使用 Lock 来获取一个 Condition 对象。
+
+```java
+public class AwaitSignalExample {
+    private Lock lock = new ReentrantLock();
+    private Condition condition = lock.newCondition();
+
+    public void before() {
+        lock.lock();
+        try {
+            System.out.println("before");
+            condition.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public void after() {
+        lock.lock();
+        try {
+            condition.await();
+            System.out.println("after");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    AwaitSignalExample example = new AwaitSignalExample();
+    executorService.execute(() -> example.after());
+    executorService.execute(() -> example.before());
+}
+```
+
+```html
+before
+after
+```
+
+# 七、J.U.C - AQS
+
+java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
+
+## CountdownLatch
+
+用来控制 **一个线程等待多个线程** 。
+
+维护了一个计数器 `cnt`，每次调用 `countDown()` 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 `await()` 方法而在等待的线程就会被唤醒。
+
+<div align="center"> <img src="/image/02/Concurrent/CountdownLatch.png" width=""/> </div><br>
+
+```java
+public class CountdownLatchExample {
+
+    public static void main(String[] args) throws InterruptedException {
+        final int totalThread = 10;
+        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalThread; i++) {
+            executorService.execute(() -> {
+                System.out.print("run..");
+                countDownLatch.countDown();
+            });
+        }
+        countDownLatch.await();
+        System.out.println("end");
+        executorService.shutdown();
+    }
+}
+```
+
+```html
+run..run..run..run..run..run..run..run..run..run..end
+```
+
+## CyclicBarrier
+
+用来控制 **多个线程互相等待**，只有当多个线程都到达时，这些线程才会继续执行。
+
+和 CountdownLatch 相似，都是通过维护计数器来实现的。但是它的计数器是递增的，每次执行 `await()` 方法之后，计数器会加 1，直到计数器的值和设置的值相等，等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 的计数器可以`循环使用`，所以它才叫做循环屏障。
+
+下图应该从下往上看才正确。
+
+<div align="center"> <img src="/image/02/Concurrent/CyclicBarrier.png" width=""/> </div><br>
+
+```java
+public class CyclicBarrierExample {
+    public static void main(String[] args) throws InterruptedException {
+        final int totalThread = 10;
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalThread; i++) {
+            executorService.execute(() -> {
+                System.out.print("before..");
+                try {
+                    cyclicBarrier.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } catch (BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+                System.out.print("after..");
+            });
+        }
+        executorService.shutdown();
+    }
+}
+```
+
+```html
+before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..
+```
+
+## Semaphore
+
+Semaphore 就是操作系统中的信号量，可以 **控制对互斥资源的访问线程数**。
+
+<div align="center"> <img src="/image/02/Concurrent/Semaphore.png" width=""/> </div><br>
+
+以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。
+
+```java
+public class SemaphoreExample {
+    public static void main(String[] args) {
+        final int clientCount = 3;
+        final int totalRequestCount = 10;
+        Semaphore semaphore = new Semaphore(clientCount);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalRequestCount; i++) {
+            executorService.execute(()->{
+                try {
+                    semaphore.acquire();
+                    System.out.print(semaphore.availablePermits() + " ");
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    semaphore.release();
+                }
+            });
+        }
+        executorService.shutdown();
+    }
+}
+```
+
+```html
+2 1 2 2 2 2 2 1 2 2
+```
+
+# 八、J.U.C - 其它组件
+
+## FutureTask
+
+在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future<V> 进行封装。FutureTask 实现了 `RunnableFuture` 接口，该接口继承自 `Runnable` 和 `Future<V>` 接口，这使得 `FutureTask` 既可以当做一个任务执行，也可以有返回值。
+
+```
+public class FutureTask<V> implements RunnableFuture<V>
+```
+
+```
+public interface RunnableFuture<V> extends Runnable, Future<V>
+```
+
+**当一个计算任务需要执行很长时间**，那么就可以用 FutureTask 来封装这个任务，用一个线程去执行该任务，然后其它线程继续执行其它任务。当需要该任务的计算结果时，再通过 FutureTask 的 get() 方法获取。
+
+```java
+public class FutureTaskExample {
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
+            @Override
+            public Integer call() throws Exception {
+                int result = 0;
+                for (int i = 0; i < 100; i++) {
+                    Thread.sleep(10);
+                    result += i;
+                }
+                return result;
+            }
+        });
+
+        Thread computeThread = new Thread(futureTask);
+        computeThread.start();
+
+        Thread otherThread = new Thread(() -> {
+            System.out.println("other task is running...");
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+        otherThread.start();
+        System.out.println(futureTask.get());
+    }
+}
+```
+
+```html
+other task is running...
+4950
+```
+
+## BlockingQueue
+
+java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
+
+-  **FIFO 队列** ：`LinkedBlockingQueue`、`ArrayListBlockingQueue`（固定长度）
+-  **优先级队列** ：`PriorityBlockingQueue`
+
+提供了阻塞的 `take()` 和 `put()` 方法：如果队列为空 `take()` 将阻塞，直到队列中有内容；如果队列为满 `put()` 将阻塞，指到队列有空闲位置。
+
+**使用 BlockingQueue 实现生产者消费者问题**
+
+```java
+public class ProducerConsumer {
+
+    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
+
+    private static class Producer extends Thread {
+        @Override
+        public void run() {
+            try {
+                queue.put("product");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.print("produce..");
+        }
+    }
+
+    private static class Consumer extends Thread {
+
+        @Override
+        public void run() {
+            try {
+                String product = queue.take();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.print("consume..");
+        }
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    for (int i = 0; i < 2; i++) {
+        Producer producer = new Producer();
+        producer.start();
+    }
+    for (int i = 0; i < 5; i++) {
+        Consumer consumer = new Consumer();
+        consumer.start();
+    }
+    for (int i = 0; i < 3; i++) {
+        Producer producer = new Producer();
+        producer.start();
+    }
+}
+```
+
+```html
+produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
+```
+
+## ForkJoin
+
+主要用于并行计算中，和 MapReduce 原理类似，都是 把 **大的计算任务** **拆分** 成 **多个小任务** **并行计算**。
+
+```java
+public class ForkJoinExample extends RecursiveTask<Integer> {
+    private final int threhold = 5;
+    private int first;
+    private int last;
+
+    public ForkJoinExample(int first, int last) {
+        this.first = first;
+        this.last = last;
+    }
+
+    @Override
+    protected Integer compute() {
+        int result = 0;
+        if (last - first <= threhold) {
+            // 任务足够小则直接计算
+            for (int i = first; i <= last; i++) {
+                result += i;
+            }
+        } else {
+            // 拆分成小任务
+            int middle = first + (last - first) / 2;
+            ForkJoinExample leftTask = new ForkJoinExample(first, middle);
+            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
+            leftTask.fork();
+            rightTask.fork();
+            result = leftTask.join() + rightTask.join();
+        }
+        return result;
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+    ForkJoinExample example = new ForkJoinExample(1, 10000);
+    ForkJoinPool forkJoinPool = new ForkJoinPool();
+    Future result = forkJoinPool.submit(example);
+    System.out.println(result.get());
+}
+```
+
+ForkJoin 使用 `ForkJoinPool` 来启动，它是一个特殊的线程池，`线程数量取决于 CPU 核数`。
+
+```
+public class ForkJoinPool extends AbstractExecutorService
+```
+
+ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
+
+<div align="center"> <img src="/image/02/Concurrent/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg" width=""/> </div><br>
+
+# 九、线程不安全示例
+
+如果 **多个线程对同一个共享数据进行访问而不采取同步操作** 的话，那么操作的结果是不一致的。
+
+以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值为 997 而不是 1000。
+
+```java
+public class ThreadUnsafeExample {
+
+    private int cnt = 0;
+
+    public void add() {
+        cnt++;
+    }
+
+    public int get() {
+        return cnt;
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    ThreadUnsafeExample example = new ThreadUnsafeExample();
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
+}
+```
+
+```html
+997
+```
+
+# 十、Java 内存模型
+
+Java 内存模型试图 **屏蔽各种硬件和操作系统的内存访问差异**，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
+
+## 主内存与工作内存
+
+处理器上的寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了 **高速缓存**。
+
+加入高速缓存带来了一个新的问题：**缓存一致性**。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
+
+<div align="center"> <img src="/image/02/Concurrent/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png" width=""/> </div><br>
+
+所有的变量都存储在`主内存`中，每个线程还有自己的`工作内存`，`工作内存`存储在高速缓存或者寄存器中，保存了该线程使用的变量的`主内存`副本拷贝。
+
+线程只能直接操作`工作内存`中的变量，不同线程之间的变量值传递需要通过`主内存`来完成。
+
+<div align="center"> <img src="/image/02/Concurrent/47358f87-bc4c-496f-9a90-8d696de94cee.png" width=""/> </div><br>
+
+## 内存间交互操作
+
+Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
+
+<div align="center"> <img src="/image/02/Concurrent/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png" width=""/> </div><br>
+
+- `read`：把一个变量的值从`主内存`传输到`工作内存`中
+- `load`：在 read 之后执行，把 read 得到的值放入`工作内存`的变量副本中
+- `use`：把`工作内存`中一个变量的值传递给`执行引擎`
+- `assign`：把一个从`执行引擎`接收到的值赋给`工作内存`的变量
+- `store`：把`工作内存`的一个变量的值传送到`主内存`中
+- `write`：在 store 之后执行，把 store 得到的值放入`主内存`的变量中
+- `lock`：作用于`主内存`的变量
+- `unlock`
+
+## 内存模型三大特性
+
+### 1. 原子性
+
+Java 内存模型保证了 `read`、`load`、`use`、`assign`、`store`、`write`、`lock` 和 `unlock` 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
+
+有一个错误认识就是，int 等原子性的变量在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 变量属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
+
+为了方便讨论，将内存间的交互操作简化为 3 个：`load`、`assign`、`store`。
+
+下图演示了两个线程同时对 cnt 变量进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入该变量的值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足 `原子性`只是说明 load、assign、store 这些单个操作具备原子性。
+
+<div align="center"> <img src="/image/02/Concurrent/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png" width=""/> </div><br>
+
+AtomicInteger 能保证多个线程修改的原子性。
+
+<div align="center"> <img src="/image/02/Concurrent/952afa9a-458b-44ce-bba9-463e60162945.png" width=""/> </div><br>
+
+使用 **AtomicInteger** 重写之前线程不安全的代码之后得到以下线程安全实现：
+
+```java
+public class AtomicExample {
+    private AtomicInteger cnt = new AtomicInteger();
+
+    public void add() {
+        cnt.incrementAndGet();
+    }
+
+    public int get() {
+        return cnt.get();
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    AtomicExample example = new AtomicExample(); // 只修改这条语句
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
+}
+```
+
+```html
+1000
+```
+
+除了使用原子类之外，也可以使用 `synchronized` 互斥锁来保证操作的完整性，它对应的内存间交互操作为：`lock` 和 `unlock`，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
+
+```java
+public class AtomicSynchronizedExample {
+    private int cnt = 0;
+
+    public synchronized void add() {
+        cnt++;
+    }
+
+    public synchronized int get() {
+        return cnt;
+    }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    AtomicSynchronizedExample example = new AtomicSynchronizedExample();
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
+}
+```
+
+```html
+1000
+```
+
+### 2. 可见性
+
+可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量`修改后`将新值`同步`回`主内存`，在变量读取前从主内存刷新变量值来实现`可见性`的。
+
+`volatile` 可保证可见性。`synchronized` 也能够保证可见性，对一个变量执行 `unlock` 操作之前，必须把变量值同步回`主内存`。`final` 关键字也能保证可见性：被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程可以通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
+
+对前面的线程不安全示例中的 cnt 变量用 volatile 修饰，不能解决线程不安全问题，因为 `volatile` 并`不能`保证操作的 `原子性`。
+
+### 3. 有序性
+
+有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了`指令重排序`。
+
+在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程`不会影响`到`单线程`程序的执行，却会`影响`到`多线程并发执行`的正确性。
+
+`volatile` 关键字通过添加内存屏障的方式来 `禁止指令重排`，即重排序时不能把后面的指令放到内存屏障之前。
+
+也可以通过 `synchronized` 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让`线程顺序执行同步代码`。
+
+## 先行发生原则
+
+上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
+
+主要有以下这些原则：
+
+### 1. 单一线程原则
+
+> Single Thread rule
+
+在一个线程内，在程序 **前面的操作** **先行发生于后面的操作**。
+
+<div align="center"> <img src="/image/02/Concurrent/single-thread-rule.png" width=""/> </div><br>
+
+### 2. 管程锁定规则
+
+> Monitor Lock Rule
+
+一个 unlock 操作 **先行发生于后面对同一个锁的 lock 操作**。
+
+<div align="center"> <img src="/image/02/Concurrent/monitor-lock-rule.png" width=""/> </div><br>
+
+### 3. volatile 变量规则
+
+> Volatile Variable Rule
+
+对一个 volatile 变量的 **写操作**  **先行发生于后面对这个变量的读操作**。
+
+<div align="center"> <img src="/image/02/Concurrent/volatile-variable-rule.png" width=""/> </div><br>
+
+### 4. 线程启动规则
+
+> Thread Start Rule
+
+Thread 对象的 start() 方法调用 **先行发生于此线程的每一个动作**。
+
+<div align="center"> <img src="/image/02/Concurrent/thread-start-rule.png" width=""/> </div><br>
+
+### 5. 线程加入规则
+
+> Thread Join Rule
+
+join() 方法返回 **先行发生于 Thread 对象的结束**。
+
+<div align="center"> <img src="/image/02/Concurrent/thread-join-rule.png" width=""/> </div><br>
+
+### 6. 线程中断规则
+
+> Thread Interruption Rule
+
+对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 `Thread.interrupted()` 方法检测到是否有中断发生。
+
+### 7. 对象终结规则
+
+> Finalizer Rule
+
+一个对象的初始化完成（构造函数执行结束）先行发生于它的 `finalize()` 方法的开始。
+
+### 8. 传递性
+
+> Transitivity
+
+如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。
+
+# 十一、线程安全
+
+## 线程安全定义
+
+`一个类`在可以被`多个线程`安全调用时就是线程安全的。
+
+## 线程安全分类
+
+线程安全不是一个非真即假的命题，可以将共享数据按照安全程度的强弱顺序分成以下五类：`不可变`、`绝对线程安全`、`相对线程安全`、`线程兼容`和`线程对立`。
+
+### 1. 不可变
+
+`不可变（Immutable）`的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施，只要一个不可变的对象被正确地构建出来，那其外部的可见状态永远也不会改变，永远也不会看到它在多个线程之中处于不一致的状态。
+
+不可变的类型：
+
+- `final` 关键字修饰的基本数据类型；
+- `String`
+- `枚举类型`
+- `Number` 部分子类，如 `Long` 和 `Double` 等数值包装类型，`BigInteger` 和 `BigDecimal` 等大数据类型。但同为 Number 的子类型的原子类 `AtomicInteger` 和 `AtomicLong` 则并非不可变的。
+
+对于 `集合类型`，可以使用 `Collections.unmodifiableXXX()` 方法来获取一个不可变的集合。
+
+```java
+public class ImmutableExample {
+    public static void main(String[] args) {
+        Map<String, Integer> map = new HashMap<>();
+        Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(map);
+        unmodifiableMap.put("a", 1);
+    }
+}
+```
+
+```
+Exception in thread "main" java.lang.UnsupportedOperationException
+    at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
+    at ImmutableExample.main(ImmutableExample.java:9)
+```
+
+Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都`直接抛出异常`。
+
+```java
+public V put(K key, V value) {
+    throw new UnsupportedOperationException();
+}
+```
+
+多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
+
+### 2. 绝对线程安全
+
+不管运行时环境如何，调用者都不需要任何额外的同步措施。
+
+### 3. 相对线程安全
+
+相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
+
+在 Java 语言中，大部分的线程安全类都属于这种类型，例如 `Vector`、`HashTable`、Collections 的 `synchronizedCollection()` 方法包装的集合等。
+
+对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 `ArrayIndexOutOfBoundsException`。
+
+```java
+public class VectorUnsafeExample {
+    private static Vector<Integer> vector = new Vector<>();
+
+    public static void main(String[] args) {
+        while (true) {
+            for (int i = 0; i < 100; i++) {
+                vector.add(i);
+            }
+            ExecutorService executorService = Executors.newCachedThreadPool();
+            executorService.execute(() -> {
+                for (int i = 0; i < vector.size(); i++) {
+                    vector.remove(i);
+                }
+            });
+            executorService.execute(() -> {
+                for (int i = 0; i < vector.size(); i++) {
+                    vector.get(i);
+                }
+            });
+            executorService.shutdown();
+        }
+    }
+}
+```
+
+```html
+Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
+    at java.util.Vector.remove(Vector.java:831)
+    at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
+    at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
+    at java.lang.Thread.run(Thread.java:745)
+```
+
+
+如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。
+
+```java
+executorService.execute(() -> {
+    synchronized (vector) {
+        for (int i = 0; i < vector.size(); i++) {
+            vector.remove(i);
+        }
+    }
+});
+executorService.execute(() -> {
+    synchronized (vector) {
+        for (int i = 0; i < vector.size(); i++) {
+            vector.get(i);
+        }
+    }
+});
+```
+
+### 4. 线程兼容
+
+线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
+
+### 5. 线程对立
+
+线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
+
+## 线程安全的实现方法
+
+### 1. 互斥同步
+
+`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 的旧值，上述的处理过程是一个原子操作。
+
+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 是在一个循环中进行，发生冲突的做法是不断的进行重试。
+
+```java
+// 代码 1
+private AtomicInteger cnt = new AtomicInteger();
+
+public void add() {
+    cnt.incrementAndGet();
+}
+```
+
+```java
+// 代码 2
+public final int incrementAndGet() {
+    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+}
+```
+
+```java
+// 代码 3
+public final int getAndAddInt(Object var1, long var2, int var4) {
+    int var5;
+    do {
+        var5 = this.getIntVolatile(var1, var2);
+    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+
+    return var5;
+}
+```
+
+ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。J.U.C 包提供了一个带有标记的原子引用类“`AtomicStampedReference`”来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+
+### 3. 无同步方案
+
+要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
+
+**（一）可重入代码（Reentrant Code）**
+
+这种代码也叫做`纯代码（Pure Code）`，可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
+
+可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
+
+**（二）栈封闭**
+
+多个线程访问同一个方法的`局部变量时`，不会出现线程安全问题，因为局部变量存储在栈中，属于`线程私有的`。
+
+```java
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class StackClosedExample {
+    public void add100() {
+        int cnt = 0;
+        for (int i = 0; i < 100; i++) {
+            cnt++;
+        }
+        System.out.println(cnt);
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+    StackClosedExample example = new StackClosedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> example.add100());
+    executorService.execute(() -> example.add100());
+    executorService.shutdown();
+}
+```
+
+```html
+100
+100
+```
+
+**（三）线程本地存储（Thread Local Storage）**
+
+如果一段代码中所需要的`数据`必须与其他`代码共享`，那就看看这些共享数据的代码是否能保证在`同一个线程中`执行。如果能保证，我们就可以把共享数据的可见范围限制在`同一个线程`之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
+
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+
+可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
+
+对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
+
+```java
+public class ThreadLocalExample {
+    public static void main(String[] args) {
+        ThreadLocal threadLocal = new ThreadLocal();
+        Thread thread1 = new Thread(() -> {
+            threadLocal.set(1);
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println(threadLocal.get());
+            threadLocal.remove();
+        });
+        Thread thread2 = new Thread(() -> {
+            threadLocal.set(2);
+            threadLocal.remove();
+        });
+        thread1.start();
+        thread2.start();
+    }
+}
+```
+
+```html
+1
+```
+
+为了理解 ThreadLocal，先看以下代码：
+
+```java
+public class ThreadLocalExample1 {
+    public static void main(String[] args) {
+        ThreadLocal threadLocal1 = new ThreadLocal();
+        ThreadLocal threadLocal2 = new ThreadLocal();
+        Thread thread1 = new Thread(() -> {
+            threadLocal1.set(1);
+            threadLocal2.set(1);
+        });
+        Thread thread2 = new Thread(() -> {
+            threadLocal1.set(2);
+            threadLocal2.set(2);
+        });
+        thread1.start();
+        thread2.start();
+    }
+}
+```
+
+它所对应的底层结构图为：
+
+<div align="center"> <img src="/image/02/Concurrent/3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/> </div><br>
+
+每个 Thread 都有一个 `ThreadLocal.ThreadLocalMap` 对象，Thread 类中就定义了 `ThreadLocal.ThreadLocalMap` 成员。
+
+```java
+/* ThreadLocal values pertaining to this thread. This map is maintained
+ * by the ThreadLocal class. */
+ThreadLocal.ThreadLocalMap threadLocals = null;
+```
+
+当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 `ThreadLocalMap` 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。
+
+```java
+public void set(T value) {
+    Thread t = Thread.currentThread();
+    ThreadLocalMap map = getMap(t);
+    if (map != null)
+        map.set(this, value);
+    else
+        createMap(t, value);
+}
+```
+
+get() 方法类似。
+
+```java
+public T get() {
+    Thread t = Thread.currentThread();
+    ThreadLocalMap map = getMap(t);
+    if (map != null) {
+        ThreadLocalMap.Entry e = map.getEntry(this);
+        if (e != null) {
+            @SuppressWarnings("unchecked")
+            T result = (T)e.value;
+            return result;
+        }
+    }
+    return setInitialValue();
+}
+```
+
+ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，尽可能在每次使用 ThreadLocal 后手动调用 `remove()`，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
+
+# 十二、锁优化
+
+这里的锁优化主要是指虚拟机对 `synchronized` 的优化。
+
+## 自旋锁
+
+互斥同步的进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。`自旋锁的思想`是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
+
+自选锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。自旋次数的默认值是 10 次，用户可以使用虚拟机参数 `-XX:PreBlockSpin` 来更改。
+
+在 JDK 1.6 中引入了`自适应`的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
+
+## 锁消除
+
+锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。
+
+锁消除主要是通过逃逸分析来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们上的锁进行消除。
+
+对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：
+
+```java
+public static String concatString(String s1, String s2, String s3) {
+    return s1 + s2 + s3;
+}
+```
+
+String 是一个不可变的类，Javac 编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作，在 JDK 1.5 及以后的版本中，会转化为 StringBuilder 对象的连续 append() 操作，即上面的代码可能会变成下面的样子：
+
+```java
+public static String concatString(String s1, String s2, String s3) {
+    StringBuffer sb = new StringBuffer();
+    sb.append(s1);
+    sb.append(s2);
+    sb.append(s3);
+    return sb.toString();
+}
+```
+
+每个 StringBuffer.append() 方法中都有一个同步块，锁就是 `sb` 对象。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 `concatString()` 方法内部。也就是说，sb 的所有引用永远不会“逃逸”到 `concatString()` 方法之外，其他线程无法访问到它。因此，虽然这里有锁，但是可以被安全地消除掉。
+
+## 锁粗化
+
+如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。
+
+上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
+
+## 轻量级锁
+
+JDK 1.6 引入了`偏向锁`和`轻量级锁`，从而让锁拥有了四个状态：`无锁状态（unlocked）`、`偏向锁状态（biasble）`、`轻量级锁状态（lightweight locked）`和`重量级锁状态（inflated）`。
+
+以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 mark word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出，应该注意的是 state 表格不是存储在对象头中的。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
+
+<div align="center"> <img src="/image/02/Concurrent/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="600"/> </div><br>
+
+下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
+
+<div align="center"> <img src="/image/02/Concurrent/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/> </div><br>
+
+轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
+
+当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
+
+<div align="center"> <img src="/image/02/Concurrent/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="500"/> </div><br>
+
+如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
+
+## 偏向锁
+
+偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要。
+
+可以使用 `-XX:+UseBiasedLocking=true` 开启偏向锁，不过在 JDK 1.6 中它是默认开启的。
+
+当锁对象第一次被线程获得的时候，进入偏向状态，标记为 1 01。同时使用 CAS 操作将线程 ID 记录到 Mark Word 中，如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
+
+当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
+
+<div align="center"> <img src="/image/02/Concurrent/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/> </div><br>
+
+# 十三、多线程开发良好的实践
+
+- 给线程起个有意义的名字，这样可以方便找 Bug。
+
+- 缩小同步范围，例如对于 synchronized，应该尽量使用同步块而不是同步方法。
+
+- 多用同步类少用 `wait()` 和 `notify()`。首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现对复杂控制流的控制。其次，这些类是由最好的企业编写和维护，在后续的 JDK 中它们还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
+
+- 多用并发集合少用同步集合。并发集合比同步集合的可扩展性更好，例如应该使用 `ConcurrentHashMap` 而不是 `Hashtable。`
+
+- 使用本地变量和不可变类来保证线程安全。
+
+- `使用线程池`而不是直接创建 Thread 对象，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
+
+- 使用 `BlockingQueue` 实现生产者消费者问题。
+
+# 参考资料
+
+- BruceEckel. Java 编程思想: 第 4 版 [M]. 机械工业出版社, 2007.
+- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
+- [Threads and Locks](https://docs.oracle.com/javase/specs/jvms/se6/html/Threads.doc.html)
+- [线程通信](http://ifeve.com/thread-signaling/#missed_signal)
+- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
+- [BlockingQueue](http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html)
+- [thread state java](https://stackoverflow.com/questions/11265289/thread-state-java)
+- [CSC 456 Spring 2012/ch7 MN](http://wiki.expertiza.ncsu.edu/index.php/CSC_456_Spring_2012/ch7_MN)
+- [Java - Understanding Happens-before relationship](https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/happens-before.html)
+- [6장 Thread Synchronization](https://www.slideshare.net/novathinker/6-thread-synchronization)
+- [How is Java's ThreadLocal implemented under the hood?](https://stackoverflow.com/questions/1202444/how-is-javas-threadlocal-implemented-under-the-hood/15653015)
+- [Concurrent](https://sites.google.com/site/webdevelopart/21-compile/06-java/javase/concurrent?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F&showPrintDialog=1)
+- [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
+- [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
+- [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JAVA\351\224\201\346\234\211\345\223\252\344\272\233\347\247\215\347\261\273\357\274\214\344\273\245\345\217\212\345\214\272\345\210\253.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JAVA\351\224\201\346\234\211\345\223\252\344\272\233\347\247\215\347\261\273\357\274\214\344\273\245\345\217\212\345\214\272\345\210\253.md"
similarity index 88%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JAVA\351\224\201\346\234\211\345\223\252\344\272\233\347\247\215\347\261\273\357\274\214\344\273\245\345\217\212\345\214\272\345\210\253.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JAVA\351\224\201\346\234\211\345\223\252\344\272\233\347\247\215\347\261\273\357\274\214\344\273\245\345\217\212\345\214\272\345\210\253.md"
index cddfe283..0bf8859b 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JAVA\351\224\201\346\234\211\345\223\252\344\272\233\347\247\215\347\261\273\357\274\214\344\273\245\345\217\212\345\214\272\345\210\253.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JAVA\351\224\201\346\234\211\345\223\252\344\272\233\347\247\215\347\261\273\357\274\214\344\273\245\345\217\212\345\214\272\345\210\253.md"	
@@ -1,80 +1,83 @@
-在读很多并发文章中，会提及各种各样锁如公平锁，乐观锁等等，这篇文章介绍各种锁的分类。介绍的内容如下：
-
-公平锁/非公平锁
-可重入锁
-独享锁/共享锁
-互斥锁/读写锁
-乐观锁/悲观锁
-分段锁
-偏向锁/轻量级锁/重量级锁
-自旋锁
-
-上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。
-
-**公平锁/非公平锁**
-公平锁是指多个线程按照申请锁的顺序来获取锁。
-非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
-对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
-对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。
-
-**可重入锁**
-可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。
-对于Java ReentrantLock而言, 他的名字就可以看出是一个可重入锁，其名字是Re entrant Lock重新进入锁。
-对于Synchronized而言,也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。
-
-synchronized void setA() throws Exception{
-    Thread.sleep(1000);
-    setB();
-}
-
-synchronized void setB() throws Exception{
-    Thread.sleep(1000);
-}
-上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁。
-
-**独享锁/共享锁**
-独享锁是指该锁一次只能被一个线程所持有。
-共享锁是指该锁可被多个线程所持有。
-
-对于Java ReentrantLock而言，其是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。
-读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。
-独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。
-对于Synchronized而言，当然是独享锁。
-
-**互斥锁/读写锁**
-上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
-互斥锁在Java中的具体实现就是ReentrantLock
-读写锁在Java中的具体实现就是ReadWriteLock
-
-**乐观锁/悲观锁**
-乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。
-悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。
-乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。
-
-从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。
-悲观锁在Java中的使用，就是利用各种锁。
-乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。
-
-**分段锁**
-分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
-我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。
-当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。
-但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。
-分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。
-
-### 锁优化
-
-**自旋锁** -XX:+UseSpinning  自旋次数 -XX:PreBlockSpin
-在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。
-典型的自旋锁实现的例子，可以参考自旋锁的实现 http://ifeve.com/java_lock_see1/
-**自适应性自旋**
-
-**锁消除**
-
-**锁粗化**
-
-**偏向锁/轻量级锁/重量级锁**
-这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
-偏向锁：-XX:-UseBiasedLocking 是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
-轻量级锁：是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
-重量级锁：是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。
+在读很多并发文章中，会提及各种各样锁如公平锁，乐观锁等等，这篇文章介绍各种锁的分类。介绍的内容如下：
+
+公平锁/非公平锁
+可重入锁
+独享锁/共享锁
+互斥锁/读写锁
+乐观锁/悲观锁
+分段锁
+偏向锁/轻量级锁/重量级锁
+自旋锁
+
+上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。
+
+**公平锁/非公平锁**
+公平锁是指多个线程按照申请锁的顺序来获取锁。
+非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
+对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
+对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。
+
+**可重入锁**
+可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。
+对于Java ReentrantLock而言, 他的名字就可以看出是一个可重入锁，其名字是Re entrant Lock重新进入锁。
+对于Synchronized而言,也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。
+
+synchronized void setA() throws Exception{
+    Thread.sleep(1000);
+    setB();
+}
+
+synchronized void setB() throws Exception{
+    Thread.sleep(1000);
+}
+上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁。
+
+**独享锁/共享锁**
+独享锁是指该锁一次只能被一个线程所持有。
+共享锁是指该锁可被多个线程所持有。
+
+对于Java ReentrantLock而言，其是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。
+读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。
+独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。
+对于Synchronized而言，当然是独享锁。
+
+**互斥锁/读写锁**
+上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
+互斥锁在Java中的具体实现就是ReentrantLock
+读写锁在Java中的具体实现就是ReadWriteLock
+
+**乐观锁/悲观锁**
+乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。
+悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。
+乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。
+
+从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。
+悲观锁在Java中的使用，就是利用各种锁。
+乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。
+
+**分段锁**
+分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
+我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。
+当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。
+但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。
+分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。
+
+### 锁优化
+
+**自旋锁** -XX:+UseSpinning  自旋次数 -XX:PreBlockSpin
+在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。
+典型的自旋锁实现的例子，可以参考自旋锁的实现 http://ifeve.com/java_lock_see1/
+**自适应性自旋**
+
+**锁消除**
+
+**锁粗化**
+
+**偏向锁/轻量级锁/重量级锁**
+这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
+
+偏向锁:-XX:-UseBiasedLocking 是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
+
+轻量级锁:是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
+
+重量级锁:是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Java\345\271\266\345\217\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Java\345\271\266\345\217\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Java\345\271\266\345\217\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Java\345\271\266\345\217\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/NIO.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/NIO.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/NIO.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/NIO.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Synchronized.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Synchronized.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Synchronized.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Synchronized.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Thread\345\222\214Runnable\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213\347\232\204\345\214\272\345\210\253.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Thread\345\222\214Runnable\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213\347\232\204\345\214\272\345\210\253.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Thread\345\222\214Runnable\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213\347\232\204\345\214\272\345\210\253.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/Thread\345\222\214Runnable\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213\347\232\204\345\214\272\345\210\253.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/thread\344\270\216runable\345\246\202\344\275\225\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/thread\344\270\216runable\345\246\202\344\275\225\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/thread\344\270\216runable\345\246\202\344\275\225\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/thread\344\270\216runable\345\246\202\344\275\225\345\256\236\347\216\260\345\244\232\347\272\277\347\250\213.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/volatile\345\217\230\351\207\217\344\277\256\351\245\260\347\254\246.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/volatile\345\217\230\351\207\217\344\277\256\351\245\260\347\254\246.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/volatile\345\217\230\351\207\217\344\277\256\351\245\260\347\254\246.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/volatile\345\217\230\351\207\217\344\277\256\351\245\260\347\254\246.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\344\275\277\347\224\250wait notify notifyall\345\256\236\347\216\260\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\344\275\277\347\224\250wait notify notifyall\345\256\236\347\216\260\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\344\275\277\347\224\250wait notify notifyall\345\256\236\347\216\260\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\344\275\277\347\224\250wait notify notifyall\345\256\236\347\216\260\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\217\257\351\207\215\345\205\245\345\206\205\347\275\256\351\224\201.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\217\257\351\207\215\345\205\245\345\206\205\347\275\256\351\224\201.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\217\257\351\207\215\345\205\245\345\206\205\347\275\256\351\224\201.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\217\257\351\207\215\345\205\245\345\206\205\347\275\256\351\224\201.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\244\232\347\272\277\347\250\213\347\216\257\345\242\203\344\270\255\345\256\211\345\205\250\344\275\277\347\224\250\351\233\206\345\220\210API.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\244\232\347\272\277\347\250\213\347\216\257\345\242\203\344\270\255\345\256\211\345\205\250\344\275\277\347\224\250\351\233\206\345\220\210API.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\244\232\347\272\277\347\250\213\347\216\257\345\242\203\344\270\255\345\256\211\345\205\250\344\275\277\347\224\250\351\233\206\345\220\210API.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\244\232\347\272\277\347\250\213\347\216\257\345\242\203\344\270\255\345\256\211\345\205\250\344\275\277\347\224\250\351\233\206\345\220\210API.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\210\346\212\244\347\272\277\347\250\213\344\270\216\351\230\273\345\241\236\347\272\277\347\250\213.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\210\346\212\244\347\272\277\347\250\213\344\270\216\351\230\273\345\241\236\347\272\277\347\250\213.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\210\346\212\244\347\272\277\347\250\213\344\270\216\351\230\273\345\241\236\347\272\277\347\250\213.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\210\346\212\244\347\272\277\347\250\213\344\270\216\351\230\273\345\241\236\347\272\277\347\250\213.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\236\347\216\260\345\206\205\345\255\230\345\217\257\350\247\201\347\232\204\344\270\244\347\247\215\346\226\271\346\263\225\346\257\224\350\276\203\357\274\232\345\212\240\351\224\201\345\222\214volatile\345\217\230\351\207\217.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\236\347\216\260\345\206\205\345\255\230\345\217\257\350\247\201\347\232\204\344\270\244\347\247\215\346\226\271\346\263\225\346\257\224\350\276\203\357\274\232\345\212\240\351\224\201\345\222\214volatile\345\217\230\351\207\217.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\236\347\216\260\345\206\205\345\255\230\345\217\257\350\247\201\347\232\204\344\270\244\347\247\215\346\226\271\346\263\225\346\257\224\350\276\203\357\274\232\345\212\240\351\224\201\345\222\214volatile\345\217\230\351\207\217.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\345\256\236\347\216\260\345\206\205\345\255\230\345\217\257\350\247\201\347\232\204\344\270\244\347\247\215\346\226\271\346\263\225\346\257\224\350\276\203\357\274\232\345\212\240\351\224\201\345\222\214volatile\345\217\230\351\207\217.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\346\255\273\351\224\201.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\346\255\273\351\224\201.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\346\255\273\351\224\201.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\346\255\273\351\224\201.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\224\237\344\272\247\350\200\205\345\222\214\346\266\210\350\264\271\350\200\205\351\227\256\351\242\230.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\224\237\344\272\247\350\200\205\345\222\214\346\266\210\350\264\271\350\200\205\351\227\256\351\242\230.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\224\237\344\272\247\350\200\205\345\222\214\346\266\210\350\264\271\350\200\205\351\227\256\351\242\230.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\224\237\344\272\247\350\200\205\345\222\214\346\266\210\350\264\271\350\200\205\351\227\256\351\242\230.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\344\270\255\346\226\255.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\344\270\255\346\226\255.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\344\270\255\346\226\255.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\344\270\255\346\226\255.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\346\214\202\350\265\267\343\200\201\346\201\242\345\244\215\344\270\216\347\273\210\346\255\242\347\232\204\346\255\243\347\241\256\346\226\271\346\263\225.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\346\214\202\350\265\267\343\200\201\346\201\242\345\244\215\344\270\216\347\273\210\346\255\242\347\232\204\346\255\243\347\241\256\346\226\271\346\263\225.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\346\214\202\350\265\267\343\200\201\346\201\242\345\244\215\344\270\216\347\273\210\346\255\242\347\232\204\346\255\243\347\241\256\346\226\271\346\263\225.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/JavaConcurrent/\347\272\277\347\250\213\346\214\202\350\265\267\343\200\201\346\201\242\345\244\215\344\270\216\347\273\210\346\255\242\347\232\204\346\255\243\347\241\256\346\226\271\346\263\225.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Object Thread/\351\200\232\347\237\245\345\222\214\345\224\244\351\206\222.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Object Thread/\351\200\232\347\237\245\345\222\214\345\224\244\351\206\222.md"
similarity index 99%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Object Thread/\351\200\232\347\237\245\345\222\214\345\224\244\351\206\222.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Object Thread/\351\200\232\347\237\245\345\222\214\345\224\244\351\206\222.md"
index bc6deca4..3f5534cc 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Object Thread/\351\200\232\347\237\245\345\222\214\345\224\244\351\206\222.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/Object Thread/\351\200\232\347\237\245\345\222\214\345\224\244\351\206\222.md"	
@@ -1,18 +1,18 @@
-从这三个方法的文字描述可以知道以下几点信息：
-
-1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
-2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
-3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
-4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；
-
-有朋友可能会有疑问：为何这三个不是Thread类声明中的方法，而是Object类中声明的方法（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？其实这个问题很简单，由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
-
-调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）；notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。
-
-同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。
-
-使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。 
-Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，在阻塞队列那一篇博文中就讲述到了，阻塞队列实际上是使用了Condition来模拟线程间协作。
-Condition是个接口，基本的方法就是await()和signal()方法；
-Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
-调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用Conditon中的await()对应Object的wait()； Condition中的signal()对应Object的notify()； Condition中的signalAll()对应Object的notifyAll()
+从这三个方法的文字描述可以知道以下几点信息：
+
+1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
+2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
+3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
+4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；
+
+有朋友可能会有疑问：为何这三个不是Thread类声明中的方法，而是Object类中声明的方法（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？其实这个问题很简单，由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
+
+调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）；notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。
+
+同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。
+
+使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。 
+Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，在阻塞队列那一篇博文中就讲述到了，阻塞队列实际上是使用了Condition来模拟线程间协作。
+Condition是个接口，基本的方法就是await()和signal()方法；
+Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
+调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用Conditon中的await()对应Object的wait()； Condition中的signal()对应Object的notify()； Condition中的signalAll()对应Object的notifyAll()
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/ThreadLocal.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/ThreadLocal.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/ThreadLocal.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/ThreadLocal.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/all.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/all.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/all.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/all.md"
index c01b12ab..0272fe48 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/all.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/all.md"	
@@ -1,218 +1,218 @@
-http://images.cnblogs.com/cnblogs_com/loveincode/1037824/o_164d94300b13d901.png
-引入线程为了 **提高系统的执行效率**，减少处理机的空转时间和调度切换的时间，以及便于系统管理
-
-并行
-并发
-并发是针对进程的，并发是针对线程的
-### 1. 线程状态
-  基本状态：执行 、 就绪 、阻塞
-
-### 线程问题
-  线程安全问题
-  性能问题
-
-  *对象的发布与逸出*
-    静态域逸出
-    public修饰的get方法
-    方法参数传值
-    隐式的this
-    逸出就是本不应该发布对象的地方，把对象发布了，导致我们的数据泄露出去了，这就造成了一个安全隐患。
-
-  *安全发布对象*
-    在静态域中直接初始化，静态初始化由JVM在类的初始化阶段就执行了，JVM内部存在着同步机制，致使这种方式我们可以安全发布对象
-    对应的引用保存到volatile或者AtomicReferance引用中，保证该对象的引用的可见性和原子性
-    由final修饰，不可变
-    由锁来保护
-
-  *解决线程安全性的方法*
-
-    无状态（没有共享变量） 只要我们保证不要在栈（方法）上发布对象（每个变量的作用域仅仅停留在此方法上），那么我们的线程就是安全的
-    使用final使该引用变量不可变
-    加锁（内置锁，显示lock锁）
-      原子性 atomic包下的类 count++这个操作就不是一个原子性操作
-      可见性
-        volatile 保证该变量对所有线程的可见性，但不保证原子性
-        1. 一旦你完成写入，任何访问这个字段的线程将会得到最新的值
-        2. 会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，内存屏障会把之前的写入值都刷新到缓存。
-        3. volatile可以防止重排序
-      JDK提供的 原子性（atomic） 容器（concurrenthashmap等等）
-
-### 2. 每个对象都有同步方法：
-synchronized
-wait
-notify  **wait/notify必须存在于synchronised中**
-await
-signal/signalAll
-### 3. 每个对象都有一个monitor,用来检测并发代码重入
-### 4. 同步与通信
-### 5. volatile
-JVM内存模型
-处理数据时，线程会把值从主存load到本地栈，完成之后在save回去。
-每次针对该关键字修饰的变量的操作都会引起一次load and save,保存可见性
-### 6. 基本实现
-1.继承Thread类，重载run方法；
-2.实现Runnable接口，实现run方法
-1. Thread
-  yield() 调用yield方法会 **先让别的线程执行，但不确保真正让出**
-  sleep() 调用sleep方法会进入计时等待状态，等 **时间到了，进入的是就绪状态而并非运行状态**
-  join()  调用join方法，**会等待该线程执行完毕后才执行别的线程**
-  interrupte() 不会真正的停止一个线程，它仅仅是给这个线程发一个信号告诉它，它应该要结束了。interrupte()方法压根是不会对线程的状态造成影响的，它仅仅设置一个标志位罢了。
-  静态方法 Thread.interrupted() 会清除中断标志位
-  实例方法 isInterrupted() 不会清楚中断标志位
-  setPriority(int newPriority)
-  线程名 主线程叫做main，其他线程是thread-x
-  **守护线程**  守护线程做为一个服务线程，没有服务对象就没有必要执行了。
-    在线程启动前设置守护线程，方法是setDaemon(boolean on)
-    使用守护线程不要访问共享资源（数据库，文件等），因为它可能会在任何时候就挂掉了。
-    守护线程中产生的新线程也是守护线程
-2. Runnable
-3. Callable Callback
-  带返回值的Runnable,返回值Future
-  Future
-    判断任务是否完成
-    能够中断任务
-    能够获取任务执行结果
-  两种模式
-    非阻塞:isDone获取返回值时,如果线程未执行完返回false，否则返回true
-    阻塞:get()获取返回值，阻塞至该线程结束。
-### 7. 中断
-每个线程都有中断标识位,线程会不断的检测改标志位,线程检测到中断后不会中断正在运行的线程,而是抛出InterruptedException
-### 8. 高效使用 java 1.5中的java.util.concurent包提供大量工具
-#### 8.1 ThreadLocal
-#### 8.2 原子类
-AtomicInteger compareAndSet()可实现乐观锁
-AtomicBoolean
-AtomicLong
-#### 8.3 AtomicReference
-#### 8.4 锁
-  *synchronized*
-  synchronized能够将代码块（方法）锁起来
-  **互斥锁**，一次只能进入允许一个线程进入被锁住的代码块
-  synchronized是一种 **内置锁/监视器锁**  Java每个对象都有一个内置锁（监视器锁，可以理解为锁标记）
-  **底层通过monitor对象，对象有自己的对象头，存储了很多信息，其中一个信息标识是被哪个线程持有。**
-
-  保证线程的原子性
-  可见性
-
-  静态方法获取的是类锁（类的字节码文件对象）
-  synchronized修饰普通方法或代码块获取的是对象锁
-  **获取了类锁的线程和获取了对象锁的线程是不冲突的**
-
-  **可重入锁**  **锁的持有者是线程，而不是调用** (也叫做递归锁,指的是同一线程外层函数获得锁之后,内层递归函数仍然有获取该锁的代码,但不受影响) https://www.jb51.net/article/57338.htm
-
-  锁升级 适应自旋锁、锁消除、锁粗化、轻量级锁、偏向锁
-
-  *Lock*
-  支持中断、超时不获取、是非阻塞的
-  提高 **语义话**，哪里加锁，哪里解锁都得写出来
-  允许多个线程同时访问共享资源（**读写锁**）
-
-  **底层原理 AQS AbstractQueuedSynchronizer**
-  AQS是一个实现锁的框架
-  内部实现的关键：先进先出的队列、state状态
-  定义了内部类ConditionObject
-  提供两种线程模式  独占模式 共享模式
-
-  修改state状态值时使用CAS算法来实现
-  等待列被称为：CLH队列，是一个双向队列
-  定义了框架，具体实现由子类来做（**模板模式**）
-
-  三种实现
-    ReentrantLock **比synchronized更有伸缩性，使用时标准用法是在try之前调用lock方法，在finally代码释放锁**
-    ReentrantReadWriteLock state的变量高16位是读锁，低16位是写锁 读锁不能升级为写锁，写锁可以降级为读锁
-    ReentrantReadWriteLock.ReadLock 读时共享
-    ReentrantReadWriteLock.WriteLock 写时互斥
-
-  加锁方式
-    组塞式:lock
-    非阻塞:trylock
-    可中断:lockinterruptily
-  Condition
-  解锁unlock  **为了避免错误,该方法一定要放在finally语句块中**
-#### 8.5 并发容器
-  BlockingQueue **实现生产者消费者模型的神奇**
-    ArrayListBlockingQueue
-    LinkedListBlockingQueue
-    DelayQueue
-    PriorityBlockingQueue
-  ConcurrentLinkQueue
-  ConcurrentHashMap
-  CopyOnWriteArrayList
-  在迭代并发容器时修改其内容并不会抛出ConcurrentModificationException异常
-  在并发容器内部实现中尽量避免了synchronized关键字,从而增强了并发性
-#### 8.6 线程池
-  状态
-  Running 线程池能够接受新任务
-  Shutdown 线程池不可以接受新任务
-  Stop 线程池不接受新任务，不处理已添加任务，并且中断正在处理的任务
-  Tidying 当所有的任务终止，ctl中的记录为0，会变成Tidying状态
-  Terminated 线程池彻底终止的状态
-
-  ThreadPoolExecutor
-  参数
-  corePoolSize 核心线程的数量
-  maximumPoolSize 最大线程数
-  keepAliveTime 线程空闲的时间
-  unit 时间单位
-  workQueue 保存等待执行的任务的阻塞队列，等待的任务必须实现Runnable接口
-  threadFactory 设置创建线程的工厂
-  handler 线程池的拒绝策略
-
-  Executors 提供了一种将 **任务提交** **任务执行** 分离开来的机制
-  Executors接口 定义了执行任务的行为
-  ExecutorServices接口 提供了线程池管理生命周期的方法
-    newCachedThreadPool() 非常有弹性的线程池，对于新的任务，如果此时线程池里没有空闲线程，线程池会毫不犹豫的创建一条新的线程去处理这个任务.`无限线程池`
-    newSingleThreadExecutor() 单个worker线程的Executor  创建单个线程的线程池。
-    newFixedThreadPool() 返回一个corePoolSize和maximumPoolSize相等的线程池 创建固定大小的线程池。
-
-  *执行线程*
-    submit()
-    execute()
-
-  *线程池关闭*
-    shutdown() 线程池状态立刻变为Shutdown 等待任务执行完才中断线程
-    shutdownnow() 线程池状态立刻变为Stop 不等任务执行完就中断了线程
-
-  *策略*
-  线程数量策略
-    如果运行线程的数量少于核心线程数量，则创建新的线程处理请求
-    如果运行线程的数量大于核心线程数量，小于最大线程数量，则当队列满的时候才创建新的线程
-    如果核心线程数量等于最大线程数量,那么将创建固定大小的线程池
-    如果设置了最大线程数量为无穷，那么允许线程池适合任意的并发数量
-  线程空间策略
-    当前线程数大于核心线程数，如果空闲时间超过了，那该线程会销毁
-  排队策略
-    同步移交：不会放到队列中，而是等待线程执行它。如果当前线程没执行，可能会新开一个线程执行。
-    无界限策略：如果核心线程都在工作，该线程会放到队列中。所以线程数不会超过核心线程数。
-    有界限策略：可以避免资源耗尽，但是一定程度降低了吞吐量。
-
-  *拒绝任务策略*
-  1. AbortPolicy：直接抛出异常，默认策略；
-  2. CallerRunsPolicy：用调用者所在的线程来执行任务；
-  3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务(最老的)，并执行当前任务；
-  4. DiscardPolicy：直接丢弃任务；
-
-  *excute执行方法*
-  如果线程池中运行的线程数量 > corePoolSize，则创建新线程来处理请求，即时其他辅助线程是空闲的
-  如果线程池中运行的线程数量 >= corePoolSize,且线程池处于Running状态，且把提交的任务成功放入阻塞队列中，就再次检查线程池的状态
-  如果以上两个case都不成立，即没能将任务成功放入阻塞队列，addWorker新建线程失败，则该任务由当前RejectedExecutionHandler处理
-
-#### 8.7 同步器
-  CountDownLatch 闭锁 某个线程等待其他线程执行完毕后，它才执行（其他线程等待某个线程执行完毕后，它才执行）
-  CyclicBarrier 栅栏 一旦线程互相等待至某个状态，这组线程再同时执行
-  Semphore 信号量 控制一组线程同时执行
-  Exchanger
-  SynchronousQueue
-#### 8.8 并发容器与同步容器对比
-同步容器对于并发读访问的支持不好
-由于内部多采用synchronized关键字实现,所以性能不如并发容器
-对于同步容器进行迭代的同时修改它的内容，会报ConcurrentModificationException异常
-
-
-
-##### InterruptedException
-抛InterruptedException的代表方法有：
-
-java.lang.Object 类的 wait 方法
-java.lang.Thread 类的 sleep 方法
-java.lang.Thread 类的 join 方法
+http://images.cnblogs.com/cnblogs_com/loveincode/1037824/o_164d94300b13d901.png
+引入线程为了 **提高系统的执行效率**，减少处理机的空转时间和调度切换的时间，以及便于系统管理
+
+并行
+并发
+并发是针对进程的，并发是针对线程的
+### 1. 线程状态
+  基本状态：执行 、 就绪 、阻塞
+
+### 线程问题
+  线程安全问题
+  性能问题
+
+  *对象的发布与逸出*
+    静态域逸出
+    public修饰的get方法
+    方法参数传值
+    隐式的this
+    逸出就是本不应该发布对象的地方，把对象发布了，导致我们的数据泄露出去了，这就造成了一个安全隐患。
+
+  *安全发布对象*
+    在静态域中直接初始化，静态初始化由JVM在类的初始化阶段就执行了，JVM内部存在着同步机制，致使这种方式我们可以安全发布对象
+    对应的引用保存到volatile或者AtomicReferance引用中，保证该对象的引用的可见性和原子性
+    由final修饰，不可变
+    由锁来保护
+
+  *解决线程安全性的方法*
+
+    无状态（没有共享变量） 只要我们保证不要在栈（方法）上发布对象（每个变量的作用域仅仅停留在此方法上），那么我们的线程就是安全的
+    使用final使该引用变量不可变
+    加锁（内置锁，显示lock锁）
+      原子性 atomic包下的类 count++这个操作就不是一个原子性操作
+      可见性
+        volatile 保证该变量对所有线程的可见性，但不保证原子性
+        1. 一旦你完成写入，任何访问这个字段的线程将会得到最新的值
+        2. 会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，内存屏障会把之前的写入值都刷新到缓存。
+        3. volatile可以防止重排序
+      JDK提供的 原子性（atomic） 容器（concurrenthashmap等等）
+
+### 2. 每个对象都有同步方法：
+synchronized
+wait
+notify  **wait/notify必须存在于synchronised中**
+await
+signal/signalAll
+### 3. 每个对象都有一个monitor,用来检测并发代码重入
+### 4. 同步与通信
+### 5. volatile
+JVM内存模型
+处理数据时，线程会把值从主存load到本地栈，完成之后在save回去。
+每次针对该关键字修饰的变量的操作都会引起一次load and save,保存可见性
+### 6. 基本实现
+1.继承Thread类，重载run方法；
+2.实现Runnable接口，实现run方法
+1. Thread
+  yield() 调用yield方法会 **先让别的线程执行，但不确保真正让出**
+  sleep() 调用sleep方法会进入计时等待状态，等 **时间到了，进入的是就绪状态而并非运行状态**
+  join()  调用join方法，**会等待该线程执行完毕后才执行别的线程**
+  interrupte() 不会真正的停止一个线程，它仅仅是给这个线程发一个信号告诉它，它应该要结束了。interrupte()方法压根是不会对线程的状态造成影响的，它仅仅设置一个标志位罢了。
+  静态方法 Thread.interrupted() 会清除中断标志位
+  实例方法 isInterrupted() 不会清楚中断标志位
+  setPriority(int newPriority)
+  线程名 主线程叫做main，其他线程是thread-x
+  **守护线程**  守护线程做为一个服务线程，没有服务对象就没有必要执行了。
+    在线程启动前设置守护线程，方法是setDaemon(boolean on)
+    使用守护线程不要访问共享资源（数据库，文件等），因为它可能会在任何时候就挂掉了。
+    守护线程中产生的新线程也是守护线程
+2. Runnable
+3. Callable Callback
+  带返回值的Runnable,返回值Future
+  Future
+    判断任务是否完成
+    能够中断任务
+    能够获取任务执行结果
+  两种模式
+    非阻塞:isDone获取返回值时,如果线程未执行完返回false，否则返回true
+    阻塞:get()获取返回值，阻塞至该线程结束。
+### 7. 中断
+每个线程都有中断标识位,线程会不断的检测改标志位,线程检测到中断后不会中断正在运行的线程,而是抛出InterruptedException
+### 8. 高效使用 java 1.5中的java.util.concurent包提供大量工具
+#### 8.1 ThreadLocal
+#### 8.2 原子类
+AtomicInteger compareAndSet()可实现乐观锁
+AtomicBoolean
+AtomicLong
+#### 8.3 AtomicReference
+#### 8.4 锁
+  *synchronized*
+  synchronized能够将代码块（方法）锁起来
+  **互斥锁**，一次只能进入允许一个线程进入被锁住的代码块
+  synchronized是一种 **内置锁/监视器锁**  Java每个对象都有一个内置锁（监视器锁，可以理解为锁标记）
+  **底层通过monitor对象，对象有自己的对象头，存储了很多信息，其中一个信息标识是被哪个线程持有。**
+
+  保证线程的原子性
+  可见性
+
+  静态方法获取的是类锁（类的字节码文件对象）
+  synchronized修饰普通方法或代码块获取的是对象锁
+  **获取了类锁的线程和获取了对象锁的线程是不冲突的**
+
+  **可重入锁**  **锁的持有者是线程，而不是调用** (也叫做递归锁,指的是同一线程外层函数获得锁之后,内层递归函数仍然有获取该锁的代码,但不受影响) https://www.jb51.net/article/57338.htm
+
+  锁升级 适应自旋锁、锁消除、锁粗化、轻量级锁、偏向锁
+
+  *Lock*
+  支持中断、超时不获取、是非阻塞的
+  提高 **语义话**，哪里加锁，哪里解锁都得写出来
+  允许多个线程同时访问共享资源（**读写锁**）
+
+  **底层原理 AQS AbstractQueuedSynchronizer**
+  AQS是一个实现锁的框架
+  内部实现的关键：先进先出的队列、state状态
+  定义了内部类ConditionObject
+  提供两种线程模式  独占模式 共享模式
+
+  修改state状态值时使用CAS算法来实现
+  等待列被称为：CLH队列，是一个双向队列
+  定义了框架，具体实现由子类来做（**模板模式**）
+
+  三种实现
+    ReentrantLock **比synchronized更有伸缩性，使用时标准用法是在try之前调用lock方法，在finally代码释放锁**
+    ReentrantReadWriteLock state的变量高16位是读锁，低16位是写锁 读锁不能升级为写锁，写锁可以降级为读锁
+    ReentrantReadWriteLock.ReadLock 读时共享
+    ReentrantReadWriteLock.WriteLock 写时互斥
+
+  加锁方式
+    组塞式:lock
+    非阻塞:trylock
+    可中断:lockinterruptily
+  Condition
+  解锁unlock  **为了避免错误,该方法一定要放在finally语句块中**
+#### 8.5 并发容器
+  BlockingQueue **实现生产者消费者模型的神奇**
+    ArrayListBlockingQueue
+    LinkedListBlockingQueue
+    DelayQueue
+    PriorityBlockingQueue
+  ConcurrentLinkQueue
+  ConcurrentHashMap
+  CopyOnWriteArrayList
+  在迭代并发容器时修改其内容并不会抛出ConcurrentModificationException异常
+  在并发容器内部实现中尽量避免了synchronized关键字,从而增强了并发性
+#### 8.6 线程池
+  状态
+  Running 线程池能够接受新任务
+  Shutdown 线程池不可以接受新任务
+  Stop 线程池不接受新任务，不处理已添加任务，并且中断正在处理的任务
+  Tidying 当所有的任务终止，ctl中的记录为0，会变成Tidying状态
+  Terminated 线程池彻底终止的状态
+
+  ThreadPoolExecutor
+  参数
+  corePoolSize 核心线程的数量
+  maximumPoolSize 最大线程数
+  keepAliveTime 线程空闲的时间
+  unit 时间单位
+  workQueue 保存等待执行的任务的阻塞队列，等待的任务必须实现Runnable接口
+  threadFactory 设置创建线程的工厂
+  handler 线程池的拒绝策略
+
+  Executors 提供了一种将 **任务提交** **任务执行** 分离开来的机制
+  Executors接口 定义了执行任务的行为
+  ExecutorServices接口 提供了线程池管理生命周期的方法
+    newCachedThreadPool() 非常有弹性的线程池，对于新的任务，如果此时线程池里没有空闲线程，线程池会毫不犹豫的创建一条新的线程去处理这个任务.`无限线程池`
+    newSingleThreadExecutor() 单个worker线程的Executor  创建单个线程的线程池。
+    newFixedThreadPool() 返回一个corePoolSize和maximumPoolSize相等的线程池 创建固定大小的线程池。
+
+  *执行线程*
+    submit()
+    execute()
+
+  *线程池关闭*
+    shutdown() 线程池状态立刻变为Shutdown 等待任务执行完才中断线程
+    shutdownnow() 线程池状态立刻变为Stop 不等任务执行完就中断了线程
+
+  *策略*
+  线程数量策略
+    如果运行线程的数量少于核心线程数量，则创建新的线程处理请求
+    如果运行线程的数量大于核心线程数量，小于最大线程数量，则当队列满的时候才创建新的线程
+    如果核心线程数量等于最大线程数量,那么将创建固定大小的线程池
+    如果设置了最大线程数量为无穷，那么允许线程池适合任意的并发数量
+  线程空间策略
+    当前线程数大于核心线程数，如果空闲时间超过了，那该线程会销毁
+  排队策略
+    同步移交：不会放到队列中，而是等待线程执行它。如果当前线程没执行，可能会新开一个线程执行。
+    无界限策略：如果核心线程都在工作，该线程会放到队列中。所以线程数不会超过核心线程数。
+    有界限策略：可以避免资源耗尽，但是一定程度降低了吞吐量。
+
+  *拒绝任务策略*
+  1. AbortPolicy：直接抛出异常，默认策略；
+  2. CallerRunsPolicy：用调用者所在的线程来执行任务；
+  3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务(最老的)，并执行当前任务；
+  4. DiscardPolicy：直接丢弃任务；
+
+  *excute执行方法*
+  如果线程池中运行的线程数量 > corePoolSize，则创建新线程来处理请求，即时其他辅助线程是空闲的
+  如果线程池中运行的线程数量 >= corePoolSize,且线程池处于Running状态，且把提交的任务成功放入阻塞队列中，就再次检查线程池的状态
+  如果以上两个case都不成立，即没能将任务成功放入阻塞队列，addWorker新建线程失败，则该任务由当前RejectedExecutionHandler处理
+
+#### 8.7 同步器
+  CountDownLatch 闭锁 某个线程等待其他线程执行完毕后，它才执行（其他线程等待某个线程执行完毕后，它才执行）
+  CyclicBarrier 栅栏 一旦线程互相等待至某个状态，这组线程再同时执行
+  Semphore 信号量 控制一组线程同时执行
+  Exchanger
+  SynchronousQueue
+#### 8.8 并发容器与同步容器对比
+同步容器对于并发读访问的支持不好
+由于内部多采用synchronized关键字实现,所以性能不如并发容器
+对于同步容器进行迭代的同时修改它的内容，会报ConcurrentModificationException异常
+
+
+
+##### InterruptedException
+抛InterruptedException的代表方法有：
+
+java.lang.Object 类的 wait 方法
+java.lang.Thread 类的 sleep 方法
+java.lang.Thread 类的 join 方法
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/me.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/me.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/me.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/me.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/question.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/question.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/question.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/question.md"
index 77586666..d95d592e 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/question.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/question.md"	
@@ -1,44 +1,44 @@
-``` java
-public static void main(String[]args)throws Exception {
-    final Object obj = new Object();
-
-    Thread t1 = new Thread() {
-        public void run() {
-            synchronized (obj) {
-                try {
-                    obj.wait();
-                    System.out.println("Thread 1 wake up.");
-                } catch (InterruptedException e) {
-                }
-            }
-        }
-    };
-    t1.start();
-    Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
-
-    Thread t2 = new Thread() {
-        public void run() {
-            synchronized (obj) {
-                obj.notifyAll();
-                System.out.println("Thread 2 sent notify.");
-            }
-        }
-    };
-    t2.start();
-}
-```
-``` output
-Thread 2 sent notify.
-Thread 1 wake up
-
-执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。
-```
-### Thread run方法和start方法的区别
-1.start方法
-     用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
-2.run方法
-     run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。
-
-     run()方法就是一个普通的方法，真正启动一个新线程的话是start()
-
-     run方法是线程内重写的一个方法，start一个线程后使得线程处于就绪状态，当jvm调用的时候，线程启动会运行run。run函数是线程里面的一个函数不是多线程的。
+``` java
+public static void main(String[]args)throws Exception {
+    final Object obj = new Object();
+
+    Thread t1 = new Thread() {
+        public void run() {
+            synchronized (obj) {
+                try {
+                    obj.wait();
+                    System.out.println("Thread 1 wake up.");
+                } catch (InterruptedException e) {
+                }
+            }
+        }
+    };
+    t1.start();
+    Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
+
+    Thread t2 = new Thread() {
+        public void run() {
+            synchronized (obj) {
+                obj.notifyAll();
+                System.out.println("Thread 2 sent notify.");
+            }
+        }
+    };
+    t2.start();
+}
+```
+``` output
+Thread 2 sent notify.
+Thread 1 wake up
+
+执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。
+```
+### Thread run方法和start方法的区别
+1.start方法
+     用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
+2.run方法
+     run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。
+
+     run()方法就是一个普通的方法，真正启动一个新线程的话是start()
+
+     run方法是线程内重写的一个方法，start一个线程后使得线程处于就绪状态，当jvm调用的时候，线程启动会运行run。run函数是线程里面的一个函数不是多线程的。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/synchronize\357\274\210S\357\274\211 VS lock(L).md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/synchronize\357\274\210S\357\274\211 VS lock(L).md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/synchronize\357\274\210S\357\274\211 VS lock(L).md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/synchronize\357\274\210S\357\274\211 VS lock(L).md"
index 56f28054..4733b8d1 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/synchronize\357\274\210S\357\274\211 VS lock(L).md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/synchronize\357\274\210S\357\274\211 VS lock(L).md"	
@@ -1,8 +1,8 @@
-synchronize（S） VS lock(L)
-
-1. L是接口，S是关键字
-2. S在发生异常时，会自动释放线程占有的锁，不会发生死锁
-   L在发生异常时，若没有主动通过unlock()释放锁，则可能造成死锁。所以用lock时，要在finally释放锁。
-3. L可以当等待锁的线程响应中断，而S不行，使用S时，等待的线程将会一直等下去，不能响应中断。
-4. 通过L可以知道是否成功获得锁，S不可以
-5. L可以提高多个线程进行读写操作的效率
+synchronize（S） VS lock(L)
+
+1. L是接口，S是关键字
+2. S在发生异常时，会自动释放线程占有的锁，不会发生死锁
+   L在发生异常时，若没有主动通过unlock()释放锁，则可能造成死锁。所以用lock时，要在finally释放锁。
+3. L可以当等待锁的线程响应中断，而S不行，使用S时，等待的线程将会一直等下去，不能响应中断。
+4. 通过L可以知道是否成功获得锁，S不可以
+5. L可以提高多个线程进行读写操作的效率
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/thread.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/top50.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/top50.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/top50.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/top50.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/volatile.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/volatile.txt"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/volatile.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/volatile.txt"
index 0afb61bd..0535f475 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/volatile.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/volatile.txt"	
@@ -1,2 +1,2 @@
-volatile的两大特性：禁止重排序（有序性）、内存可见性
-没有原子性
+volatile的两大特性：禁止重排序（有序性）、内存可见性
+没有原子性
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/AQS.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/AQS.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/AQS.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/AQS.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch.txt"
similarity index 99%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch.txt"
index 54645a36..b99d26ed 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch.txt"	
@@ -1,3 +1,3 @@
-https://www.jianshu.com/p/7c7a5df5bda6?ref=myread
-
+https://www.jianshu.com/p/7c7a5df5bda6?ref=myread
+
 CountDownLatch是同步工具类之一，可以指定一个计数值，在并发环境下由线程进行减1操作，当计数值变为0之后，被await方法阻塞的线程将会唤醒，实现线程间的同步。
\ No newline at end of file
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch\345\222\214CyclicBarrier\347\232\204\345\214\272\345\210\253.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch\345\222\214CyclicBarrier\347\232\204\345\214\272\345\210\253.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch\345\222\214CyclicBarrier\347\232\204\345\214\272\345\210\253.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CountDownLatch\345\222\214CyclicBarrier\347\232\204\345\214\272\345\210\253.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CyclicBarrier.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CyclicBarrier.txt"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CyclicBarrier.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CyclicBarrier.txt"
index 75e63707..77c8fa69 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CyclicBarrier.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/CyclicBarrier.txt"	
@@ -1,13 +1,13 @@
-https://www.cnblogs.com/nullzx/p/5271964.html
-
-CyclicBarrier 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。
-
-它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
-线程进入屏障通过CyclicBarrier的await()方法。
-
-CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，
-其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
-
-
-CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)，
+https://www.cnblogs.com/nullzx/p/5271964.html
+
+CyclicBarrier 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。
+
+它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
+线程进入屏障通过CyclicBarrier的await()方法。
+
+CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，
+其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
+
+
+CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)，
 用于在线程到达屏障时，优先执行barrierAction这个Runnable对象，方便处理更复杂的业务场景。
\ No newline at end of file
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Exchanger.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Exchanger.txt"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Exchanger.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Exchanger.txt"
index 4bd131aa..b0466cfa 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Exchanger.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Exchanger.txt"	
@@ -1,20 +1,20 @@
-Exchanger是自jdk1.5起开始提供的工具套件，一般用于两个工作线程之间交换数据。
-
-在本文中我将采取由浅入深的方式来介绍分析这个工具类。首先我们来看看官方的api文档中的叙述：
-A synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the exchange method, matches with a partner thread, and receives its partner's object on return. An Exchanger may be viewed as a bidirectional form of a SynchronousQueue. Exchangers may be useful in applications such as genetic algorithms and pipeline designs.
-
-在以上的描述中，有几个要点：
-
-	此类提供对外的操作是同步的；
-	用于成对出现的线程之间交换数据；
-	可以视作双向的同步队列；
-	可应用于基因算法、流水线设计等场景。
-	
-
-从官方的javadoc可以知道，当一个线程到达exchange调用点时，如果它的伙伴线程此前已经调用了此方法，那么它的伙伴会被调度唤醒并与之进行对象交换，然后各自返回。
-          
-如果它的伙伴还没到达交换点，那么当前线程将会被挂起，
-直至伙伴线程到达 —— 完成交换正常返回；
-或者当前线程被中断 —— 抛出中断异常；
-又或者是等候超时-—— 抛出超时异常。
-
+Exchanger是自jdk1.5起开始提供的工具套件，一般用于两个工作线程之间交换数据。
+
+在本文中我将采取由浅入深的方式来介绍分析这个工具类。首先我们来看看官方的api文档中的叙述：
+A synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the exchange method, matches with a partner thread, and receives its partner's object on return. An Exchanger may be viewed as a bidirectional form of a SynchronousQueue. Exchangers may be useful in applications such as genetic algorithms and pipeline designs.
+
+在以上的描述中，有几个要点：
+
+	此类提供对外的操作是同步的；
+	用于成对出现的线程之间交换数据；
+	可以视作双向的同步队列；
+	可应用于基因算法、流水线设计等场景。
+	
+
+从官方的javadoc可以知道，当一个线程到达exchange调用点时，如果它的伙伴线程此前已经调用了此方法，那么它的伙伴会被调度唤醒并与之进行对象交换，然后各自返回。
+          
+如果它的伙伴还没到达交换点，那么当前线程将会被挂起，
+直至伙伴线程到达 —— 完成交换正常返回；
+或者当前线程被中断 —— 抛出中断异常；
+又或者是等候超时-—— 抛出超时异常。
+
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Semaphore.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Semaphore.txt"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Semaphore.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Semaphore.txt"
index fc0ec610..727b6e0a 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Semaphore.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273/Semaphore.txt"	
@@ -1,9 +1,9 @@
-https://www.cnblogs.com/nullzx/p/5270233.html
-
-在信号量上我们定义两种操作： acquire（获取） 和 release（释放）。
-
-当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
-release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
-
-信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
-
+https://www.cnblogs.com/nullzx/p/5270233.html
+
+在信号量上我们定义两种操作： acquire（获取） 和 release（释放）。
+
+当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
+release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
+
+信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
+
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/01 - \346\267\261\345\205\245\345\210\206\346\236\220synchronized\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/01 - \346\267\261\345\205\245\345\210\206\346\236\220synchronized\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/01 - \346\267\261\345\205\245\345\210\206\346\236\220synchronized\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/01 - \346\267\261\345\205\245\345\210\206\346\236\220synchronized\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
index f65b6f44..e35ee82c 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/01 - \346\267\261\345\205\245\345\210\206\346\236\220synchronized\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/01 - \346\267\261\345\205\245\345\210\206\346\236\220synchronized\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"	
@@ -1,236 +1,236 @@
-synchronized是一个重量级锁，相对于Lock，它会显得那么笨重，以至于我们认为它不是那么的高效而慢慢摒弃它。
-诚然，随着`Javs SE 1.6`对synchronized进行的各种优化后，synchronized并不会显得那么重了。
-下面跟随LZ一起来探索synchronized的实现机制、Java是如何对它进行了优化、锁优化机制、锁的存储结构和升级过程；
-
-### 实现原理
-
-  **synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性**
-
-  Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
-
-  1. 普通同步方法，锁是当前实例对象 **对象锁**
-  ```java
-   public synchronized void test(){}
-  ```
-  2. 静态同步方法，锁是当前类的class对象 **类锁**
-  ```java
-  public static synchronized void test(){}
-
-  public static void test(){
-      synchronized (TestSynchronized.class) {
-          // TODO
-      }
-  }
-  ```
-  3. 同步方法块，锁是括号里面的对象 **对象锁**
-  ```java
-  public void test(){
-     synchronized (this) {
-         // TODO
-     }
-  }
-  ```
-
-
-  **对象锁**
-
-  一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。
-
-  **类锁** 和 **对象锁** 是不一样的锁，是互相独立的。
-
-  当一个线程访问同步代码块时，它首先是需要得到锁才能执行同步代码，当退出或者抛出异常时必须要释放锁，那么它是如何来实现这个机制的呢？我们先看一段简单的代码：
-  ```java
-  public class SynchronizedTest {
-      public synchronized void test1(){
-
-      }
-      public void test2(){
-          synchronized (this){
-          }
-      }
-  }
-  ```
-  利用javap工具查看生成的class文件信息来分析Synchronize的实现:
-
-  <img src="img/Synchronize-1_thumb-1.jpg">
-
-  从上面可以看出，同步代码块是使用`monitorenter`和`monitorexit`指令实现的，同步方法（在这看不出来需要看JVM底层实现）依靠的是方法修饰符上的`ACC_SYNCHRONIZED`实现。
-
-  **同步代码块**：monitorenter指令插入到同步代码块的开始位置，monitorexit指令插入到同步代码块的结束位置，JVM需要保证每一个monitorenter都有一个monitorexit与之相对应。任何对象都有一个monitor与之相关联，当且一个monitor被持有之后，他将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor所有权，即尝试获取对象的锁；
-
-  **同步方法**：synchronized方法则会被翻译成普通的方法调用和返回指令如:invokevirtual、areturn指令，在VM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法，而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1，表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象。(摘自：http://www.cnblogs.com/javaminer/p/3889023.html)
-
-  下面我们来继续分析，但是在深入之前我们需要了解两个重要的概念：Java对象头，Monitor。
-
-### Java对象头、monitor
-
-  **Java对象头和monitor是实现synchronized的基础！下面就这两个概念来做详细介绍。**
-
-#### Java对象头
-
-  **`synchronized`用的锁是存在Java对象头里的** ，那么什么是Java对象头呢？
-
-  Hotspot虚拟机的对象头主要包括两部分数据：
-  **Mark Word（标记字段）**、**class Pointer（类型指针）**。
-
-  其中`Class Pointer`是是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Word用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键，所以下面将重点阐述Mark Word。
-
-  `Mark Word`用于存储对象自身的运行时数据，
-  如`哈希码（HashCode）`、`GC分代年龄`、`锁状态标志`、`线程持有的锁`、`偏向线程` `ID`、`偏向时间戳`等等。
-
-  Java对象头一般占有两个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit），
-  但是如果对象是数组类型，则需要三个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数组的大小，所以用一块来记录数组长度。
-  下图是Java对象头的存储结构（32位虚拟机）：
-
-  <img src="img/222222_2_thumb-1.jpg">
-
-  对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
-
-  <img src="img/11111111111_2-1.jpg">
-
-#### Monitor
-
-  什么是Monitor？我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。
-
-  与一切皆对象一样，所有的Java对象是天生的Monitor，每一个Java对象都有成为Monitor的潜质，因为在Java的设计中 ，每一个Java对象自打娘胎里出来就带了一把看不见的锁，它叫做`内部锁`或者`Monitor锁`。
-
-  Monitor 是`线程私有`的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联（对象头的MarkWord中的LockWord指向monitor的起始地址），同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用。其结构如下：  
-
-  * **Owner**：初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL；
-  * **EntryQ**: 关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程。
-  * **RcThis**: 表示blocked或waiting在该monitor record上的所有线程的个数。
-  * **Nest**: 用来实现重入锁的计数。
-  * **HashCode**: 保存从对象头拷贝过来的HashCode值（可能还包含GC age）。
-  * **Candidate**: 用来避免不必要的阻塞或等待线程唤醒，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降。Candidate只有两种可能的值0表示没有需要唤醒的线程1表示要唤醒一个继任线程来竞争锁。
-  摘自：Java中synchronized的实现原理与应用）
-  我们知道synchronized是重量级锁，效率不怎么滴，同时这个观念也一直存在我们脑海里，不过在jdk 1.6中对synchronize的实现进行了各种优化，使得它显得不是那么重了，那么JVM采用了那些优化手段呢？
-
-### 锁优化
-
-  jdk1.6对锁的实现引入了大量的优化，如 **自旋锁**、**适应性自旋锁**、**锁消除**、**锁粗化**、**偏向锁**、**轻量级锁** 等技术来减少锁操作的开销。
-  锁主要存在四中状态，依次是：`无锁状态`、`偏向锁状态`、`轻量级锁状态`、`重量级锁状态`，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
-
-  * 自适应偏向锁：自旋时间不固定
-  * 锁消除：如果发现代码是线程安全的，将锁去掉
-  * 锁粗化：加锁范围过小(重复加锁)，将加锁的范围扩展
-  * 轻量级锁：在无竞争的情况下使用CAS操作去消除同步使用的互斥量
-  * 偏向锁：在无竞争环境下，把整个同步都消除，CAS也不做。
-
-#### 自旋锁
-  线程的阻塞和唤醒需要CPU从`用户态`转为`核心态`，频繁的阻塞和唤醒对CPU来说是一件负担很重的工作，势必会给系统的并发性能带来很大的压力。同时我们发现在许多应用上面，`对象锁的锁状态只会持续很短一段时间`，为了这一段很短的时间频繁地阻塞和唤醒线程是非常不值得的。所以引入自旋锁。
-
-  何谓自旋锁？
-  所谓自旋锁，就是让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。怎么等待呢？执行一段无意义的循环即可（自旋）。
-
-  自旋等待不能替代阻塞，先不说对处理器数量的要求（多核，貌似现在没有单核的处理器了），虽然它可以避免线程切换带来的开销，但是它占用了处理器的时间。**如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理的资源，它不会做任何有意义的工作，典型的占着茅坑不拉屎，这样反而会带来性能上的浪费。** 所以说，自旋等待的时间（自旋的次数）必须要有一个限度，如果自旋超过了定义的时间仍然没有获取到锁，则应该被挂起。
-
-  自旋锁在JDK 1.4.2中引入，默认关闭，但是可以使用-XX:+UseSpinning开开启，在JDK1.6中默认开启。同时自旋的`默认次数为10次`，可以通过参数-XX:PreBlockSpin来调整；
-
-  如果通过参数`-XX:preBlockSpin`来调整自旋锁的自旋次数，会带来诸多不便。假如我将参数调整为10，但是系统很多线程都是等你刚刚退出的时候就释放了锁（假如你多自旋一两次就可以获取锁），你是不是很尴尬。于是JDK1.6引入 自适应的自旋锁，让虚拟机会变得越来越聪明。
-
-#### 适应自旋锁
-
-  JDK 1.6引入了更加聪明的自旋锁，即自适应自旋锁。所谓自适应就意味着自旋的次数不再是固定的，它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。
-  它怎么做呢？
-
-  线程如果自旋成功了，那么下次自旋的次数会更加多，因为虚拟机认为既然上次成功了，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多。
-  反之，如果对于某个锁，很少有自旋能够成功的，那么在以后要或者这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源。
-
-  有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测会越来越准确，虚拟机会变得越来越聪明。
-
-#### 锁消除
-
-  为了保证数据的完整性，我们在进行操作时需要对这部分操作进行同步控制，但是在有些情况下，**JVM检测到不可能存在共享数据竞争**，这时JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持。
-
-  如果不存在竞争，为什么还需要加锁呢？
-
-  所以锁消除可以节省毫无意义的请求锁的时间。变量是否逃逸，对于虚拟机来说需要使用数据流分析来确定，但是对于我们程序员来说这还不清楚么？
-
-  我们会在明明知道不存在数据竞争的代码块前加上同步吗？但是有时候程序并不是我们所想的那样？我们虽然没有显示使用锁，但是我们在使用一些JDK的内置API时，如StringBuffer、Vector、HashTable等，这个时候会存在隐形的加锁操作。
-
-  比如StringBuffer的append()方法，Vector的add()方法：
-
-  ```java
-  public void vectorTest(){
-      Vector<String> vector = new Vector<String>();
-      for(int i = 0 ; i < 10 ; i++){
-          vector.add(i + "");
-      }
-
-      System.out.println(vector);
-  }
-  ```
-  在运行这段代码时，JVM可以明显检测到变量vector没有逃逸出方法vectorTest()之外，所以JVM可以大胆地将vector内部的加锁操作消除。
-
-#### 锁粗化
-
-  我们知道在使用同步锁的时候，需要让同步块的作用范围尽可能小—仅在共享数据的实际作用域中才进行同步，这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。
-
-  在大多数的情况下，上述观点是正确的，LZ也一直坚持着这个观点。但是如果一系列的连续加锁解锁操作，可能会导致不必要的性能损耗，所以引入锁粗话的概念。
-
-  锁粗话概念比较好理解，`就是将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁`。
-
-  如上面实例：vector每次add的时候都需要加锁操作，JVM检测到对同一个对象（vector）连续加锁、解锁操作，会合并一个更大范围的加锁、解锁操作，即加锁解锁操作会移到for循环之外。
-
-#### 轻量级锁
-
-  轻量级锁能提升程序同步性能的依据是 **“对于绝大部分的锁，在整个同步周期内都是不存在竞争的”**，这是一个经验数据。
-
-  * 如果没有竞争，轻量级锁使用 **CAS操作避免了使用互斥量的开销**
-  * 但如果存在锁竞争，除了互斥量的开销外，还额外发生了CAS操作，因此在有竞争的情况下，轻量级锁会比传统的重量级锁更慢。
-
-  简单来说：如果发现同步周期内都是 **不存在竞争** ，JVM会使用 **CAS操作来替代操作系统互斥量**。这个优化就被叫做轻量级锁。
-
-  引入轻量级锁的主要目的是在 **多没有多线程竞争的前提** 下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
-  当关闭偏向锁功能或者多个线程竞争偏向锁导致偏向锁升级为轻量级锁，则会尝试获取轻量级锁，其步骤如下：
-  获取锁
-
-  判断当前对象是否处于无锁状态（hashcode、0、01），若是，则JVM首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝（官方把这份拷贝加了一个Displaced前缀，即Displaced Mark Word）；否则执行步骤（3）；
-
-  JVM利用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指正，如果成功表示竞争到锁，则将锁标志位变成00（表示此对象处于轻量级锁状态），执行同步操作；如果失败则执行步骤（3）；
-  判断当前对象的Mark Word是否指向当前线程的栈帧，如果是则表示当前线程已经持有当前对象的锁，则直接执行同步代码块；否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁需要膨胀为重量级锁，锁标志位变成10，后面等待的线程将会进入阻塞状态；
-
-  释放锁
-  轻量级锁的释放也是通过CAS操作来进行的，主要步骤如下：
-
-  取出在获取轻量级锁保存在Displaced Mark Word中的数据；
-  用CAS操作将取出的数据替换当前对象的Mark Word中，如果成功，则说明释放锁成功，否则执行（3）；
-  如果CAS操作替换失败，说明有其他线程尝试获取该锁，则需要在释放锁的同时需要唤醒被挂起的线程。
-  对于轻量级锁，其性能提升的依据是“对于绝大部分的锁，在整个生命周期内都是不会存在竞争的”，如果打破这个依据则除了互斥的开销外，还有额外的CAS操作，因此在有多线程竞争的情况下，轻量级锁比重量级锁更慢；
-
-  下图是轻量级锁的获取和释放过程
-  <img src="img/22222222222222_thumb-1.png">
-
-#### 偏向锁
-
-
-  引入偏向锁主要目的是：**为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径。** 上面提到了轻量级锁的加锁解锁操作是需要依赖多次CAS原子指令的。那么偏向锁是如何来减少不必要的CAS操作呢？我们可以查看Mark work的结构就明白了。只需要检查是否为偏向锁、锁标识为以及ThreadID即可，处理流程如下：
-
-  获取锁
-
-  检测Mark Word是否为可偏向状态，即是否为偏向锁1，锁标识位为01；
-  若为可偏向状态，则测试线程ID是否为当前线程ID，如果是，则执行步骤（5），否则执行步骤（3）；
-  如果线程ID不为当前线程ID，则通过CAS操作竞争锁，竞争成功，则将Mark Word的线程ID替换为当前线程ID，否则执行线程（4）；
-  通过CAS竞争锁失败，证明当前存在多线程竞争情况，当到达全局安全点，获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码块；
-  执行同步代码块
-
-  释放锁
-
-  偏向锁的释放采用了一种只有竞争才会释放锁的机制，线程是不会主动去释放偏向锁，需要等待其他线程来竞争。偏向锁的撤销需要等待全局安全点（这个时间点是上没有正在执行的代码）。其步骤如下：
-
-  暂停拥有偏向锁的线程，判断锁对象石是否还处于被锁定状态；
-  撤销偏向苏，恢复到无锁状态（01）或者轻量级锁的状态；
-  下图是偏向锁的获取和释放流程
-
-  <img src="img/image2_thumb-1.png">
-
-  偏向锁可以提高带有同步但无竞争的程序性能。它同样是一个带有效益权衡（Trade Off）性质的优化，也就是说，它并不一定总是对程序运行有利，如果程序中大多数的锁总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候 使用参数`-XX：-UseBiasedLocking`来禁止偏向锁优化反而可以提升性能。
-
-#### 重量级锁
-
-  重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。
-
-### 参考资料
-  周志明：《深入理解Java虚拟机》
-  方腾飞：《Java并发编程的艺术》
-  [Java中synchronized的实现原理与应用](https://blog.csdn.net/u012465296/article/details/53022317)
+synchronized是一个重量级锁，相对于Lock，它会显得那么笨重，以至于我们认为它不是那么的高效而慢慢摒弃它。
+诚然，随着`Javs SE 1.6`对synchronized进行的各种优化后，synchronized并不会显得那么重了。
+下面跟随LZ一起来探索synchronized的实现机制、Java是如何对它进行了优化、锁优化机制、锁的存储结构和升级过程；
+
+### 实现原理
+
+  **synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性**
+
+  Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
+
+  1. 普通同步方法，锁是当前实例对象 **对象锁**
+  ```java
+   public synchronized void test(){}
+  ```
+  2. 静态同步方法，锁是当前类的class对象 **类锁**
+  ```java
+  public static synchronized void test(){}
+
+  public static void test(){
+      synchronized (TestSynchronized.class) {
+          // TODO
+      }
+  }
+  ```
+  3. 同步方法块，锁是括号里面的对象 **对象锁**
+  ```java
+  public void test(){
+     synchronized (this) {
+         // TODO
+     }
+  }
+  ```
+
+
+  **对象锁**
+
+  一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。
+
+  **类锁** 和 **对象锁** 是不一样的锁，是互相独立的。
+
+  当一个线程访问同步代码块时，它首先是需要得到锁才能执行同步代码，当退出或者抛出异常时必须要释放锁，那么它是如何来实现这个机制的呢？我们先看一段简单的代码：
+  ```java
+  public class SynchronizedTest {
+      public synchronized void test1(){
+
+      }
+      public void test2(){
+          synchronized (this){
+          }
+      }
+  }
+  ```
+  利用javap工具查看生成的class文件信息来分析Synchronize的实现:
+
+  <img src="img/Synchronize-1_thumb-1.jpg">
+
+  从上面可以看出，同步代码块是使用`monitorenter`和`monitorexit`指令实现的，同步方法（在这看不出来需要看JVM底层实现）依靠的是方法修饰符上的`ACC_SYNCHRONIZED`实现。
+
+  **同步代码块**：monitorenter指令插入到同步代码块的开始位置，monitorexit指令插入到同步代码块的结束位置，JVM需要保证每一个monitorenter都有一个monitorexit与之相对应。任何对象都有一个monitor与之相关联，当且一个monitor被持有之后，他将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor所有权，即尝试获取对象的锁；
+
+  **同步方法**：synchronized方法则会被翻译成普通的方法调用和返回指令如:invokevirtual、areturn指令，在VM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法，而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1，表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象。(摘自：http://www.cnblogs.com/javaminer/p/3889023.html)
+
+  下面我们来继续分析，但是在深入之前我们需要了解两个重要的概念：Java对象头，Monitor。
+
+### Java对象头、monitor
+
+  **Java对象头和monitor是实现synchronized的基础！下面就这两个概念来做详细介绍。**
+
+#### Java对象头
+
+  **`synchronized`用的锁是存在Java对象头里的** ，那么什么是Java对象头呢？
+
+  Hotspot虚拟机的对象头主要包括两部分数据：
+  **Mark Word（标记字段）**、**class Pointer（类型指针）**。
+
+  其中`Class Pointer`是是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Word用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键，所以下面将重点阐述Mark Word。
+
+  `Mark Word`用于存储对象自身的运行时数据，
+  如`哈希码（HashCode）`、`GC分代年龄`、`锁状态标志`、`线程持有的锁`、`偏向线程` `ID`、`偏向时间戳`等等。
+
+  Java对象头一般占有两个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit），
+  但是如果对象是数组类型，则需要三个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数组的大小，所以用一块来记录数组长度。
+  下图是Java对象头的存储结构（32位虚拟机）：
+
+  <img src="img/222222_2_thumb-1.jpg">
+
+  对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
+
+  <img src="img/11111111111_2-1.jpg">
+
+#### Monitor
+
+  什么是Monitor？我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。
+
+  与一切皆对象一样，所有的Java对象是天生的Monitor，每一个Java对象都有成为Monitor的潜质，因为在Java的设计中 ，每一个Java对象自打娘胎里出来就带了一把看不见的锁，它叫做`内部锁`或者`Monitor锁`。
+
+  Monitor 是`线程私有`的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联（对象头的MarkWord中的LockWord指向monitor的起始地址），同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用。其结构如下：  
+
+  * **Owner**：初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL；
+  * **EntryQ**: 关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程。
+  * **RcThis**: 表示blocked或waiting在该monitor record上的所有线程的个数。
+  * **Nest**: 用来实现重入锁的计数。
+  * **HashCode**: 保存从对象头拷贝过来的HashCode值（可能还包含GC age）。
+  * **Candidate**: 用来避免不必要的阻塞或等待线程唤醒，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降。Candidate只有两种可能的值0表示没有需要唤醒的线程1表示要唤醒一个继任线程来竞争锁。
+  摘自：Java中synchronized的实现原理与应用）
+  我们知道synchronized是重量级锁，效率不怎么滴，同时这个观念也一直存在我们脑海里，不过在jdk 1.6中对synchronize的实现进行了各种优化，使得它显得不是那么重了，那么JVM采用了那些优化手段呢？
+
+### 锁优化
+
+  jdk1.6对锁的实现引入了大量的优化，如 **自旋锁**、**适应性自旋锁**、**锁消除**、**锁粗化**、**偏向锁**、**轻量级锁** 等技术来减少锁操作的开销。
+  锁主要存在四中状态，依次是：`无锁状态`、`偏向锁状态`、`轻量级锁状态`、`重量级锁状态`，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
+
+  * 自适应偏向锁：自旋时间不固定
+  * 锁消除：如果发现代码是线程安全的，将锁去掉
+  * 锁粗化：加锁范围过小(重复加锁)，将加锁的范围扩展
+  * 轻量级锁：在无竞争的情况下使用CAS操作去消除同步使用的互斥量
+  * 偏向锁：在无竞争环境下，把整个同步都消除，CAS也不做。
+
+#### 自旋锁
+  线程的阻塞和唤醒需要CPU从`用户态`转为`核心态`，频繁的阻塞和唤醒对CPU来说是一件负担很重的工作，势必会给系统的并发性能带来很大的压力。同时我们发现在许多应用上面，`对象锁的锁状态只会持续很短一段时间`，为了这一段很短的时间频繁地阻塞和唤醒线程是非常不值得的。所以引入自旋锁。
+
+  何谓自旋锁？
+  所谓自旋锁，就是让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。怎么等待呢？执行一段无意义的循环即可（自旋）。
+
+  自旋等待不能替代阻塞，先不说对处理器数量的要求（多核，貌似现在没有单核的处理器了），虽然它可以避免线程切换带来的开销，但是它占用了处理器的时间。**如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理的资源，它不会做任何有意义的工作，典型的占着茅坑不拉屎，这样反而会带来性能上的浪费。** 所以说，自旋等待的时间（自旋的次数）必须要有一个限度，如果自旋超过了定义的时间仍然没有获取到锁，则应该被挂起。
+
+  自旋锁在JDK 1.4.2中引入，默认关闭，但是可以使用-XX:+UseSpinning开开启，在JDK1.6中默认开启。同时自旋的`默认次数为10次`，可以通过参数-XX:PreBlockSpin来调整；
+
+  如果通过参数`-XX:preBlockSpin`来调整自旋锁的自旋次数，会带来诸多不便。假如我将参数调整为10，但是系统很多线程都是等你刚刚退出的时候就释放了锁（假如你多自旋一两次就可以获取锁），你是不是很尴尬。于是JDK1.6引入 自适应的自旋锁，让虚拟机会变得越来越聪明。
+
+#### 适应自旋锁
+
+  JDK 1.6引入了更加聪明的自旋锁，即自适应自旋锁。所谓自适应就意味着自旋的次数不再是固定的，它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。
+  它怎么做呢？
+
+  线程如果自旋成功了，那么下次自旋的次数会更加多，因为虚拟机认为既然上次成功了，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多。
+  反之，如果对于某个锁，很少有自旋能够成功的，那么在以后要或者这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源。
+
+  有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测会越来越准确，虚拟机会变得越来越聪明。
+
+#### 锁消除
+
+  为了保证数据的完整性，我们在进行操作时需要对这部分操作进行同步控制，但是在有些情况下，**JVM检测到不可能存在共享数据竞争**，这时JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持。
+
+  如果不存在竞争，为什么还需要加锁呢？
+
+  所以锁消除可以节省毫无意义的请求锁的时间。变量是否逃逸，对于虚拟机来说需要使用数据流分析来确定，但是对于我们程序员来说这还不清楚么？
+
+  我们会在明明知道不存在数据竞争的代码块前加上同步吗？但是有时候程序并不是我们所想的那样？我们虽然没有显示使用锁，但是我们在使用一些JDK的内置API时，如StringBuffer、Vector、HashTable等，这个时候会存在隐形的加锁操作。
+
+  比如StringBuffer的append()方法，Vector的add()方法：
+
+  ```java
+  public void vectorTest(){
+      Vector<String> vector = new Vector<String>();
+      for(int i = 0 ; i < 10 ; i++){
+          vector.add(i + "");
+      }
+
+      System.out.println(vector);
+  }
+  ```
+  在运行这段代码时，JVM可以明显检测到变量vector没有逃逸出方法vectorTest()之外，所以JVM可以大胆地将vector内部的加锁操作消除。
+
+#### 锁粗化
+
+  我们知道在使用同步锁的时候，需要让同步块的作用范围尽可能小—仅在共享数据的实际作用域中才进行同步，这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。
+
+  在大多数的情况下，上述观点是正确的，LZ也一直坚持着这个观点。但是如果一系列的连续加锁解锁操作，可能会导致不必要的性能损耗，所以引入锁粗话的概念。
+
+  锁粗话概念比较好理解，`就是将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁`。
+
+  如上面实例：vector每次add的时候都需要加锁操作，JVM检测到对同一个对象（vector）连续加锁、解锁操作，会合并一个更大范围的加锁、解锁操作，即加锁解锁操作会移到for循环之外。
+
+#### 轻量级锁
+
+  轻量级锁能提升程序同步性能的依据是 **“对于绝大部分的锁，在整个同步周期内都是不存在竞争的”**，这是一个经验数据。
+
+  * 如果没有竞争，轻量级锁使用 **CAS操作避免了使用互斥量的开销**
+  * 但如果存在锁竞争，除了互斥量的开销外，还额外发生了CAS操作，因此在有竞争的情况下，轻量级锁会比传统的重量级锁更慢。
+
+  简单来说：如果发现同步周期内都是 **不存在竞争** ，JVM会使用 **CAS操作来替代操作系统互斥量**。这个优化就被叫做轻量级锁。
+
+  引入轻量级锁的主要目的是在 **多没有多线程竞争的前提** 下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
+  当关闭偏向锁功能或者多个线程竞争偏向锁导致偏向锁升级为轻量级锁，则会尝试获取轻量级锁，其步骤如下：
+  获取锁
+
+  判断当前对象是否处于无锁状态（hashcode、0、01），若是，则JVM首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝（官方把这份拷贝加了一个Displaced前缀，即Displaced Mark Word）；否则执行步骤（3）；
+
+  JVM利用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指正，如果成功表示竞争到锁，则将锁标志位变成00（表示此对象处于轻量级锁状态），执行同步操作；如果失败则执行步骤（3）；
+  判断当前对象的Mark Word是否指向当前线程的栈帧，如果是则表示当前线程已经持有当前对象的锁，则直接执行同步代码块；否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁需要膨胀为重量级锁，锁标志位变成10，后面等待的线程将会进入阻塞状态；
+
+  释放锁
+  轻量级锁的释放也是通过CAS操作来进行的，主要步骤如下：
+
+  取出在获取轻量级锁保存在Displaced Mark Word中的数据；
+  用CAS操作将取出的数据替换当前对象的Mark Word中，如果成功，则说明释放锁成功，否则执行（3）；
+  如果CAS操作替换失败，说明有其他线程尝试获取该锁，则需要在释放锁的同时需要唤醒被挂起的线程。
+  对于轻量级锁，其性能提升的依据是“对于绝大部分的锁，在整个生命周期内都是不会存在竞争的”，如果打破这个依据则除了互斥的开销外，还有额外的CAS操作，因此在有多线程竞争的情况下，轻量级锁比重量级锁更慢；
+
+  下图是轻量级锁的获取和释放过程
+  <img src="img/22222222222222_thumb-1.png">
+
+#### 偏向锁
+
+
+  引入偏向锁主要目的是：**为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径。** 上面提到了轻量级锁的加锁解锁操作是需要依赖多次CAS原子指令的。那么偏向锁是如何来减少不必要的CAS操作呢？我们可以查看Mark work的结构就明白了。只需要检查是否为偏向锁、锁标识为以及ThreadID即可，处理流程如下：
+
+  获取锁
+
+  检测Mark Word是否为可偏向状态，即是否为偏向锁1，锁标识位为01；
+  若为可偏向状态，则测试线程ID是否为当前线程ID，如果是，则执行步骤（5），否则执行步骤（3）；
+  如果线程ID不为当前线程ID，则通过CAS操作竞争锁，竞争成功，则将Mark Word的线程ID替换为当前线程ID，否则执行线程（4）；
+  通过CAS竞争锁失败，证明当前存在多线程竞争情况，当到达全局安全点，获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码块；
+  执行同步代码块
+
+  释放锁
+
+  偏向锁的释放采用了一种只有竞争才会释放锁的机制，线程是不会主动去释放偏向锁，需要等待其他线程来竞争。偏向锁的撤销需要等待全局安全点（这个时间点是上没有正在执行的代码）。其步骤如下：
+
+  暂停拥有偏向锁的线程，判断锁对象石是否还处于被锁定状态；
+  撤销偏向苏，恢复到无锁状态（01）或者轻量级锁的状态；
+  下图是偏向锁的获取和释放流程
+
+  <img src="img/image2_thumb-1.png">
+
+  偏向锁可以提高带有同步但无竞争的程序性能。它同样是一个带有效益权衡（Trade Off）性质的优化，也就是说，它并不一定总是对程序运行有利，如果程序中大多数的锁总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候 使用参数`-XX：-UseBiasedLocking`来禁止偏向锁优化反而可以提升性能。
+
+#### 重量级锁
+
+  重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。
+
+### 参考资料
+  周志明：《深入理解Java虚拟机》
+  方腾飞：《Java并发编程的艺术》
+  [Java中synchronized的实现原理与应用](https://blog.csdn.net/u012465296/article/details/53022317)
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/02 - \346\267\261\345\205\245\345\210\206\346\236\220volatile\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/02 - \346\267\261\345\205\245\345\210\206\346\236\220volatile\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/02 - \346\267\261\345\205\245\345\210\206\346\236\220volatile\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/02 - \346\267\261\345\205\245\345\210\206\346\236\220volatile\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
index d57c207b..aa3df78c 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/02 - \346\267\261\345\205\245\345\210\206\346\236\220volatile\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/02 - \346\267\261\345\205\245\345\210\206\346\236\220volatile\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"	
@@ -1,142 +1,142 @@
-通过前面一章我们了解了synchronized是一个重量级的锁，虽然JVM对它做了很多优化，而下面介绍的volatile则是轻量级的synchronized。
-如果一个变量使用volatile，则它比使用synchronized的成本更加低，因为它不会引起线程上下文的切换和调度。Java语言规范对volatile的定义如下：
-
-    **Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。**
-
-上面比较绕口，通俗点讲就是说一个变量如果用volatile修饰了，则Java可以确保所有线程看到这个变量的值是一致的，如果某个线程对volatile修饰的共享变量进行更新，那么其他线程可以立马看到这个更新，这就是所谓的 **线程可见性**。
-
-volatile虽然看起来比较简单，使用起来无非就是在一个变量前面加上volatile即可，但是要用好并不容易（LZ承认我至今仍然使用不好，在使用时仍然是模棱两可）。
-
-### 内存模型相关概念
-
-  理解volatile其实还是有点儿难度的，它与Java的内存模型有关，所以在理解volatile之前我们需要先了解有关Java内存模型的概念，这里只做初步的介绍，后续LZ会详细介绍Java内存模型。
-
-#### 操作系统语义
-
-  计算机在运行程序时，每条指令都是在CPU中执行的，在执行过程中势必会涉及到数据的读写。
-
-  我们知道程序运行的数据是存储在 **主存** 中，这时就会有一个问题，读写主存中的数据没有CPU中执行指令的速度快，如果任何的交互都需要与主存打交道则会大大影响效率，所以就有了 **CPU高速缓存**。CPU高速缓存为某个CPU独有，只与在该CPU运行的线程有关。
-
-  有了CPU高速缓存虽然解决了效率问题，但是它会带来一个新的问题：**数据一致性** 。在程序运行中，会将运行所需要的数据复制一份到CPU高速缓存中，在进行运算时CPU不再也主存打交道，而是直接从高速缓存中读写数据，只有当运行结束后才会将数据刷新到主存中。举一个简单的例子：
-  ```
-  i++i++
-  ```
-
-  当线程运行这段代码时，首先会从主存中读取i( i = 1)，然后复制一份到CPU高速缓存中，然后CPU执行 + 1 （2）的操作，然后将数据（2）写入到告诉缓存中，最后刷新到主存中。其实这样做在单线程中是没有问题的，有问题的是在多线程中。如下：
-
-  假如有两个线程A、B都执行这个操作（i++），按照我们正常的逻辑思维主存中的i值应该=3，但事实是这样么？分析如下：
-
-  两个线程从主存中读取i的值（1）到各自的高速缓存中，然后线程A执行+1操作并将结果写入高速缓存中，最后写入主存中，此时主存i==2,线程B做同样的操作，主存中的i仍然=2。所以最终结果为2并不是3。这种现象就是缓存一致性问题。
-
-  解决 **缓存一致性方案** 有两种：
-
-  * 通过在总线加LOCK#锁的方式
-  * 通过缓存一致性协议（MESI协议）
-
-  但是方案1存在一个问题，它是采用一种独占的方式来实现的，即总线加LOCK#锁的话，只能有一个CPU能够运行，其他CPU都得阻塞，效率较为低下。
-
-  第二种方案，缓存一致性协议（MESI协议）它确保每个缓存中使用的共享变量的副本是一致的。其核心思想如下：当某个CPU在写数据时，如果发现操作的变量是共享变量，则会通知其他CPU告知该变量的缓存行是无效的，因此其他CPU在读取该变量时，发现其无效会重新从主存中加载数据。
-  <img src="img/212219343783699_thumb-1.jpg">
-
-#### Java内存模型
-  上面从操作系统层次阐述了如何保证数据一致性，下面我们来看一下Java内存模型，稍微研究一下Java内存模型为我们提供了哪些保证以及在Java中提供了哪些方法和机制来让我们在进行多线程编程时能够保证程序执行的正确性。
-
-  在并发编程中我们一般都会遇到这三个基本概念：`原子性`、`可见性`、`有序性`。我们稍微看下volatile
-
-#### 内存语义
-  当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立刻刷新到主内存中
-  当读一个volatile变量时，JMM会把该线程对应的本地内存设置为失效，直接从主内存中读取共享变量
-
-##### 原子性
-
-    **原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。**
-
-  原子性就像数据库里面的事务一样，他们是一个团队，同生共死。其实理解原子性非常简单，我们看下面一个简单的例子即可：
-  ```
-  i = 0;            ---1
-  j = i ;            ---2
-  i++;            ---3
-  i = j + 1;    ---4
-  ```
-
-  上面四个操作，有哪个几个是原子操作，那几个不是？如果不是很理解，可能会认为都是原子性操作，其实只有1才是原子操作，其余均不是。
-
-  1—在Java中，对基本数据类型的变量和赋值操作都是原子性操作；
-  2—包含了两个操作：读取i，将i值赋值给j
-  3—包含了三个操作：读取i值、i + 1 、将+1结果赋值给i；
-  4—同三一样
-
-  在单线程环境下我们可以认为整个步骤都是原子性操作，但是在多线程环境下则不同，Java只保证了基本数据类型的变量和赋值操作才是原子性的（注：在32位的JDK环境下，对64位数据的读取不是原子性操作*，如long、double）。要想在多线程环境下保证原子性，则可以通过锁、synchronized来确保。
-
-    **volatile对单个读/写具有原子性，无法保证复合操作（例如i++）的原子性**
-
-##### 可见性
-
-    **可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。**
-
-  在上面已经分析了，在多线程环境下，一个线程对共享变量的操作对其他线程是不可见的。
-
-  **Java提供了volatile来保证可见性。**
-
-  当一个变量被volatile修饰后，表示着线程本地内存无效，当一个线程修改共享变量后他会立即被更新到主内存中，当其他线程读取共享变量时，它会直接从主内存中读取。
-  当然，synchronize和锁都可以保证可见性。
-
-##### 有序性
-
-    **有序性：即程序执行的顺序按照代码的先后顺序执行。**
-
-  在Java内存模型中，为了效率是允许编译器和处理器对指令进行重排序，当然重排序它不会影响单线程的运行结果，但是对多线程会有影响。
-
-  Java提供volatile来保证一定的有序性。最著名的例子就是单例模式里面的DCL（双重检查锁）。这里LZ就不再阐述了。
-
-### 剖析volatile原理 **内存屏障**
-
-  JMM比较庞大，不是上面一点点就能够阐述的。上面简单地介绍都是为了volatile做铺垫的。
-
-    **volatile可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在JVM底层volatile是采用“内存屏障”来实现的。**
-
-  上面那段话，有两层语义
-
-  1. 保证可见性、提供一定的有序性、不保证原子性
-  2. 禁止指令重排序
-
-  第一层语义就不做介绍了，下面重点介绍指令重排序。
-  在执行程序时为了提高性能，编译器和处理器通常会对指令做重排序：
-
-  1. 编译器重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序；
-  2. 处理器重排序。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序；
-
-  指令重排序对单线程没有什么影响，他不会影响程序的运行结果，但是会影响多线程的正确性。既然指令重排序会影响到 **多线程** 执行的正确性，那么我们就需要禁止重排序。那么JVM是 **如何禁止重排序的呢**？这个问题稍后回答，我们先看另一个原则`happens-before`，happen-before原则保证了程序的“`有序性`”，它规定如果两个操作的执行顺序无法从happens-before原则中推到出来，那么他们就不能保证有序性，可以随意进行重排序。其定义如下：
-
-  1. 同一个线程中的，前面的操作 happen-before 后续的操作。（即单线程内按代码顺序执行。但是，在不影响在单线程环境执行结果的前提下，编译器和处理器可以进行重排序，这是合法的。换句话说，这一是规则无法保证编译重排和指令重排）。
-  2. 监视器上的解锁操作 happen-before 其后续的加锁操作。（Synchronized 规则）
-  3. 对volatile变量的写操作 happen-before 后续的读操作。（volatile 规则）
-  4. 线程的start() 方法 happen-before 该线程所有的后续操作。（线程启动规则）
-  5. 线程所有的操作 happen-before 其他线程在该线程上调用 join 返回成功后的操作。
-  6. 如果 a happen-before b，b happen-before c，则a happen-before c（传递性）。
-
-  我们着重看第三点volatile规则：对volatile变量的写操作 happen-before 后续的读操作。为了实现volatile内存语义，JMM会重排序，其规则如下：
-
-  对happen-before原则有了稍微的了解，我们再来回答这个问题JVM是如何禁止重排序的？
-
-  <img src="img/20170104-volatile_thumb-1.jpg">
-
-  **观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令。** lock前缀指令其实就相当于一个内存屏障。内存屏障是一组处理指令，用来实现对内存操作的顺序限制。volatile的底层就是通过内存屏障来实现的。下图是完成上述规则所需要的内存屏障：
-
-  volatile暂且下分析到这里，JMM体系较为庞大，不是三言两语能够说清楚的，后面会结合JMM再一次对volatile深入分析。
-
-  <img src="img/20170104-volatile2_thumb-1.jpg">
-
-### 总结
-  volatile看起来简单，但是要想理解它还是比较难的，这里只是对其进行基本的了解。volatile相对于synchronized稍微轻量些，在某些场合它可以替代synchronized，但是又不能完全取代synchronized，只有在某些场合才能够使用volatile。使用它必须满足如下两个条件：
-
-  1. 对变量的写操作不依赖当前值；
-  2. 该变量没有包含在具有其他变量的不变式中。
-
-  **volatile经常用于两个两个场景：状态标记量、double check**(双重检测 单例模式)
-
-### 参考资料
-周志明：《深入理解Java虚拟机》
-方腾飞：《Java并发编程的艺术》
-Java并发编程：volatile关键字解析 http://www.cnblogs.com/dolphin0520/p/3920373.html
-Java 并发编程：volatile的使用及其原理 http://www.cnblogs.com/paddix/p/5428507.html
+通过前面一章我们了解了synchronized是一个重量级的锁，虽然JVM对它做了很多优化，而下面介绍的volatile则是轻量级的synchronized。
+如果一个变量使用volatile，则它比使用synchronized的成本更加低，因为它不会引起线程上下文的切换和调度。Java语言规范对volatile的定义如下：
+
+    **Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。**
+
+上面比较绕口，通俗点讲就是说一个变量如果用volatile修饰了，则Java可以确保所有线程看到这个变量的值是一致的，如果某个线程对volatile修饰的共享变量进行更新，那么其他线程可以立马看到这个更新，这就是所谓的 **线程可见性**。
+
+volatile虽然看起来比较简单，使用起来无非就是在一个变量前面加上volatile即可，但是要用好并不容易（LZ承认我至今仍然使用不好，在使用时仍然是模棱两可）。
+
+### 内存模型相关概念
+
+  理解volatile其实还是有点儿难度的，它与Java的内存模型有关，所以在理解volatile之前我们需要先了解有关Java内存模型的概念，这里只做初步的介绍，后续LZ会详细介绍Java内存模型。
+
+#### 操作系统语义
+
+  计算机在运行程序时，每条指令都是在CPU中执行的，在执行过程中势必会涉及到数据的读写。
+
+  我们知道程序运行的数据是存储在 **主存** 中，这时就会有一个问题，读写主存中的数据没有CPU中执行指令的速度快，如果任何的交互都需要与主存打交道则会大大影响效率，所以就有了 **CPU高速缓存**。CPU高速缓存为某个CPU独有，只与在该CPU运行的线程有关。
+
+  有了CPU高速缓存虽然解决了效率问题，但是它会带来一个新的问题：**数据一致性** 。在程序运行中，会将运行所需要的数据复制一份到CPU高速缓存中，在进行运算时CPU不再也主存打交道，而是直接从高速缓存中读写数据，只有当运行结束后才会将数据刷新到主存中。举一个简单的例子：
+  ```
+  i++i++
+  ```
+
+  当线程运行这段代码时，首先会从主存中读取i( i = 1)，然后复制一份到CPU高速缓存中，然后CPU执行 + 1 （2）的操作，然后将数据（2）写入到告诉缓存中，最后刷新到主存中。其实这样做在单线程中是没有问题的，有问题的是在多线程中。如下：
+
+  假如有两个线程A、B都执行这个操作（i++），按照我们正常的逻辑思维主存中的i值应该=3，但事实是这样么？分析如下：
+
+  两个线程从主存中读取i的值（1）到各自的高速缓存中，然后线程A执行+1操作并将结果写入高速缓存中，最后写入主存中，此时主存i==2,线程B做同样的操作，主存中的i仍然=2。所以最终结果为2并不是3。这种现象就是缓存一致性问题。
+
+  解决 **缓存一致性方案** 有两种：
+
+  * 通过在总线加LOCK#锁的方式
+  * 通过缓存一致性协议（MESI协议）
+
+  但是方案1存在一个问题，它是采用一种独占的方式来实现的，即总线加LOCK#锁的话，只能有一个CPU能够运行，其他CPU都得阻塞，效率较为低下。
+
+  第二种方案，缓存一致性协议（MESI协议）它确保每个缓存中使用的共享变量的副本是一致的。其核心思想如下：当某个CPU在写数据时，如果发现操作的变量是共享变量，则会通知其他CPU告知该变量的缓存行是无效的，因此其他CPU在读取该变量时，发现其无效会重新从主存中加载数据。
+  <img src="img/212219343783699_thumb-1.jpg">
+
+#### Java内存模型
+  上面从操作系统层次阐述了如何保证数据一致性，下面我们来看一下Java内存模型，稍微研究一下Java内存模型为我们提供了哪些保证以及在Java中提供了哪些方法和机制来让我们在进行多线程编程时能够保证程序执行的正确性。
+
+  在并发编程中我们一般都会遇到这三个基本概念：`原子性`、`可见性`、`有序性`。我们稍微看下volatile
+
+#### 内存语义
+  当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立刻刷新到主内存中
+  当读一个volatile变量时，JMM会把该线程对应的本地内存设置为失效，直接从主内存中读取共享变量
+
+##### 原子性
+
+    **原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。**
+
+  原子性就像数据库里面的事务一样，他们是一个团队，同生共死。其实理解原子性非常简单，我们看下面一个简单的例子即可：
+  ```
+  i = 0;            ---1
+  j = i ;            ---2
+  i++;            ---3
+  i = j + 1;    ---4
+  ```
+
+  上面四个操作，有哪个几个是原子操作，那几个不是？如果不是很理解，可能会认为都是原子性操作，其实只有1才是原子操作，其余均不是。
+
+  1—在Java中，对基本数据类型的变量和赋值操作都是原子性操作；
+  2—包含了两个操作：读取i，将i值赋值给j
+  3—包含了三个操作：读取i值、i + 1 、将+1结果赋值给i；
+  4—同三一样
+
+  在单线程环境下我们可以认为整个步骤都是原子性操作，但是在多线程环境下则不同，Java只保证了基本数据类型的变量和赋值操作才是原子性的（注：在32位的JDK环境下，对64位数据的读取不是原子性操作*，如long、double）。要想在多线程环境下保证原子性，则可以通过锁、synchronized来确保。
+
+    **volatile对单个读/写具有原子性，无法保证复合操作（例如i++）的原子性**
+
+##### 可见性
+
+    **可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。**
+
+  在上面已经分析了，在多线程环境下，一个线程对共享变量的操作对其他线程是不可见的。
+
+  **Java提供了volatile来保证可见性。**
+
+  当一个变量被volatile修饰后，表示着线程本地内存无效，当一个线程修改共享变量后他会立即被更新到主内存中，当其他线程读取共享变量时，它会直接从主内存中读取。
+  当然，synchronize和锁都可以保证可见性。
+
+##### 有序性
+
+    **有序性：即程序执行的顺序按照代码的先后顺序执行。**
+
+  在Java内存模型中，为了效率是允许编译器和处理器对指令进行重排序，当然重排序它不会影响单线程的运行结果，但是对多线程会有影响。
+
+  Java提供volatile来保证一定的有序性。最著名的例子就是单例模式里面的DCL（双重检查锁）。这里LZ就不再阐述了。
+
+### 剖析volatile原理 **内存屏障**
+
+  JMM比较庞大，不是上面一点点就能够阐述的。上面简单地介绍都是为了volatile做铺垫的。
+
+    **volatile可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在JVM底层volatile是采用“内存屏障”来实现的。**
+
+  上面那段话，有两层语义
+
+  1. 保证可见性、提供一定的有序性、不保证原子性
+  2. 禁止指令重排序
+
+  第一层语义就不做介绍了，下面重点介绍指令重排序。
+  在执行程序时为了提高性能，编译器和处理器通常会对指令做重排序：
+
+  1. 编译器重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序；
+  2. 处理器重排序。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序；
+
+  指令重排序对单线程没有什么影响，他不会影响程序的运行结果，但是会影响多线程的正确性。既然指令重排序会影响到 **多线程** 执行的正确性，那么我们就需要禁止重排序。那么JVM是 **如何禁止重排序的呢**？这个问题稍后回答，我们先看另一个原则`happens-before`，happen-before原则保证了程序的“`有序性`”，它规定如果两个操作的执行顺序无法从happens-before原则中推到出来，那么他们就不能保证有序性，可以随意进行重排序。其定义如下：
+
+  1. 同一个线程中的，前面的操作 happen-before 后续的操作。（即单线程内按代码顺序执行。但是，在不影响在单线程环境执行结果的前提下，编译器和处理器可以进行重排序，这是合法的。换句话说，这一是规则无法保证编译重排和指令重排）。
+  2. 监视器上的解锁操作 happen-before 其后续的加锁操作。（Synchronized 规则）
+  3. 对volatile变量的写操作 happen-before 后续的读操作。（volatile 规则）
+  4. 线程的start() 方法 happen-before 该线程所有的后续操作。（线程启动规则）
+  5. 线程所有的操作 happen-before 其他线程在该线程上调用 join 返回成功后的操作。
+  6. 如果 a happen-before b，b happen-before c，则a happen-before c（传递性）。
+
+  我们着重看第三点volatile规则：对volatile变量的写操作 happen-before 后续的读操作。为了实现volatile内存语义，JMM会重排序，其规则如下：
+
+  对happen-before原则有了稍微的了解，我们再来回答这个问题JVM是如何禁止重排序的？
+
+  <img src="img/20170104-volatile_thumb-1.jpg">
+
+  **观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令。** lock前缀指令其实就相当于一个内存屏障。内存屏障是一组处理指令，用来实现对内存操作的顺序限制。volatile的底层就是通过内存屏障来实现的。下图是完成上述规则所需要的内存屏障：
+
+  volatile暂且下分析到这里，JMM体系较为庞大，不是三言两语能够说清楚的，后面会结合JMM再一次对volatile深入分析。
+
+  <img src="img/20170104-volatile2_thumb-1.jpg">
+
+### 总结
+  volatile看起来简单，但是要想理解它还是比较难的，这里只是对其进行基本的了解。volatile相对于synchronized稍微轻量些，在某些场合它可以替代synchronized，但是又不能完全取代synchronized，只有在某些场合才能够使用volatile。使用它必须满足如下两个条件：
+
+  1. 对变量的写操作不依赖当前值；
+  2. 该变量没有包含在具有其他变量的不变式中。
+
+  **volatile经常用于两个两个场景：状态标记量、double check**(双重检测 单例模式)
+
+### 参考资料
+周志明：《深入理解Java虚拟机》
+方腾飞：《Java并发编程的艺术》
+Java并发编程：volatile关键字解析 http://www.cnblogs.com/dolphin0520/p/3920373.html
+Java 并发编程：volatile的使用及其原理 http://www.cnblogs.com/paddix/p/5428507.html
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/03 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213happens-before.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/03 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213happens-before.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/03 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213happens-before.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/03 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213happens-before.md"
index 5c41a88b..b13c7529 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/03 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213happens-before.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/03 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213happens-before.md"	
@@ -1,81 +1,81 @@
-  由于存在线程本地内存和主内存的原因，再加上重排序，会导致多线程环境下存在可见性的问题。
-  那么我们正确使用同步、锁的情况下，线程A修改了变量a何时对线程B可见？
-
-  我们无法就所有场景来规定某个线程修改的变量何时对其他线程可见，但是我们可以指定某些规则，这规则就是happens-before，从JDK 5 开始，JMM就使用happens-before的概念来阐述多线程之间的内存可见性。
-
-    **在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。**
-
-  happens-before原则非常重要，**它是判断数据是否存在竞争、线程是否安全的主要依据**，依靠这个原则，我们解决在并发环境下两操作之间是否可能存在冲突的所有问题。下面我们就一个简单的例子稍微了解下happens-before ；
-  ```
-  i = 1;       //线程A执行
-  j = i ;      //线程B执行
-  ```
-  j 是否等于1呢？假定线程A的操作（i = 1）happens-before线程B的操作（j = i）,那么可以确定线程B执行后j = 1 一定成立，如果他们不存在happens-before原则，那么j = 1 不一定成立。这就是happens-before原则的威力。
-
-  happens-before原则定义如下:
-  1. 如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
-  2. 两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果`重排序之后的执行结果`与`按照happens-before关系来执行的结果` **一致**，那么这种`重排序并不非法`。
-
-  下面是happens-before原则规则：
-  1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
-  2. 锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；
-  3. volatile变量规则：对一个变量的 **写操作** 先行发生于后面对这个变量的 **读操作**；
-  4. 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
-  5. 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
-  6. 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
-  7. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段
-  检测到线程已经终止执行；
-  8. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；
-  我们来详细看看上面每条规则（摘自《深入理解Java虚拟机第12章》）：
-  **程序次序规则**：一段代码在单线程中执行的结果是有序的。注意是执行结果，因为虚拟机、处理器会对指令进行重排序（重排序后面会详细介绍）。虽然重排序了，但是并不会影响程序的执行结果，所以程序最终执行的结果与顺序执行的结果是一致的。故而这个规则只对单线程有效，在多线程环境下无法保证正确性。
-
-  **锁定规则**：这个规则比较好理解，无论是在单线程环境还是多线程环境，一个锁处于被锁定状态，那么必须先执行unlock操作后面才能进行lock操作。
-
-  **volatile变量规则**：这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。
-
-  **传递规则**：提现了happens-before原则具有传递性，即A happens-before B , B happens-before C，那么A happens-before C
-
-  **线程启动规则**：假定线程A在执行过程中，通过执行ThreadB.start()来启动线程B，那么线程A对共享变量的修改在接下来线程B开始执行后确保对线程B可见。
-
-  **线程终结规则**：假定线程A在执行的过程中，通过制定ThreadB.join()等待线程B终止，那么线程B在终止之前对共享变量的修改在线程A等待返回后可见。
-
-  上面八条是原生Java满足Happens-before关系的规则，但是我们可以对他们进行推导出其他满足happens-before的规则：
-
-  1. 将一个元素放入一个线程安全的队列的操作Happens-Before从队列中取出这个元素的操作
-  2. 将一个元素放入一个线程安全容器的操作Happens-Before从容器中取出这个元素的操作
-  3. 在CountDownLatch上的倒数操作Happens-Before CountDownLatch#await()操作
-  4. 释放Semaphore许可的操作Happens-Before获得许可操作
-  5. Future表示的任务的所有操作Happens-Before Future#get()操作
-  6. 向Executor提交一个Runnable或Callable的操作Happens-Before任务开始执行操作
-
-  这里再说一遍happens-before的概念：
-    **如果两个操作不存在上述（前面8条 + 后面6条）任一一个happens-before规则，那么这两个操作就没有顺序的保障，JVM可以对这两个操作进行重排序。如果操作A happens-before操作B，那么操作A在内存上所做的操作对操作B都是可见的。**
-
-  下面就用一个简单的例子来描述下happens-before原则：
-  ```JAVA
-  private int i = 0;
-  public void write(int j ){
-      i = j;
-  }
-  public int read(){
-      return i;
-  }
-  ```
-
-  我们约定线程A执行write()，线程B执行read()，且线程A优先于线程B执行，那么线程B获得结果是什么？；我们就这段简单的代码一次分析happens-before的规则（规则5、6、7、8 + 推导的6条可以忽略，因为他们和这段代码毫无关系）：
-
-  1. 由于两个方法是由不同的线程调用，所以肯定不满足程序次序规则；
-  2. 两个方法都没有使用锁，所以不满足锁定规则；
-  3. 变量i不是用volatile修饰的，所以volatile变量规则不满足；
-  4. 传递规则肯定不满足；
-
-  所以我们无法通过happens-before原则推导出线程A happens-before线程B，虽然可以确认在时间上线程A优先于线程B指定，但是就是无法确认线程B获得的结果是什么，所以这段代码不是线程安全的。那么怎么修复这段代码呢？满足规则2、3任一即可。
-
-    **happen-before原则是JMM中非常重要的原则，它是判断数据是否存在竞争、线程是否安全的主要依据，保证了多线程环境下的可见性。**
-
-  下图是happens-before与JMM的关系图（摘自《Java并发编程的艺术》）
-  <img src="img/happens-before_thumb.png">
-
-### 参考资料
-  周志明：《深入理解Java虚拟机》
-  方腾飞：《Java并发编程的艺术》
+  由于存在线程本地内存和主内存的原因，再加上重排序，会导致多线程环境下存在可见性的问题。
+  那么我们正确使用同步、锁的情况下，线程A修改了变量a何时对线程B可见？
+
+  我们无法就所有场景来规定某个线程修改的变量何时对其他线程可见，但是我们可以指定某些规则，这规则就是happens-before，从JDK 5 开始，JMM就使用happens-before的概念来阐述多线程之间的内存可见性。
+
+    **在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。**
+
+  happens-before原则非常重要，**它是判断数据是否存在竞争、线程是否安全的主要依据**，依靠这个原则，我们解决在并发环境下两操作之间是否可能存在冲突的所有问题。下面我们就一个简单的例子稍微了解下happens-before ；
+  ```
+  i = 1;       //线程A执行
+  j = i ;      //线程B执行
+  ```
+  j 是否等于1呢？假定线程A的操作（i = 1）happens-before线程B的操作（j = i）,那么可以确定线程B执行后j = 1 一定成立，如果他们不存在happens-before原则，那么j = 1 不一定成立。这就是happens-before原则的威力。
+
+  happens-before原则定义如下:
+  1. 如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
+  2. 两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果`重排序之后的执行结果`与`按照happens-before关系来执行的结果` **一致**，那么这种`重排序并不非法`。
+
+  下面是happens-before原则规则：
+  1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
+  2. 锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；
+  3. volatile变量规则：对一个变量的 **写操作** 先行发生于后面对这个变量的 **读操作**；
+  4. 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
+  5. 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
+  6. 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
+  7. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段
+  检测到线程已经终止执行；
+  8. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；
+  我们来详细看看上面每条规则（摘自《深入理解Java虚拟机第12章》）：
+  **程序次序规则**：一段代码在单线程中执行的结果是有序的。注意是执行结果，因为虚拟机、处理器会对指令进行重排序（重排序后面会详细介绍）。虽然重排序了，但是并不会影响程序的执行结果，所以程序最终执行的结果与顺序执行的结果是一致的。故而这个规则只对单线程有效，在多线程环境下无法保证正确性。
+
+  **锁定规则**：这个规则比较好理解，无论是在单线程环境还是多线程环境，一个锁处于被锁定状态，那么必须先执行unlock操作后面才能进行lock操作。
+
+  **volatile变量规则**：这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。
+
+  **传递规则**：提现了happens-before原则具有传递性，即A happens-before B , B happens-before C，那么A happens-before C
+
+  **线程启动规则**：假定线程A在执行过程中，通过执行ThreadB.start()来启动线程B，那么线程A对共享变量的修改在接下来线程B开始执行后确保对线程B可见。
+
+  **线程终结规则**：假定线程A在执行的过程中，通过制定ThreadB.join()等待线程B终止，那么线程B在终止之前对共享变量的修改在线程A等待返回后可见。
+
+  上面八条是原生Java满足Happens-before关系的规则，但是我们可以对他们进行推导出其他满足happens-before的规则：
+
+  1. 将一个元素放入一个线程安全的队列的操作Happens-Before从队列中取出这个元素的操作
+  2. 将一个元素放入一个线程安全容器的操作Happens-Before从容器中取出这个元素的操作
+  3. 在CountDownLatch上的倒数操作Happens-Before CountDownLatch#await()操作
+  4. 释放Semaphore许可的操作Happens-Before获得许可操作
+  5. Future表示的任务的所有操作Happens-Before Future#get()操作
+  6. 向Executor提交一个Runnable或Callable的操作Happens-Before任务开始执行操作
+
+  这里再说一遍happens-before的概念：
+    **如果两个操作不存在上述（前面8条 + 后面6条）任一一个happens-before规则，那么这两个操作就没有顺序的保障，JVM可以对这两个操作进行重排序。如果操作A happens-before操作B，那么操作A在内存上所做的操作对操作B都是可见的。**
+
+  下面就用一个简单的例子来描述下happens-before原则：
+  ```JAVA
+  private int i = 0;
+  public void write(int j ){
+      i = j;
+  }
+  public int read(){
+      return i;
+  }
+  ```
+
+  我们约定线程A执行write()，线程B执行read()，且线程A优先于线程B执行，那么线程B获得结果是什么？；我们就这段简单的代码一次分析happens-before的规则（规则5、6、7、8 + 推导的6条可以忽略，因为他们和这段代码毫无关系）：
+
+  1. 由于两个方法是由不同的线程调用，所以肯定不满足程序次序规则；
+  2. 两个方法都没有使用锁，所以不满足锁定规则；
+  3. 变量i不是用volatile修饰的，所以volatile变量规则不满足；
+  4. 传递规则肯定不满足；
+
+  所以我们无法通过happens-before原则推导出线程A happens-before线程B，虽然可以确认在时间上线程A优先于线程B指定，但是就是无法确认线程B获得的结果是什么，所以这段代码不是线程安全的。那么怎么修复这段代码呢？满足规则2、3任一即可。
+
+    **happen-before原则是JMM中非常重要的原则，它是判断数据是否存在竞争、线程是否安全的主要依据，保证了多线程环境下的可见性。**
+
+  下图是happens-before与JMM的关系图（摘自《Java并发编程的艺术》）
+  <img src="img/happens-before_thumb.png">
+
+### 参考资料
+  周志明：《深入理解Java虚拟机》
+  方腾飞：《Java并发编程的艺术》
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/04 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\351\207\215\346\216\222\345\272\217.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/04 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\351\207\215\346\216\222\345\272\217.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/04 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\351\207\215\346\216\222\345\272\217.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/04 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\351\207\215\346\216\222\345\272\217.md"
index cf3794d3..8f2c129d 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/04 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\351\207\215\346\216\222\345\272\217.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/04 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\351\207\215\346\216\222\345\272\217.md"	
@@ -1,90 +1,90 @@
-在执行程序时，为了提供性能，处理器和编译器常常会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么排序，它需要满足以下两个条件：
-
-  1. 在单线程环境下不能改变程序运行的结果；
-  2. 存在数据依赖关系的不允许重排序
-
-如果看过LZ上篇博客的就会知道，其实这两点可以归结于一点：无法通过happens-before原则推导出来的，JMM允许任意的排序。
-
-### as-if-serial语义
-
-  as-if-serial语义的意思是，所有的操作均可以为了优化而被重排序，但是你必须要保证重排序后执行的结果不能被改变，编译器、runtime、处理器都必须遵守as-if-serial语义。注意as-if-serial只保证单线程环境，多线程环境下无效。
-
-  下面我们用一个简单的示例来说明：
-  ```java
-  int a = 1 ;      //A
-  int b = 2 ;      //B
-  int c = a + b;   //C
-  ```
-  A、B、C三个操作存在如下关系：A、B不存在数据依赖关系，A和C、B和C存在数据依赖关系，因此在进行重排序的时候，A、B可以随意排序，但是必须位于C的前面，执行顺序可以是A –> B –> C或者B –> A –> C。但是无论是何种执行顺序最终的结果C总是等于3。
-
-  as-if-serail语义把单线程程序保护起来了，它可以保证在重排序的前提下程序的最终结果始终都是一致的。
-
-  其实对于上段代码，他们存在这样的happen-before关系：
-
-  A happens-before B
-  B happens-before C
-  A happens-before C
-
-  1、2是程序顺序次序规则，3是传递性。但是，不是说通过重排序，B可能会排在A之前执行么，为何还会存在存在A happens-beforeB呢？这里再次申明A happens-before B不是A一定会在B之前执行，而是A的对B可见，但是相对于这个程序A的执行结果不需要对B可见，且他们重排序后不会影响结果，所以JMM不会认为这种重排序非法。
-
-  我们需要明白这点：在不改变程序执行结果的前提下，尽可能提高程序的运行效率。
-
-  下面我们在看一段有意思的代码：
-  ```java
-  public class RecordExample1 {
-      public static void main(String[] args){
-          int a = 1;
-          int b = 2;
-          try {
-              a = 3;           //A
-              b = 1 / 0;       //B
-          } catch (Exception e) {
-          } finally {
-              System.out.println("a = " + a);
-          }
-      }
-  }
-  ```
-  按照重排序的规则，操作A与操作B有可能会进行重排序，如果重排序了，B会抛出异常（ / by zero），此时A语句一定会执行不到，那么a还会等于3么？
-  如果按照as-if-serial原则它就改变了程序的结果。其实JVM对异常做了一种特殊的处理，为了保证as-if-serial语义，Java异常处理机制对重排序做了一种特殊的处理：JIT在重排序时会在catch语句中插入错误代偿代码（a = 3）,这样做虽然会导致cathc里面的逻辑变得复杂，但是JIT优化原则是：尽可能地优化程序正常运行下的逻辑，哪怕以catch块逻辑变得复杂为代价。
-
-### 重排序对多线程的影响
-  在单线程环境下由于as-if-serial语义，重排序无法影响最终的结果，但是对于多线程环境呢？
-  如下代码（volatile的经典用法）：
-  ```java
-  public class RecordExample2 {
-      int a = 0;
-      boolean flag = false;
-      /**
-       * A线程执行
-       */
-      public void writer(){
-          a = 1;                  // 1
-          flag = true;            // 2
-      }
-      /**
-       * B线程执行
-       */
-      public void read(){
-          if(flag){                  // 3
-             int i = a + a;          // 4
-          }
-      }
-
-  }
-  ```
-  A线程执行writer()，线程B执行read()，线程B在执行时能否读到 a = 1 呢？答案是不一定（**注：X86CPU不支持写写重排序，如果是在x86上面操作，这个一定会是a=1,LZ搞了好久都没有测试出来，最后查资料才发现**）。
-
-  由于操作1 和操作2 之间没有数据依赖性，所以可以进行重排序处理，操作3 和操作4 之间也没有数据依赖性，他们亦可以进行重排序，但是操作3 和操作4 之间存在控制依赖性。假如操作1 和操作2 之间重排序：
-
-  <img src="img/20170110001_thumb-2.jpg">
-
-  按照这种执行顺序线程B肯定读不到线程A设置的a值，在这里多线程的语义就已经被重排序破坏了。
-
-  操作3 和操作4 之间也可以重排序，这里就不阐述了。但是他们之间存在一个控制依赖的关系，因为只有操作3 成立操作4 才会执行。当代码中存在控制依赖性时，会影响指令序列的执行的并行度，所以编译器和处理器会采用猜测执行来克服控制依赖对并行度的影响。假如操作3 和操作4重排序了，操作4 先执行，则先会把计算结果临时保存到重排序缓冲中，当操作3 为真时才会将计算结果写入变量i中
-
-  通过上面的分析，**重排序不会影响单线程环境的执行结果，但是会破坏多线程的执行语义。**
-
-### 参考资料
-周志明 ：《深入理解Java虚拟机》
-方腾飞：《Java并发编程的艺术》
+在执行程序时，为了提供性能，处理器和编译器常常会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么排序，它需要满足以下两个条件：
+
+  1. 在单线程环境下不能改变程序运行的结果；
+  2. 存在数据依赖关系的不允许重排序
+
+如果看过LZ上篇博客的就会知道，其实这两点可以归结于一点：无法通过happens-before原则推导出来的，JMM允许任意的排序。
+
+### as-if-serial语义
+
+  as-if-serial语义的意思是，所有的操作均可以为了优化而被重排序，但是你必须要保证重排序后执行的结果不能被改变，编译器、runtime、处理器都必须遵守as-if-serial语义。注意as-if-serial只保证单线程环境，多线程环境下无效。
+
+  下面我们用一个简单的示例来说明：
+  ```java
+  int a = 1 ;      //A
+  int b = 2 ;      //B
+  int c = a + b;   //C
+  ```
+  A、B、C三个操作存在如下关系：A、B不存在数据依赖关系，A和C、B和C存在数据依赖关系，因此在进行重排序的时候，A、B可以随意排序，但是必须位于C的前面，执行顺序可以是A –> B –> C或者B –> A –> C。但是无论是何种执行顺序最终的结果C总是等于3。
+
+  as-if-serail语义把单线程程序保护起来了，它可以保证在重排序的前提下程序的最终结果始终都是一致的。
+
+  其实对于上段代码，他们存在这样的happen-before关系：
+
+  A happens-before B
+  B happens-before C
+  A happens-before C
+
+  1、2是程序顺序次序规则，3是传递性。但是，不是说通过重排序，B可能会排在A之前执行么，为何还会存在存在A happens-beforeB呢？这里再次申明A happens-before B不是A一定会在B之前执行，而是A的对B可见，但是相对于这个程序A的执行结果不需要对B可见，且他们重排序后不会影响结果，所以JMM不会认为这种重排序非法。
+
+  我们需要明白这点：在不改变程序执行结果的前提下，尽可能提高程序的运行效率。
+
+  下面我们在看一段有意思的代码：
+  ```java
+  public class RecordExample1 {
+      public static void main(String[] args){
+          int a = 1;
+          int b = 2;
+          try {
+              a = 3;           //A
+              b = 1 / 0;       //B
+          } catch (Exception e) {
+          } finally {
+              System.out.println("a = " + a);
+          }
+      }
+  }
+  ```
+  按照重排序的规则，操作A与操作B有可能会进行重排序，如果重排序了，B会抛出异常（ / by zero），此时A语句一定会执行不到，那么a还会等于3么？
+  如果按照as-if-serial原则它就改变了程序的结果。其实JVM对异常做了一种特殊的处理，为了保证as-if-serial语义，Java异常处理机制对重排序做了一种特殊的处理：JIT在重排序时会在catch语句中插入错误代偿代码（a = 3）,这样做虽然会导致cathc里面的逻辑变得复杂，但是JIT优化原则是：尽可能地优化程序正常运行下的逻辑，哪怕以catch块逻辑变得复杂为代价。
+
+### 重排序对多线程的影响
+  在单线程环境下由于as-if-serial语义，重排序无法影响最终的结果，但是对于多线程环境呢？
+  如下代码（volatile的经典用法）：
+  ```java
+  public class RecordExample2 {
+      int a = 0;
+      boolean flag = false;
+      /**
+       * A线程执行
+       */
+      public void writer(){
+          a = 1;                  // 1
+          flag = true;            // 2
+      }
+      /**
+       * B线程执行
+       */
+      public void read(){
+          if(flag){                  // 3
+             int i = a + a;          // 4
+          }
+      }
+
+  }
+  ```
+  A线程执行writer()，线程B执行read()，线程B在执行时能否读到 a = 1 呢？答案是不一定（**注：X86CPU不支持写写重排序，如果是在x86上面操作，这个一定会是a=1,LZ搞了好久都没有测试出来，最后查资料才发现**）。
+
+  由于操作1 和操作2 之间没有数据依赖性，所以可以进行重排序处理，操作3 和操作4 之间也没有数据依赖性，他们亦可以进行重排序，但是操作3 和操作4 之间存在控制依赖性。假如操作1 和操作2 之间重排序：
+
+  <img src="img/20170110001_thumb-2.jpg">
+
+  按照这种执行顺序线程B肯定读不到线程A设置的a值，在这里多线程的语义就已经被重排序破坏了。
+
+  操作3 和操作4 之间也可以重排序，这里就不阐述了。但是他们之间存在一个控制依赖的关系，因为只有操作3 成立操作4 才会执行。当代码中存在控制依赖性时，会影响指令序列的执行的并行度，所以编译器和处理器会采用猜测执行来克服控制依赖对并行度的影响。假如操作3 和操作4重排序了，操作4 先执行，则先会把计算结果临时保存到重排序缓冲中，当操作3 为真时才会将计算结果写入变量i中
+
+  通过上面的分析，**重排序不会影响单线程环境的执行结果，但是会破坏多线程的执行语义。**
+
+### 参考资料
+周志明 ：《深入理解Java虚拟机》
+方腾飞：《Java并发编程的艺术》
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/05 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\345\210\206\346\236\220volatile.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/05 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\345\210\206\346\236\220volatile.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/05 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\345\210\206\346\236\220volatile.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/05 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\345\210\206\346\236\220volatile.md"
index 7a7b03cf..6c835e6c 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/05 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\345\210\206\346\236\220volatile.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/05 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\345\210\206\346\236\220volatile.md"	
@@ -1,129 +1,129 @@
-  volatile的特性：
-
-  1. volatile可见性；对一个volatile的读，总可以看到对这个变量最终的写；
-  2. volatile原子性；volatile对单个读/写具有原子性（32位Long、Double），但是复合操作除外，例如i++;
-  3. JVM底层采用 **内存屏障** 来实现volatile语义
-
-  下面LZ就通过happens-before原则和volatile的内存语义两个方向介绍volatile。
-
-### volatile与happens-before
-  happens-before是用来判断是否存数据竞争、线程是否安全的主要依据，它保证了多线程环境下的可见性。
-  下面我们就那个经典的例子来分析volatile变量的读写建立的happens-before关系。
-  ```java
-  public class VolatileTest {
-      int i = 0;
-      volatile boolean flag = false;
-      //Thread A
-      public void write(){
-          i = 2;              //1
-          flag = true;        //2
-      }
-      //Thread B
-      public void read(){
-          if(flag){                                   //3
-              System.out.println("---i = " + i);      //4
-          }
-      }
-  }
-  ```
-  依据happens-before原则，就上面程序得到如下关系：
-
-  依据happens-before程序顺序原则：1 happens-before 2、3 happens-before 4；
-  根据happens-before的volatile原则：2 happens-before 3；
-  根据happens-before的传递性：1 happens-before 4
-  操作1、操作4存在happens-before关系，那么1一定是对4可见的。
-  可能有同学就会问，操作1、操作2可能会发生重排序啊，会吗？如果看过LZ的博客就会明白，volatile除了保证可见性外，还有就是禁止重排序。
-  所以A线程在写volatile变量之前所有可见的共享变量，在线程B读同一个volatile变量后，将立即变得对线程B可见。
-
-### volataile的内存语义及其实现
-
-  在JMM中，线程之间的通信采用共享内存来实现的。volatile的内存语义是：
-
-    **当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新到主内存中。**
-    **当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量**
-
-  所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。
-  那么volatile的内存语义是如何实现的呢？对于一般的变量则会被重排序，而对于volatile则不能，这样会影响其内存语义，所以为了实现volatile的内存语义JMM会限制重排序。其重排序规则如下：
-
-  翻译如下：
-
-  1. 如果第一个操作为volatile读，则不管第二个操作是啥，都不能重排序。这个操作确保volatile读之后的操作不会被编译器重排序到volatile读之前；
-  2. 当第二个操作为volatile写是，则不管第一个操作是啥，都不能重排序。这个操作确保volatile写之前的操作不会被编译器重排序到volatile写之后；
-  3. 当第一个操作volatile写，第二操作为volatile读时，不能重排序。
-
-  volatile的底层实现是通过插入内存屏障，但是对于编译器来说，发现一个最优布置来最小化插入内存屏障的总数几乎是不可能的，所以，JMM采用了保守策略。如下：
-
-  * 在每一个volatile写操作前面插入一个StoreStore屏障
-  * 在每一个volatile写操作后面插入一个StoreLoad屏障
-  * 在每一个volatile读操作后面插入一个LoadLoad屏障
-  * 在每一个volatile读操作后面插入一个LoadStore屏障
-
-  StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存中。
-
-  StoreLoad屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序。
-
-  LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。
-
-  LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。
-
-  下面我们就上面那个VolatileTest例子分析下：
-  ```java
-  public class VolatileTest {
-      int i = 0;
-      volatile boolean flag = false;
-      public void write(){
-          i = 2;
-          flag = true;
-      }
-
-      public void read(){
-          if(flag){
-              System.out.println("---i = " + i);
-          }
-      }
-  }
-  ```
-  <img src="img/u7ED8_u56FE1_thumb-1.png">
-  上面通过一个例子稍微演示了volatile指令的内存屏障图例。
-
-  volatile的内存屏障插入策略非常保守，其实在实际中，只要不改变volatile写-读得内存语义，编译器可以根据具体情况优化，省略不必要的屏障。如下（摘自方腾飞 《Java并发编程的艺术》）：
-  ```java
-  public class VolatileBarrierExample {
-      int a = 0;
-      volatile int v1 = 1;
-      volatile int v2 = 2;
-
-      void readAndWrite(){
-          int i = v1;     //volatile读
-          int j = v2;     //volatile读
-          a = i + j;      //普通读
-          v1 = i + 1;     //volatile写
-          v2 = j * 2;     //volatile写
-      }
-  }
-  ```
-  没有优化的示例图如下：
-  <img src="img/14844980432094444444_thumb-1.png">
-  我们来分析上图有哪些内存屏障指令是多余的
-
-  1：这个肯定要保留了
-
-  2：禁止下面所有的普通写与上面的volatile读重排序，但是由于存在第二个volatile读，那个普通的读根本无法越过第二个volatile读。所以可以省略。
-
-  3：下面已经不存在普通读了，可以省略。
-
-  4：保留
-
-  5：保留
-
-  6：下面跟着一个volatile写，所以可以省略
-
-  7：保留
-
-  8：保留
-
-  所以2、3、6可以省略，其示意图如下：
-  <img src="img/1484498051529555555_thumb-1.png">
-
-### 参考资料
-方腾飞：《Java并发编程的艺术》
+  volatile的特性：
+
+  1. volatile可见性；对一个volatile的读，总可以看到对这个变量最终的写；
+  2. volatile原子性；volatile对单个读/写具有原子性（32位Long、Double），但是复合操作除外，例如i++;
+  3. JVM底层采用 **内存屏障** 来实现volatile语义
+
+  下面LZ就通过happens-before原则和volatile的内存语义两个方向介绍volatile。
+
+### volatile与happens-before
+  happens-before是用来判断是否存数据竞争、线程是否安全的主要依据，它保证了多线程环境下的可见性。
+  下面我们就那个经典的例子来分析volatile变量的读写建立的happens-before关系。
+  ```java
+  public class VolatileTest {
+      int i = 0;
+      volatile boolean flag = false;
+      //Thread A
+      public void write(){
+          i = 2;              //1
+          flag = true;        //2
+      }
+      //Thread B
+      public void read(){
+          if(flag){                                   //3
+              System.out.println("---i = " + i);      //4
+          }
+      }
+  }
+  ```
+  依据happens-before原则，就上面程序得到如下关系：
+
+  依据happens-before程序顺序原则：1 happens-before 2、3 happens-before 4；
+  根据happens-before的volatile原则：2 happens-before 3；
+  根据happens-before的传递性：1 happens-before 4
+  操作1、操作4存在happens-before关系，那么1一定是对4可见的。
+  可能有同学就会问，操作1、操作2可能会发生重排序啊，会吗？如果看过LZ的博客就会明白，volatile除了保证可见性外，还有就是禁止重排序。
+  所以A线程在写volatile变量之前所有可见的共享变量，在线程B读同一个volatile变量后，将立即变得对线程B可见。
+
+### volataile的内存语义及其实现
+
+  在JMM中，线程之间的通信采用共享内存来实现的。volatile的内存语义是：
+
+    **当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新到主内存中。**
+    **当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量**
+
+  所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。
+  那么volatile的内存语义是如何实现的呢？对于一般的变量则会被重排序，而对于volatile则不能，这样会影响其内存语义，所以为了实现volatile的内存语义JMM会限制重排序。其重排序规则如下：
+
+  翻译如下：
+
+  1. 如果第一个操作为volatile读，则不管第二个操作是啥，都不能重排序。这个操作确保volatile读之后的操作不会被编译器重排序到volatile读之前；
+  2. 当第二个操作为volatile写是，则不管第一个操作是啥，都不能重排序。这个操作确保volatile写之前的操作不会被编译器重排序到volatile写之后；
+  3. 当第一个操作volatile写，第二操作为volatile读时，不能重排序。
+
+  volatile的底层实现是通过插入内存屏障，但是对于编译器来说，发现一个最优布置来最小化插入内存屏障的总数几乎是不可能的，所以，JMM采用了保守策略。如下：
+
+  * 在每一个volatile写操作前面插入一个StoreStore屏障
+  * 在每一个volatile写操作后面插入一个StoreLoad屏障
+  * 在每一个volatile读操作后面插入一个LoadLoad屏障
+  * 在每一个volatile读操作后面插入一个LoadStore屏障
+
+  StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存中。
+
+  StoreLoad屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序。
+
+  LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。
+
+  LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。
+
+  下面我们就上面那个VolatileTest例子分析下：
+  ```java
+  public class VolatileTest {
+      int i = 0;
+      volatile boolean flag = false;
+      public void write(){
+          i = 2;
+          flag = true;
+      }
+
+      public void read(){
+          if(flag){
+              System.out.println("---i = " + i);
+          }
+      }
+  }
+  ```
+  <img src="img/u7ED8_u56FE1_thumb-1.png">
+  上面通过一个例子稍微演示了volatile指令的内存屏障图例。
+
+  volatile的内存屏障插入策略非常保守，其实在实际中，只要不改变volatile写-读得内存语义，编译器可以根据具体情况优化，省略不必要的屏障。如下（摘自方腾飞 《Java并发编程的艺术》）：
+  ```java
+  public class VolatileBarrierExample {
+      int a = 0;
+      volatile int v1 = 1;
+      volatile int v2 = 2;
+
+      void readAndWrite(){
+          int i = v1;     //volatile读
+          int j = v2;     //volatile读
+          a = i + j;      //普通读
+          v1 = i + 1;     //volatile写
+          v2 = j * 2;     //volatile写
+      }
+  }
+  ```
+  没有优化的示例图如下：
+  <img src="img/14844980432094444444_thumb-1.png">
+  我们来分析上图有哪些内存屏障指令是多余的
+
+  1：这个肯定要保留了
+
+  2：禁止下面所有的普通写与上面的volatile读重排序，但是由于存在第二个volatile读，那个普通的读根本无法越过第二个volatile读。所以可以省略。
+
+  3：下面已经不存在普通读了，可以省略。
+
+  4：保留
+
+  5：保留
+
+  6：下面跟着一个volatile写，所以可以省略
+
+  7：保留
+
+  8：保留
+
+  所以2、3、6可以省略，其示意图如下：
+  <img src="img/1484498051529555555_thumb-1.png">
+
+### 参考资料
+方腾飞：《Java并发编程的艺术》
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/06 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\344\273\216JMM\350\247\222\345\272\246\345\210\206\346\236\220DCL\357\274\210\345\217\214\351\207\215\346\243\200\346\265\213\357\274\211.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/06 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\344\273\216JMM\350\247\222\345\272\246\345\210\206\346\236\220DCL\357\274\210\345\217\214\351\207\215\346\243\200\346\265\213\357\274\211.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/06 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\344\273\216JMM\350\247\222\345\272\246\345\210\206\346\236\220DCL\357\274\210\345\217\214\351\207\215\346\243\200\346\265\213\357\274\211.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/06 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\344\273\216JMM\350\247\222\345\272\246\345\210\206\346\236\220DCL\357\274\210\345\217\214\351\207\215\346\243\200\346\265\213\357\274\211.md"
index 6dee3c91..60a9faf2 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/06 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\344\273\216JMM\350\247\222\345\272\246\345\210\206\346\236\220DCL\357\274\210\345\217\214\351\207\215\346\243\200\346\265\213\357\274\211.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/06 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\344\273\216JMM\350\247\222\345\272\246\345\210\206\346\236\220DCL\357\274\210\345\217\214\351\207\215\346\243\200\346\265\213\357\274\211.md"	
@@ -1,129 +1,129 @@
-DCL，即Double Check Lock，中卫双重检查锁定。其实DCL很多人在单例模式中用过，LZ面试人的时候也要他们写过，但是有很多人都会写错。他们为什么会写错呢？其错误根源在哪里？有什么解决方案？下面就随LZ一起来分析
-
-### 问题分析
-  我们先看单例模式里面的懒汉式：
-  ```java
-  public class Singleton {
-      private static Singleton singleton;
-
-      private Singleton(){}
-
-      public static Singleton getInstance(){
-          if(singleton == null){
-              singleton = new Singleton();
-          }
-
-          return singleton;
-      }
-  }
-  ```
-  我们都知道这种写法是错误的，因为它无法保证线程的安全性。优化如下：
-  ```java
-  public class Singleton {
-      private static Singleton singleton;
-
-      private Singleton(){}
-
-      public static synchronized Singleton getInstance(){
-          if(singleton == null){
-              singleton = new Singleton();
-          }
-
-          return singleton;
-      }
-  }
-  ```
-  优化非常简单，就是在getInstance方法上面做了同步，但是synchronized就会导致这个方法比较低效，导致程序性能下降，那么怎么解决呢？聪明的人们想到了双重检查 DCL：
-  ```java
-  public class Singleton {
-      private static Singleton singleton;
-
-      private Singleton(){}
-
-      public static Singleton getInstance(){
-          if(singleton == null){                              // 1
-              synchronized (Singleton.class){                 // 2
-                  if(singleton == null){                      // 3
-                      singleton = new Singleton();            // 4
-                  }
-              }
-          }
-          return singleton;
-      }
-  }
-  ```
-  就如上面所示，这个代码看起来很完美，理由如下：
-
-  如果检查第一个singleton不为null,则不需要执行下面的加锁动作，极大提高了程序的性能；
-  如果第一个singleton为null,即使有多个线程同一时间判断，但是由于synchronized的存在，只会有一个线程能够创建对象；
-  当第一个获取锁的线程创建完成后singleton对象后，其他的在第二次判断singleton一定不会为null，则直接返回已经创建好的singleton对象；
-  通过上面的分析，DCL看起确实是非常完美，但是可以明确地告诉你，这个错误的。上面的逻辑确实是没有问题，分析也对，但是就是有问题，那么问题出在哪里呢？在回答这个问题之前，我们先来复习一下创建对象过程，实例化一个对象要分为三个步骤：
-
-  分配内存空间
-  初始化对象
-  将内存空间的地址赋值给对应的引用
-  但是由于重排序的缘故，步骤2、3可能会发生重排序，其过程如下：
-
-  分配内存空间
-  将内存空间的地址赋值给对应的引用
-  初始化对象
-  如果2、3发生了重排序就会导致第二个判断会出错，singleton != null，但是它其实仅仅只是一个地址而已，此时对象还没有被初始化，所以return的singleton对象是一个没有被初始化的对象，如下：
-  <img src="img/DCL00001_2_thumb.png">
-  按照上面图例所示，线程B访问的是一个没有被初始化的singleton对象。
-
-  通过上面的阐述，我们可以判断DCL的错误根源在于步骤4：
-  ```java
-  singleton = new Singleton();
-  ```
-  知道问题根源所在，那么怎么解决呢？有两个解决办法：
-
-  不允许初始化阶段步骤2 、3发生重排序。
-  允许初始化阶段步骤2 、3发生重排序，但是不允许其他线程“看到”这个重排序。
-
-### 解决方案
-  解决方案依据上面两个解决办法即可。
-
-#### 基于volatile解决方案
-  对于上面的DCL其实只需要做一点点修改即可：将变量singleton生命为volatile即可：
-  ``` java
-  public class Singleton {
-      //通过volatile关键字来确保安全
-      private volatile static Singleton singleton;
-
-      private Singleton(){}
-
-      public static Singleton getInstance(){
-          if(singleton == null){
-              synchronized (Singleton.class){
-                  if(singleton == null){
-                      singleton = new Singleton();
-                  }
-              }
-          }
-          return singleton;
-      }
-  }
-  ```
-  当singleton声明为volatile后，步骤2、步骤3就不会被重排序了，也就可以解决上面那问题了。
-
-#### 基于类初始化的解决方案
-  该解决方案的根本就在于：利用classloder的机制来保证初始化instance时只有一个线程。JVM在类初始化阶段会获取一个锁，这个锁可以同步多个线程对同一个类的初始化。
-  ```java
-  public class Singleton {
-      private static class SingletonHolder{
-          public static Singleton singleton = new Singleton();
-      }
-
-      public static Singleton getInstance(){
-          return SingletonHolder.singleton;
-      }
-  }
-  ```
-  这种解决方案的实质是：运行步骤2和步骤3重排序，但是不允许其他线程看见。
-
-    **Java语言规定，对于每一个类或者接口C,都有一个唯一的初始化锁LC与之相对应。从C到LC的映射，由JVM的具体实现去自由实现。JVM在类初始化阶段期间会获取这个初始化锁，并且每一个线程至少获取一次锁来确保这个类已经被初始化过了。**
-
-  <img src="img/singleton_thumb.png">
-
-### 参考资料
-    方腾飞：《Java并发编程的艺术》    
+DCL，即Double Check Lock，中卫双重检查锁定。其实DCL很多人在单例模式中用过，LZ面试人的时候也要他们写过，但是有很多人都会写错。他们为什么会写错呢？其错误根源在哪里？有什么解决方案？下面就随LZ一起来分析
+
+### 问题分析
+  我们先看单例模式里面的懒汉式：
+  ```java
+  public class Singleton {
+      private static Singleton singleton;
+
+      private Singleton(){}
+
+      public static Singleton getInstance(){
+          if(singleton == null){
+              singleton = new Singleton();
+          }
+
+          return singleton;
+      }
+  }
+  ```
+  我们都知道这种写法是错误的，因为它无法保证线程的安全性。优化如下：
+  ```java
+  public class Singleton {
+      private static Singleton singleton;
+
+      private Singleton(){}
+
+      public static synchronized Singleton getInstance(){
+          if(singleton == null){
+              singleton = new Singleton();
+          }
+
+          return singleton;
+      }
+  }
+  ```
+  优化非常简单，就是在getInstance方法上面做了同步，但是synchronized就会导致这个方法比较低效，导致程序性能下降，那么怎么解决呢？聪明的人们想到了双重检查 DCL：
+  ```java
+  public class Singleton {
+      private static Singleton singleton;
+
+      private Singleton(){}
+
+      public static Singleton getInstance(){
+          if(singleton == null){                              // 1
+              synchronized (Singleton.class){                 // 2
+                  if(singleton == null){                      // 3
+                      singleton = new Singleton();            // 4
+                  }
+              }
+          }
+          return singleton;
+      }
+  }
+  ```
+  就如上面所示，这个代码看起来很完美，理由如下：
+
+  如果检查第一个singleton不为null,则不需要执行下面的加锁动作，极大提高了程序的性能；
+  如果第一个singleton为null,即使有多个线程同一时间判断，但是由于synchronized的存在，只会有一个线程能够创建对象；
+  当第一个获取锁的线程创建完成后singleton对象后，其他的在第二次判断singleton一定不会为null，则直接返回已经创建好的singleton对象；
+  通过上面的分析，DCL看起确实是非常完美，但是可以明确地告诉你，这个错误的。上面的逻辑确实是没有问题，分析也对，但是就是有问题，那么问题出在哪里呢？在回答这个问题之前，我们先来复习一下创建对象过程，实例化一个对象要分为三个步骤：
+
+  分配内存空间
+  初始化对象
+  将内存空间的地址赋值给对应的引用
+  但是由于重排序的缘故，步骤2、3可能会发生重排序，其过程如下：
+
+  分配内存空间
+  将内存空间的地址赋值给对应的引用
+  初始化对象
+  如果2、3发生了重排序就会导致第二个判断会出错，singleton != null，但是它其实仅仅只是一个地址而已，此时对象还没有被初始化，所以return的singleton对象是一个没有被初始化的对象，如下：
+  <img src="img/DCL00001_2_thumb.png">
+  按照上面图例所示，线程B访问的是一个没有被初始化的singleton对象。
+
+  通过上面的阐述，我们可以判断DCL的错误根源在于步骤4：
+  ```java
+  singleton = new Singleton();
+  ```
+  知道问题根源所在，那么怎么解决呢？有两个解决办法：
+
+  不允许初始化阶段步骤2 、3发生重排序。
+  允许初始化阶段步骤2 、3发生重排序，但是不允许其他线程“看到”这个重排序。
+
+### 解决方案
+  解决方案依据上面两个解决办法即可。
+
+#### 基于volatile解决方案
+  对于上面的DCL其实只需要做一点点修改即可：将变量singleton生命为volatile即可：
+  ``` java
+  public class Singleton {
+      //通过volatile关键字来确保安全
+      private volatile static Singleton singleton;
+
+      private Singleton(){}
+
+      public static Singleton getInstance(){
+          if(singleton == null){
+              synchronized (Singleton.class){
+                  if(singleton == null){
+                      singleton = new Singleton();
+                  }
+              }
+          }
+          return singleton;
+      }
+  }
+  ```
+  当singleton声明为volatile后，步骤2、步骤3就不会被重排序了，也就可以解决上面那问题了。
+
+#### 基于类初始化的解决方案
+  该解决方案的根本就在于：利用classloder的机制来保证初始化instance时只有一个线程。JVM在类初始化阶段会获取一个锁，这个锁可以同步多个线程对同一个类的初始化。
+  ```java
+  public class Singleton {
+      private static class SingletonHolder{
+          public static Singleton singleton = new Singleton();
+      }
+
+      public static Singleton getInstance(){
+          return SingletonHolder.singleton;
+      }
+  }
+  ```
+  这种解决方案的实质是：运行步骤2和步骤3重排序，但是不允许其他线程看见。
+
+    **Java语言规定，对于每一个类或者接口C,都有一个唯一的初始化锁LC与之相对应。从C到LC的映射，由JVM的具体实现去自由实现。JVM在类初始化阶段期间会获取这个初始化锁，并且每一个线程至少获取一次锁来确保这个类已经被初始化过了。**
+
+  <img src="img/singleton_thumb.png">
+
+### 参考资料
+    方腾飞：《Java并发编程的艺术》    
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/07 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\346\200\273\347\273\223.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/07 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\346\200\273\347\273\223.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/07 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\346\200\273\347\273\223.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/07 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\346\200\273\347\273\223.md"
index 073fbc21..4a2b1ea5 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/07 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\346\200\273\347\273\223.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/07 - Java\345\206\205\345\255\230\346\250\241\345\236\213\344\271\213\346\200\273\347\273\223.md"	
@@ -1,30 +1,30 @@
-  JMM规定了线程的工作内存和主内存的交互关系，以及线程之间的可见性和程序的执行顺序。
-  一方面，要为程序员提供足够强的内存可见性保证；另一方面，对编译器和处理器的限制要尽可能地放松。JMM对程序员屏蔽了CPU以及OS内存的使用问题，能够使程序在不同的CPU和OS内存上都能够达到预期的效果。
-
-  Java采用内存共享的模式来实现线程之间的通信。编译器和处理器可以对程序进行重排序优化处理，但是需要遵守一些规则，不能随意重排序。
-
-  `原子性`：一个操作或者多个操作要么全部执行要么全部不执行；
-
-  `可见性`：当多个线程同时访问一个共享变量时，如果其中某个线程更改了该共享变量，其他线程应该可以立刻看到这个改变；
-
-  `有序性`：程序的执行要按照代码的先后顺序执行；
-
-  在并发编程模式中，势必会遇到上面三个概念，JMM对原子性并没有提供确切的解决方案，但是JMM解决了可见性和有序性，至于原子性则需要通过锁或者Synchronized来解决了。
-
-  如果一个操作A的操作结果需要对操作B可见，那么我们就认为操作A和操作B之间存在happens-before关系，即A happens-before B。
-
-  happens-before原则是JMM中非常重要的一个原则，它是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们可以解决在并发环境下两个操作之间是否存在冲突的所有问题。JMM规定，两个操作存在happens-before关系并不一定要A操作先于B操作执行，只要A操作的结果对B操作可见即可。
-
-  在程序运行过程中，为了执行的效率，编译器和处理器是可以对程序进行一定的重排序，但是他们必须要满足两个条件：1 执行的结果保持不变，2 存在数据依赖的不能重排序。重排序是引起多线程不安全的一个重要因素。
-
-  同时顺序一致性是一个比较理想化的参考模型，它为我们提供了强大而又有力的内存可见性保证，他主要有两个特征：1 一个线程中的所有操作必须按照程序的顺序来执行；2 所有线程都只能看到一个单一的操作执行顺序，在顺序一致性模型中，每个操作都必须原则执行且立刻对所有线程可见。
-
-
-  重排序
-
-
-  顺序一致性
-
-  happens-before
-
-  as-if-serial
+  JMM规定了线程的工作内存和主内存的交互关系，以及线程之间的可见性和程序的执行顺序。
+  一方面，要为程序员提供足够强的内存可见性保证；另一方面，对编译器和处理器的限制要尽可能地放松。JMM对程序员屏蔽了CPU以及OS内存的使用问题，能够使程序在不同的CPU和OS内存上都能够达到预期的效果。
+
+  Java采用内存共享的模式来实现线程之间的通信。编译器和处理器可以对程序进行重排序优化处理，但是需要遵守一些规则，不能随意重排序。
+
+  `原子性`：一个操作或者多个操作要么全部执行要么全部不执行；
+
+  `可见性`：当多个线程同时访问一个共享变量时，如果其中某个线程更改了该共享变量，其他线程应该可以立刻看到这个改变；
+
+  `有序性`：程序的执行要按照代码的先后顺序执行；
+
+  在并发编程模式中，势必会遇到上面三个概念，JMM对原子性并没有提供确切的解决方案，但是JMM解决了可见性和有序性，至于原子性则需要通过锁或者Synchronized来解决了。
+
+  如果一个操作A的操作结果需要对操作B可见，那么我们就认为操作A和操作B之间存在happens-before关系，即A happens-before B。
+
+  happens-before原则是JMM中非常重要的一个原则，它是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们可以解决在并发环境下两个操作之间是否存在冲突的所有问题。JMM规定，两个操作存在happens-before关系并不一定要A操作先于B操作执行，只要A操作的结果对B操作可见即可。
+
+  在程序运行过程中，为了执行的效率，编译器和处理器是可以对程序进行一定的重排序，但是他们必须要满足两个条件：1 执行的结果保持不变，2 存在数据依赖的不能重排序。重排序是引起多线程不安全的一个重要因素。
+
+  同时顺序一致性是一个比较理想化的参考模型，它为我们提供了强大而又有力的内存可见性保证，他主要有两个特征：1 一个线程中的所有操作必须按照程序的顺序来执行；2 所有线程都只能看到一个单一的操作执行顺序，在顺序一致性模型中，每个操作都必须原则执行且立刻对所有线程可见。
+
+
+  重排序
+
+
+  顺序一致性
+
+  happens-before
+
+  as-if-serial
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/08 - J.U.C\344\271\213AQS\357\274\232AQS\347\256\200\344\273\213.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/08 - J.U.C\344\271\213AQS\357\274\232AQS\347\256\200\344\273\213.md"
similarity index 99%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/08 - J.U.C\344\271\213AQS\357\274\232AQS\347\256\200\344\273\213.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/08 - J.U.C\344\271\213AQS\357\274\232AQS\347\256\200\344\273\213.md"
index 497e7cc2..a054a1de 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/08 - J.U.C\344\271\213AQS\357\274\232AQS\347\256\200\344\273\213.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/08 - J.U.C\344\271\213AQS\357\274\232AQS\347\256\200\344\273\213.md"	
@@ -1,41 +1,41 @@
-
-  Java的内置锁一直都是备受争议的，在JDK 1.6之前，synchronized这个重量级锁其性能一直都是较为低下，虽然在1.6后，进行大量的锁优化策略,但是与Lock相比synchronized还是存在一些缺陷的：虽然synchronized提供了便捷性的隐式获取锁释放锁机制（基于JVM机制），但是它却缺少了获取锁与释放锁的可操作性，可中断、超时获取锁，且它为独占式在高并发场景下性能大打折扣。
-
-  在介绍Lock之前，我们需要先熟悉一个非常重要的组件，掌握了该组件JUC包下面很多问题都不在是问题了。该组件就是AQS。
-
-  AQS，**AbstractQueuedSynchronizer**，即 **队列同步器**。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），JUC并发包的作者（Doug Lea）期望它能够成为实现大部分同步需求的基础。**它是JUC并发包中的核心基础组件。**
-
-  **AQS解决了在实现同步器时涉及当的大量细节问题，例如获取同步状态、FIFO同步队列。** 基于AQS来构建同步器可以带来很多好处。它不仅能够极大地减少实现工作，而且也不必处理在多个位置上发生的竞争问题。
-
-
-  在基于AQS构建的同步器中，只能在一个时刻发生阻塞，从而降低上下文切换的开销，提高了吞吐量。同时在设计AQS时充分考虑了可伸缩行，因此J.U.C中所有基于AQS构建的同步器均可以获得这个优势。
-
-  **采用了模板方法模式，AQS实现大量通用方法，AQS的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态。**
-
-  AQS使用一个int类型的成员变量state来表示同步状态，当state>0时表示已经获取了锁，当state = 0时表示释放了锁。它提供了三个方法（getState()、setState(int newState)、compareAndSetState(int expect,int update)）来对同步状态state进行操作，当然AQS可以确保对state的操作是安全的。
-
-  AQS通过内置的FIFO同步队列来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，则会把节点中的线程唤醒，使其再次尝试获取同步状态。
-
-  AQS主要提供了如下一些方法：
-
-  `getState`()：返回同步状态的当前值；
-  `setState`(int newState)：设置当前同步状态；
-  `compareAndSetState`(int expect, int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性；
-  `tryAcquire`(int arg)：独占式获取同步状态，获取同步状态成功后，其他线程需要等待该线程释放同步状态才能获取同步状态；
-  `tryRelease`(int arg)：独占式释放同步状态；
-  `tryAcquireShared`(int arg)：共享式获取同步状态，返回值大于等于0则表示获取成功，否则获取失败；
-  `tryReleaseShared`(int arg)：共享式释放同步状态；
-  `isHeldExclusively`()：当前同步器是否在独占式模式下被线程占用，一般该方法表示是否被当前线程所独占；
-  `acquire`(int arg)：独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法将会调用可重写的tryAcquire(int arg)方法；
-  `acquireInterruptibly`(int arg)：与acquire(int arg)相同，但是该方法响应中断，当前线程为获取到同步状态而进入到同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException异常并返回；
-  `tryAcquireNanos`(int arg,long nanos)：超时获取同步状态，如果当前线程在nanos时间内没有获取到同步状态，那么将会返回false，已经获取则返回true；
-  `acquireShared`(int arg)：共享式获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式的主要区别是在同一时刻可以有多个线程获取到同步状态；
-  `acquireSharedInterruptibly`(int arg)：共享式获取同步状态，响应中断；
-  `tryAcquireSharedNanos`(int arg, long nanosTimeout)：共享式获取同步状态，增加超时限制；
-  `release`(int arg)：独占式释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒；
-  `releaseShared`(int arg)：共享式释放同步状态；
-  后面LZ将会就CLH队列，同步状态的获取、释放做详细介绍
-
-  参考资料
-  Doug Lea：《Java并发编程实战》
-  方腾飞：《Java并发编程的艺术》
+
+  Java的内置锁一直都是备受争议的，在JDK 1.6之前，synchronized这个重量级锁其性能一直都是较为低下，虽然在1.6后，进行大量的锁优化策略,但是与Lock相比synchronized还是存在一些缺陷的：虽然synchronized提供了便捷性的隐式获取锁释放锁机制（基于JVM机制），但是它却缺少了获取锁与释放锁的可操作性，可中断、超时获取锁，且它为独占式在高并发场景下性能大打折扣。
+
+  在介绍Lock之前，我们需要先熟悉一个非常重要的组件，掌握了该组件JUC包下面很多问题都不在是问题了。该组件就是AQS。
+
+  AQS，**AbstractQueuedSynchronizer**，即 **队列同步器**。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），JUC并发包的作者（Doug Lea）期望它能够成为实现大部分同步需求的基础。**它是JUC并发包中的核心基础组件。**
+
+  **AQS解决了在实现同步器时涉及当的大量细节问题，例如获取同步状态、FIFO同步队列。** 基于AQS来构建同步器可以带来很多好处。它不仅能够极大地减少实现工作，而且也不必处理在多个位置上发生的竞争问题。
+
+
+  在基于AQS构建的同步器中，只能在一个时刻发生阻塞，从而降低上下文切换的开销，提高了吞吐量。同时在设计AQS时充分考虑了可伸缩行，因此J.U.C中所有基于AQS构建的同步器均可以获得这个优势。
+
+  **采用了模板方法模式，AQS实现大量通用方法，AQS的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态。**
+
+  AQS使用一个int类型的成员变量state来表示同步状态，当state>0时表示已经获取了锁，当state = 0时表示释放了锁。它提供了三个方法（getState()、setState(int newState)、compareAndSetState(int expect,int update)）来对同步状态state进行操作，当然AQS可以确保对state的操作是安全的。
+
+  AQS通过内置的FIFO同步队列来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，则会把节点中的线程唤醒，使其再次尝试获取同步状态。
+
+  AQS主要提供了如下一些方法：
+
+  `getState`()：返回同步状态的当前值；
+  `setState`(int newState)：设置当前同步状态；
+  `compareAndSetState`(int expect, int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性；
+  `tryAcquire`(int arg)：独占式获取同步状态，获取同步状态成功后，其他线程需要等待该线程释放同步状态才能获取同步状态；
+  `tryRelease`(int arg)：独占式释放同步状态；
+  `tryAcquireShared`(int arg)：共享式获取同步状态，返回值大于等于0则表示获取成功，否则获取失败；
+  `tryReleaseShared`(int arg)：共享式释放同步状态；
+  `isHeldExclusively`()：当前同步器是否在独占式模式下被线程占用，一般该方法表示是否被当前线程所独占；
+  `acquire`(int arg)：独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法将会调用可重写的tryAcquire(int arg)方法；
+  `acquireInterruptibly`(int arg)：与acquire(int arg)相同，但是该方法响应中断，当前线程为获取到同步状态而进入到同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException异常并返回；
+  `tryAcquireNanos`(int arg,long nanos)：超时获取同步状态，如果当前线程在nanos时间内没有获取到同步状态，那么将会返回false，已经获取则返回true；
+  `acquireShared`(int arg)：共享式获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式的主要区别是在同一时刻可以有多个线程获取到同步状态；
+  `acquireSharedInterruptibly`(int arg)：共享式获取同步状态，响应中断；
+  `tryAcquireSharedNanos`(int arg, long nanosTimeout)：共享式获取同步状态，增加超时限制；
+  `release`(int arg)：独占式释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒；
+  `releaseShared`(int arg)：共享式释放同步状态；
+  后面LZ将会就CLH队列，同步状态的获取、释放做详细介绍
+
+  参考资料
+  Doug Lea：《Java并发编程实战》
+  方腾飞：《Java并发编程的艺术》
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/09 - J.U.C\344\271\213AQS\357\274\232CLH\345\220\214\346\255\245\351\230\237\345\210\227.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/09 - J.U.C\344\271\213AQS\357\274\232CLH\345\220\214\346\255\245\351\230\237\345\210\227.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/09 - J.U.C\344\271\213AQS\357\274\232CLH\345\220\214\346\255\245\351\230\237\345\210\227.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/09 - J.U.C\344\271\213AQS\357\274\232CLH\345\220\214\346\255\245\351\230\237\345\210\227.md"
index 67acde49..5d858fc4 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/09 - J.U.C\344\271\213AQS\357\274\232CLH\345\220\214\346\255\245\351\230\237\345\210\227.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/09 - J.U.C\344\271\213AQS\357\274\232CLH\345\220\214\346\255\245\351\230\237\345\210\227.md"	
@@ -1,175 +1,175 @@
-
-  AQS内部维护着一个FIFO队列，该队列就是 **CLH同步队列**。
-
-  CLH同步队列是一个 **FIFO双向队列**，AQS依赖它来完成 **同步状态的管理**，当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把 **首节点唤醒（公平锁），使其再次尝试获取同步状态**。
-
-  在CLH同步队列中，`一个节点表示一个线程`，它保存着线程的引用（thread）、状态（waitStatus）、前驱节点（prev）、后继节点（next），其定义如下：
-  ```java
-  static final class Node {
-      /** 共享 */
-      static final Node SHARED = new Node();
-
-      /** 独占 */
-      static final Node EXCLUSIVE = null;
-
-      /**
-       * 因为超时或者中断，节点会被设置为取消状态，被取消的节点时不会参与到竞争中的，他会一直保持取消状态不会转变为其他状态；
-       */
-      static final int CANCELLED =  1;
-
-      /**
-       * 后继节点的线程处于等待状态，而当前节点的线程如果释放了同步状态或者被取消，将会通知后继节点，使后继节点的线程得以运行
-       */
-      static final int SIGNAL    = -1;
-
-      /**
-       * 节点在等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了signal()后，改节点将会从等待队列中转移到同步队列中，加入到同步状态的获取中
-       */
-      static final int CONDITION = -2;
-
-      /**
-       * 表示下一次共享式同步状态获取将会无条件地传播下去
-       */
-      static final int PROPAGATE = -3;
-
-      /** 等待状态 */
-      volatile int waitStatus;
-
-      /** 前驱节点 */
-      volatile Node prev;
-
-      /** 后继节点 */
-      volatile Node next;
-
-      /** 获取同步状态的线程 */
-      volatile Thread thread;
-
-      Node nextWaiter;
-
-      final boolean isShared() {
-          return nextWaiter == SHARED;
-      }
-
-      final Node predecessor() throws NullPointerException {
-          Node p = prev;
-          if (p == null)
-              throw new NullPointerException();
-          else
-              return p;
-      }
-
-      Node() {
-      }
-
-      Node(Thread thread, Node mode) {
-          this.nextWaiter = mode;
-          this.thread = thread;
-      }
-
-      Node(Thread thread, int waitStatus) {
-          this.waitStatus = waitStatus;
-          this.thread = thread;
-      }
-  }
-  ```
-  CLH同步队列结构图如下：
-  <img src="img/201701240001_thumb-1.png">
-
-### 入列
-
-  学了数据结构的我们，CLH队列入列是再简单不过了，无非就是tail指向新节点、新节点的prev指向当前最后的节点，当前最后一个节点的next指向当前节点。代码我们可以看看addWaiter(Node node)方法：
-  ```java
-  private Node addWaiter(Node mode) {
-      //新建Node
-      Node node = new Node(Thread.currentThread(), mode);
-      //快速尝试添加尾节点
-      Node pred = tail;
-      if (pred != null) {
-          node.prev = pred;
-          //CAS设置尾节点
-          if (compareAndSetTail(pred, node)) {
-              pred.next = node;
-              return node;
-          }
-      }
-      //多次尝试
-      enq(node);
-      return node;
-  }
-  ```
-  addWaiter(Node node)先通过快速尝试设置尾节点，如果失败，则调用enq(Node node)方法设置尾节点
-  ``` java
-  private Node enq(final Node node) {
-      //多次尝试，直到成功为止
-      for (;;) {
-          Node t = tail;
-          //tail不存在，设置为首节点
-          if (t == null) {
-              if (compareAndSetHead(new Node()))
-                  tail = head;
-          } else {
-              //设置为尾节点
-              node.prev = t;
-              if (compareAndSetTail(t, node)) {
-                  t.next = node;
-                  return t;
-              }
-          }
-      }
-  }
-  ```
-  在上面代码中，两个方法都是通过一个CAS方法compareAndSetTail(Node expect, Node update)来设置尾节点，该方法可以确保节点是线程安全添加的。在enq(Node node)方法中，AQS通过“死循环”的方式来保证节点可以正确添加，只有成功添加后，当前线程才会从该方法返回，否则会一直执行下去。
-
-  过程图如下：
-  <img src="img/1485225206860201701240002_thumb">
-
-### 入列
-  学了数据结构的我们，CLH队列入列是再简单不过了，无非就是tail指向新节点、新节点的prev指向当前最后的节点，当前最后一个节点的next指向当前节点。代码我们可以看看addWaiter(Node node)方法：
-  ```java
-      private Node addWaiter(Node mode) {
-          //新建Node
-          Node node = new Node(Thread.currentThread(), mode);
-          //快速尝试添加尾节点
-          Node pred = tail;
-          if (pred != null) {
-              node.prev = pred;
-              //CAS设置尾节点
-              if (compareAndSetTail(pred, node)) {
-                  pred.next = node;
-                  return node;
-              }
-          }
-          //多次尝试
-          enq(node);
-          return node;
-      }
-  ```
-  addWaiter(Node node)先通过快速尝试设置尾节点，如果失败，则调用enq(Node node)方法设置尾节点
-  ```java
-  private Node enq(final Node node) {
-      //多次尝试，直到成功为止
-      for (;;) {
-          Node t = tail;
-          //tail不存在，设置为首节点
-          if (t == null) {
-              if (compareAndSetHead(new Node()))
-                  tail = head;
-          } else {
-              //设置为尾节点
-              node.prev = t;
-              if (compareAndSetTail(t, node)) {
-                  t.next = node;
-                  return t;
-              }
-          }
-      }
-  }
-  ```
-  在上面代码中，两个方法都是通过一个CAS方法compareAndSetTail(Node expect, Node update)来设置尾节点，该方法可以确保节点是线程安全添加的。在enq(Node node)方法中，AQS通过“死循环”的方式来保证节点可以正确添加，只有成功添加后，当前线程才会从该方法返回，否则会一直执行下去。
-
-  过程图如下：
-  <img src="201701240003_thumb.png">
-
-### 参考资料
-  Doug Lea：《Java并发编程实战》
-  方腾飞：《Java并发编程的艺术》
+
+  AQS内部维护着一个FIFO队列，该队列就是 **CLH同步队列**。
+
+  CLH同步队列是一个 **FIFO双向队列**，AQS依赖它来完成 **同步状态的管理**，当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把 **首节点唤醒（公平锁），使其再次尝试获取同步状态**。
+
+  在CLH同步队列中，`一个节点表示一个线程`，它保存着线程的引用（thread）、状态（waitStatus）、前驱节点（prev）、后继节点（next），其定义如下：
+  ```java
+  static final class Node {
+      /** 共享 */
+      static final Node SHARED = new Node();
+
+      /** 独占 */
+      static final Node EXCLUSIVE = null;
+
+      /**
+       * 因为超时或者中断，节点会被设置为取消状态，被取消的节点时不会参与到竞争中的，他会一直保持取消状态不会转变为其他状态；
+       */
+      static final int CANCELLED =  1;
+
+      /**
+       * 后继节点的线程处于等待状态，而当前节点的线程如果释放了同步状态或者被取消，将会通知后继节点，使后继节点的线程得以运行
+       */
+      static final int SIGNAL    = -1;
+
+      /**
+       * 节点在等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了signal()后，改节点将会从等待队列中转移到同步队列中，加入到同步状态的获取中
+       */
+      static final int CONDITION = -2;
+
+      /**
+       * 表示下一次共享式同步状态获取将会无条件地传播下去
+       */
+      static final int PROPAGATE = -3;
+
+      /** 等待状态 */
+      volatile int waitStatus;
+
+      /** 前驱节点 */
+      volatile Node prev;
+
+      /** 后继节点 */
+      volatile Node next;
+
+      /** 获取同步状态的线程 */
+      volatile Thread thread;
+
+      Node nextWaiter;
+
+      final boolean isShared() {
+          return nextWaiter == SHARED;
+      }
+
+      final Node predecessor() throws NullPointerException {
+          Node p = prev;
+          if (p == null)
+              throw new NullPointerException();
+          else
+              return p;
+      }
+
+      Node() {
+      }
+
+      Node(Thread thread, Node mode) {
+          this.nextWaiter = mode;
+          this.thread = thread;
+      }
+
+      Node(Thread thread, int waitStatus) {
+          this.waitStatus = waitStatus;
+          this.thread = thread;
+      }
+  }
+  ```
+  CLH同步队列结构图如下：
+  <img src="img/201701240001_thumb-1.png">
+
+### 入列
+
+  学了数据结构的我们，CLH队列入列是再简单不过了，无非就是tail指向新节点、新节点的prev指向当前最后的节点，当前最后一个节点的next指向当前节点。代码我们可以看看addWaiter(Node node)方法：
+  ```java
+  private Node addWaiter(Node mode) {
+      //新建Node
+      Node node = new Node(Thread.currentThread(), mode);
+      //快速尝试添加尾节点
+      Node pred = tail;
+      if (pred != null) {
+          node.prev = pred;
+          //CAS设置尾节点
+          if (compareAndSetTail(pred, node)) {
+              pred.next = node;
+              return node;
+          }
+      }
+      //多次尝试
+      enq(node);
+      return node;
+  }
+  ```
+  addWaiter(Node node)先通过快速尝试设置尾节点，如果失败，则调用enq(Node node)方法设置尾节点
+  ``` java
+  private Node enq(final Node node) {
+      //多次尝试，直到成功为止
+      for (;;) {
+          Node t = tail;
+          //tail不存在，设置为首节点
+          if (t == null) {
+              if (compareAndSetHead(new Node()))
+                  tail = head;
+          } else {
+              //设置为尾节点
+              node.prev = t;
+              if (compareAndSetTail(t, node)) {
+                  t.next = node;
+                  return t;
+              }
+          }
+      }
+  }
+  ```
+  在上面代码中，两个方法都是通过一个CAS方法compareAndSetTail(Node expect, Node update)来设置尾节点，该方法可以确保节点是线程安全添加的。在enq(Node node)方法中，AQS通过“死循环”的方式来保证节点可以正确添加，只有成功添加后，当前线程才会从该方法返回，否则会一直执行下去。
+
+  过程图如下：
+  <img src="img/1485225206860201701240002_thumb">
+
+### 入列
+  学了数据结构的我们，CLH队列入列是再简单不过了，无非就是tail指向新节点、新节点的prev指向当前最后的节点，当前最后一个节点的next指向当前节点。代码我们可以看看addWaiter(Node node)方法：
+  ```java
+      private Node addWaiter(Node mode) {
+          //新建Node
+          Node node = new Node(Thread.currentThread(), mode);
+          //快速尝试添加尾节点
+          Node pred = tail;
+          if (pred != null) {
+              node.prev = pred;
+              //CAS设置尾节点
+              if (compareAndSetTail(pred, node)) {
+                  pred.next = node;
+                  return node;
+              }
+          }
+          //多次尝试
+          enq(node);
+          return node;
+      }
+  ```
+  addWaiter(Node node)先通过快速尝试设置尾节点，如果失败，则调用enq(Node node)方法设置尾节点
+  ```java
+  private Node enq(final Node node) {
+      //多次尝试，直到成功为止
+      for (;;) {
+          Node t = tail;
+          //tail不存在，设置为首节点
+          if (t == null) {
+              if (compareAndSetHead(new Node()))
+                  tail = head;
+          } else {
+              //设置为尾节点
+              node.prev = t;
+              if (compareAndSetTail(t, node)) {
+                  t.next = node;
+                  return t;
+              }
+          }
+      }
+  }
+  ```
+  在上面代码中，两个方法都是通过一个CAS方法compareAndSetTail(Node expect, Node update)来设置尾节点，该方法可以确保节点是线程安全添加的。在enq(Node node)方法中，AQS通过“死循环”的方式来保证节点可以正确添加，只有成功添加后，当前线程才会从该方法返回，否则会一直执行下去。
+
+  过程图如下：
+  <img src="201701240003_thumb.png">
+
+### 参考资料
+  Doug Lea：《Java并发编程实战》
+  方腾飞：《Java并发编程的艺术》
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/10 - J.U.C\344\271\213AQS\357\274\232\345\220\214\346\255\245\347\212\266\346\200\201\347\232\204\350\216\267\345\217\226\344\270\216\351\207\212\346\224\276.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/10 - J.U.C\344\271\213AQS\357\274\232\345\220\214\346\255\245\347\212\266\346\200\201\347\232\204\350\216\267\345\217\226\344\270\216\351\207\212\346\224\276.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/10 - J.U.C\344\271\213AQS\357\274\232\345\220\214\346\255\245\347\212\266\346\200\201\347\232\204\350\216\267\345\217\226\344\270\216\351\207\212\346\224\276.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/10 - J.U.C\344\271\213AQS\357\274\232\345\220\214\346\255\245\347\212\266\346\200\201\347\232\204\350\216\267\345\217\226\344\270\216\351\207\212\346\224\276.md"
index 50a4616b..c5214b7d 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/10 - J.U.C\344\271\213AQS\357\274\232\345\220\214\346\255\245\347\212\266\346\200\201\347\232\204\350\216\267\345\217\226\344\270\216\351\207\212\346\224\276.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/10 - J.U.C\344\271\213AQS\357\274\232\345\220\214\346\255\245\347\212\266\346\200\201\347\232\204\350\216\267\345\217\226\344\270\216\351\207\212\346\224\276.md"	
@@ -1,257 +1,257 @@
-  在前面提到过，AQS是构建Java同步组件的基础，我们期待它能够成为实现大部分同步需求的基础。
-  AQS的设计模式采用的 **模板方法模式**，子类通过继承的方式，实现它的抽象方法来管理同步状态，对于子类而言它并没有太多的活要做，AQS提供了大量的模板方法来实现同步，主要是分为三类：
-
-  **独占式** 获取和释放同步状态、
-  **共享式** 获取和释放同步状态、
-
-  **查询** 同步队列中的等待线程情况。
-
-  自定义子类使用AQS提供的模板方法就可以实现自己的同步语义。
-
-### 独占式
-
-  独占式，同一时刻仅有一个线程持有同步状态。
-
-#### 独占式同步状态获取
-
-  `acquire(int arg)`方法为AQS提供的模板方法，该方法为独占式获取同步状态，但是该方法对中断不敏感，也就是说由于线程获取同步状态失败加入到CLH同步队列中，后续对线程进行中断操作时，线程不会从同步队列中移除。代码如下：
-  ```java
-  public final void acquire(int arg) {
-      if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
-          selfInterrupt();
-  }
-  ```
-  各个方法定义如下：
-
-  1. `tryAcquire`：去尝试获取锁，获取成功则设置锁状态并返回true，否则返回false。该方法自定义同步组件自己实现，该方法必须要保证线程安全的获取同步状态。
-  2. `addWaiter`：如果tryAcquire返回FALSE（获取同步状态失败），则调用该方法将当前线程加入到CLH同步队列尾部。
-  3. `acquireQueued`：当前线程会根据公平性原则来进行阻塞等待（自旋）,直到获取锁为止；并且返回当前线程在等待过程中有没有中断过。
-  4. `selfInterrupt`：产生一个中断。
-
-
-  `acquireQueued`方法为一个自旋的过程，也就是说当前线程（Node）进入同步队列后，就会进入一个自旋的过程，每个节点都会自省地观察，当条件满足，获取到同步状态后，就可以从这个自旋过程中退出，否则会一直执行下去。如下：
-  ```java
-  final boolean acquireQueued(final Node node, int arg) {
-      boolean failed = true;
-      try {
-          //中断标志
-          boolean interrupted = false;
-          /*
-           * 自旋过程，其实就是一个死循环而已
-           */
-          for (;;) {
-              //当前线程的前驱节点
-              final Node p = node.predecessor();
-              //当前线程的前驱节点是头结点，且同步状态成功
-              if (p == head && tryAcquire(arg)) {
-                  setHead(node);
-                  p.next = null; // help GC
-                  failed = false;
-                  return interrupted;
-              }
-              //获取失败，线程等待--具体后面介绍
-              if (shouldParkAfterFailedAcquire(p, node) &&
-                      parkAndCheckInterrupt())
-                  interrupted = true;
-          }
-      } finally {
-          if (failed)
-              cancelAcquire(node);
-      }
-  }
-  ```
-  从上面代码中可以看到，当前线程会一直尝试获取同步状态，当然前提是只有其前驱节点为头结点才能够尝试获取同步状态，理由：
-
-  保持FIFO同步队列原则。
-  头节点释放同步状态后，将会唤醒其后继节点，后继节点被唤醒后需要检查自己是否为头节点。
-  acquire(int arg)方法流程图如下：
-  <img src="img/201701260001_thumb.png">
-
-### 独占式获取 **响应中断**
-
-  AQS提供了acquire(int arg)方法以供独占式获取同步状态，但是该方法对中断不响应，对线程进行中断操作后，该线程会依然位于CLH同步队列中等待着获取同步状态。为了响应中断，AQS提供了 **acquireInterruptibly(int arg)方法**，该方法在等待获取同步状态时，如果当前线程被中断了，会立刻响应中断抛出异常InterruptedException。
-  ```java
-  public final void acquireInterruptibly(int arg)
-          throws InterruptedException {
-      if (Thread.interrupted())
-          throw new InterruptedException();
-      if (!tryAcquire(arg))
-          doAcquireInterruptibly(arg);
-  }
-  ```
-  首先校验该线程是否已经中断了，如果是则抛出InterruptedException，否则执行tryAcquire(int arg)方法获取同步状态，如果获取成功，则直接返回，否则执行doAcquireInterruptibly(int arg)。doAcquireInterruptibly(int arg)定义如下：
-  ```java
-  private void doAcquireInterruptibly(int arg)
-      throws InterruptedException {
-      final Node node = addWaiter(Node.EXCLUSIVE);
-      boolean failed = true;
-      try {
-          for (;;) {
-              final Node p = node.predecessor();
-              if (p == head && tryAcquire(arg)) {
-                  setHead(node);
-                  p.next = null; // help GC
-                  failed = false;
-                  return;
-              }
-              if (shouldParkAfterFailedAcquire(p, node) &&
-                  parkAndCheckInterrupt())
-                  throw new InterruptedException();
-          }
-      } finally {
-          if (failed)
-              cancelAcquire(node);
-      }
-  }
-  ```
-  doAcquireInterruptibly(int arg)方法与acquire(int arg)方法仅有两个差别。1.方法声明抛出InterruptedException异常，2.在中断方法处不再是使用interrupted标志，而是直接抛出InterruptedException异常。
-
-### 独占式 **超时获取**
-  AQS除了提供上面两个方法外，还提供了一个增强版的方法：**tryAcquireNanos(int arg,long nanos)**。该方法为acquireInterruptibly方法的进一步增强，它除了响应中断外，还有超时控制。即如果当前线程没有在指定时间内获取同步状态，则会返回false，否则返回true。如下：
-  ```java
-  public final boolean tryAcquireNanos(int arg, long nanosTimeout)
-          throws InterruptedException {
-      if (Thread.interrupted())
-          throw new InterruptedException();
-      return tryAcquire(arg) ||
-          doAcquireNanos(arg, nanosTimeout);
-  }
-  ```
-  tryAcquireNanos(int arg, long nanosTimeout)方法超时获取最终是在doAcquireNanos(int arg, long nanosTimeout)中实现的，如下：
-  ```java
-  private boolean doAcquireNanos(int arg, long nanosTimeout)
-          throws InterruptedException {
-      //nanosTimeout <= 0
-      if (nanosTimeout <= 0L)
-          return false;
-      //超时时间
-      final long deadline = System.nanoTime() + nanosTimeout;
-      //新增Node节点
-      final Node node = addWaiter(Node.EXCLUSIVE);
-      boolean failed = true;
-      try {
-          //自旋
-          for (;;) {
-              final Node p = node.predecessor();
-              //获取同步状态成功
-              if (p == head && tryAcquire(arg)) {
-                  setHead(node);
-                  p.next = null; // help GC
-                  failed = false;
-                  return true;
-              }
-              /*
-               * 获取失败，做超时、中断判断
-               */
-              //重新计算需要休眠的时间
-              nanosTimeout = deadline - System.nanoTime();
-              //已经超时，返回false
-              if (nanosTimeout <= 0L)
-                  return false;
-              //如果没有超时，则等待nanosTimeout纳秒
-              //注：该线程会直接从LockSupport.parkNanos中返回，
-              //LockSupport为JUC提供的一个阻塞和唤醒的工具类，后面做详细介绍
-              if (shouldParkAfterFailedAcquire(p, node) &&
-                      nanosTimeout > spinForTimeoutThreshold)
-                  LockSupport.parkNanos(this, nanosTimeout);
-              //线程是否已经中断了
-              if (Thread.interrupted())
-                  throw new InterruptedException();
-          }
-      } finally {
-          if (failed)
-              cancelAcquire(node);
-      }
-  }
-  ```
-  针对超时控制，程序首先记录唤醒时间deadline ，deadline = System.nanoTime() + nanosTimeout（时间间隔）。如果获取同步状态失败，则需要计算出需要休眠的时间间隔nanosTimeout（= deadline - System.nanoTime()），如果nanosTimeout <= 0 表示已经超时了，返回false，如果大于spinForTimeoutThreshold（1000L）则需要休眠nanosTimeout ，如果nanosTimeout <= spinForTimeoutThreshold ，就不需要休眠了，直接进入快速自旋的过程。原因在于 spinForTimeoutThreshold 已经非常小了，非常短的时间等待无法做到十分精确，如果这时再次进行超时等待，相反会让nanosTimeout 的超时从整体上面表现得不是那么精确，所以在超时非常短的场景中，AQS会进行无条件的快速自旋。
-
-  整个流程如下：
-  <img src="img/201701270001_thumb.png">
-
-### 独占式同步状态释放
-
-  当线程获取同步状态后，执行完相应逻辑后就需要释放同步状态。AQS提供了 **release(int arg)** 方法释放同步状态：
-  ```java
-  public final boolean release(int arg) {
-      if (tryRelease(arg)) {
-          Node h = head;
-          if (h != null && h.waitStatus != 0)
-              unparkSuccessor(h);
-          return true;
-      }
-      return false;
-  }
-  ```
-  该方法同样是先调用自定义同步器自定义的tryRelease(int arg)方法来释放同步状态，释放成功后，会调用unparkSuccessor(Node node)方法唤醒后继节点（如何唤醒LZ后面介绍）。
-
-  这里稍微总结下：
-
-  在AQS中维护着一个FIFO的同步队列，当线程获取同步状态失败后，则会加入到这个CLH同步队列的对尾并一直保持着自旋。在CLH同步队列中的线程在自旋时会判断其前驱节点是否为首节点，如果为首节点则不断尝试获取同步状态，获取成功则退出CLH同步队列。当线程执行完逻辑后，会释放同步状态，释放后会唤醒其后继节点。
-
-### 共享式
-共享式与独占式的最主要区别在于同一时刻独占式只能有一个线程获取同步状态，而共享式在同一时刻可以有多个线程获取同步状态。例如读操作可以有多个线程同时进行，而写操作同一时刻只能有一个线程进行写操作，其他操作都会被阻塞。
-
-### 共享式同步状态获取
-AQS提供 **acquireShared(int arg)方法** 共享式获取同步状态：
-  ```java
-  public final void acquireShared(int arg) {
-      if (tryAcquireShared(arg) < 0)
-		//获取失败，自旋获取同步状态
-          doAcquireShared(arg);
-  }
-  ```
-  从上面程序可以看出，方法首先是调用tryAcquireShared(int arg)方法尝试获取同步状态，如果获取失败则调用doAcquireShared(int arg)自旋方式获取同步状态，共享式获取同步状态的标志是返回 >= 0 的值表示获取成功。自选式获取同步状态如下：
-  ``` java
-  private void doAcquireShared(int arg) {
-      /共享式节点
-      final Node node = addWaiter(Node.SHARED);
-      boolean failed = true;
-      try {
-          boolean interrupted = false;
-          for (;;) {
-              //前驱节点
-              final Node p = node.predecessor();
-              //如果其前驱节点，获取同步状态
-              if (p == head) {
-                  //尝试获取同步
-                  int r = tryAcquireShared(arg);
-                  if (r >= 0) {
-                      setHeadAndPropagate(node, r);
-                      p.next = null; // help GC
-                      if (interrupted)
-                          selfInterrupt();
-                      failed = false;
-                      return;
-                  }
-              }
-              if (shouldParkAfterFailedAcquire(p, node) &&
-                      parkAndCheckInterrupt())
-                  interrupted = true;
-          }
-      } finally {
-          if (failed)
-              cancelAcquire(node);
-      }
-  }
-  ```
-  tryAcquireShared(int arg)方法尝试获取同步状态，返回值为int，当其 >= 0 时，表示能够获取到同步状态，这个时候就可以从自旋过程中退出。
-
-  acquireShared(int arg)方法不响应中断，与独占式相似，AQS也提供了响应中断、超时的方法，分别是：acquireSharedInterruptibly(int arg)、tryAcquireSharedNanos(int arg,long nanos)，这里就不做解释了。
-
-### 共享式同步状态释放
-  获取同步状态后，需要调用 **releaseShared(int arg)** 方法释放同步状态，方法如下：
-  ```java
-  public final boolean releaseShared(int arg) {
-      if (tryReleaseShared(arg)) {
-          doReleaseShared();
-          return true;
-      }
-      return false;
-  }
-  ```
-  因为可能会存在多个线程同时进行释放同步状态资源，所以需要确保同步状态安全地成功释放，一般都是通过CAS和循环来完成的。
-
-### 参考资料
-Doug Lea：《Java并发编程实战》
-方腾飞：《Java并发编程的艺术》
+  在前面提到过，AQS是构建Java同步组件的基础，我们期待它能够成为实现大部分同步需求的基础。
+  AQS的设计模式采用的 **模板方法模式**，子类通过继承的方式，实现它的抽象方法来管理同步状态，对于子类而言它并没有太多的活要做，AQS提供了大量的模板方法来实现同步，主要是分为三类：
+
+  **独占式** 获取和释放同步状态、
+  **共享式** 获取和释放同步状态、
+
+  **查询** 同步队列中的等待线程情况。
+
+  自定义子类使用AQS提供的模板方法就可以实现自己的同步语义。
+
+### 独占式
+
+  独占式，同一时刻仅有一个线程持有同步状态。
+
+#### 独占式同步状态获取
+
+  `acquire(int arg)`方法为AQS提供的模板方法，该方法为独占式获取同步状态，但是该方法对中断不敏感，也就是说由于线程获取同步状态失败加入到CLH同步队列中，后续对线程进行中断操作时，线程不会从同步队列中移除。代码如下：
+  ```java
+  public final void acquire(int arg) {
+      if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
+          selfInterrupt();
+  }
+  ```
+  各个方法定义如下：
+
+  1. `tryAcquire`：去尝试获取锁，获取成功则设置锁状态并返回true，否则返回false。该方法自定义同步组件自己实现，该方法必须要保证线程安全的获取同步状态。
+  2. `addWaiter`：如果tryAcquire返回FALSE（获取同步状态失败），则调用该方法将当前线程加入到CLH同步队列尾部。
+  3. `acquireQueued`：当前线程会根据公平性原则来进行阻塞等待（自旋）,直到获取锁为止；并且返回当前线程在等待过程中有没有中断过。
+  4. `selfInterrupt`：产生一个中断。
+
+
+  `acquireQueued`方法为一个自旋的过程，也就是说当前线程（Node）进入同步队列后，就会进入一个自旋的过程，每个节点都会自省地观察，当条件满足，获取到同步状态后，就可以从这个自旋过程中退出，否则会一直执行下去。如下：
+  ```java
+  final boolean acquireQueued(final Node node, int arg) {
+      boolean failed = true;
+      try {
+          //中断标志
+          boolean interrupted = false;
+          /*
+           * 自旋过程，其实就是一个死循环而已
+           */
+          for (;;) {
+              //当前线程的前驱节点
+              final Node p = node.predecessor();
+              //当前线程的前驱节点是头结点，且同步状态成功
+              if (p == head && tryAcquire(arg)) {
+                  setHead(node);
+                  p.next = null; // help GC
+                  failed = false;
+                  return interrupted;
+              }
+              //获取失败，线程等待--具体后面介绍
+              if (shouldParkAfterFailedAcquire(p, node) &&
+                      parkAndCheckInterrupt())
+                  interrupted = true;
+          }
+      } finally {
+          if (failed)
+              cancelAcquire(node);
+      }
+  }
+  ```
+  从上面代码中可以看到，当前线程会一直尝试获取同步状态，当然前提是只有其前驱节点为头结点才能够尝试获取同步状态，理由：
+
+  保持FIFO同步队列原则。
+  头节点释放同步状态后，将会唤醒其后继节点，后继节点被唤醒后需要检查自己是否为头节点。
+  acquire(int arg)方法流程图如下：
+  <img src="img/201701260001_thumb.png">
+
+### 独占式获取 **响应中断**
+
+  AQS提供了acquire(int arg)方法以供独占式获取同步状态，但是该方法对中断不响应，对线程进行中断操作后，该线程会依然位于CLH同步队列中等待着获取同步状态。为了响应中断，AQS提供了 **acquireInterruptibly(int arg)方法**，该方法在等待获取同步状态时，如果当前线程被中断了，会立刻响应中断抛出异常InterruptedException。
+  ```java
+  public final void acquireInterruptibly(int arg)
+          throws InterruptedException {
+      if (Thread.interrupted())
+          throw new InterruptedException();
+      if (!tryAcquire(arg))
+          doAcquireInterruptibly(arg);
+  }
+  ```
+  首先校验该线程是否已经中断了，如果是则抛出InterruptedException，否则执行tryAcquire(int arg)方法获取同步状态，如果获取成功，则直接返回，否则执行doAcquireInterruptibly(int arg)。doAcquireInterruptibly(int arg)定义如下：
+  ```java
+  private void doAcquireInterruptibly(int arg)
+      throws InterruptedException {
+      final Node node = addWaiter(Node.EXCLUSIVE);
+      boolean failed = true;
+      try {
+          for (;;) {
+              final Node p = node.predecessor();
+              if (p == head && tryAcquire(arg)) {
+                  setHead(node);
+                  p.next = null; // help GC
+                  failed = false;
+                  return;
+              }
+              if (shouldParkAfterFailedAcquire(p, node) &&
+                  parkAndCheckInterrupt())
+                  throw new InterruptedException();
+          }
+      } finally {
+          if (failed)
+              cancelAcquire(node);
+      }
+  }
+  ```
+  doAcquireInterruptibly(int arg)方法与acquire(int arg)方法仅有两个差别。1.方法声明抛出InterruptedException异常，2.在中断方法处不再是使用interrupted标志，而是直接抛出InterruptedException异常。
+
+### 独占式 **超时获取**
+  AQS除了提供上面两个方法外，还提供了一个增强版的方法：**tryAcquireNanos(int arg,long nanos)**。该方法为acquireInterruptibly方法的进一步增强，它除了响应中断外，还有超时控制。即如果当前线程没有在指定时间内获取同步状态，则会返回false，否则返回true。如下：
+  ```java
+  public final boolean tryAcquireNanos(int arg, long nanosTimeout)
+          throws InterruptedException {
+      if (Thread.interrupted())
+          throw new InterruptedException();
+      return tryAcquire(arg) ||
+          doAcquireNanos(arg, nanosTimeout);
+  }
+  ```
+  tryAcquireNanos(int arg, long nanosTimeout)方法超时获取最终是在doAcquireNanos(int arg, long nanosTimeout)中实现的，如下：
+  ```java
+  private boolean doAcquireNanos(int arg, long nanosTimeout)
+          throws InterruptedException {
+      //nanosTimeout <= 0
+      if (nanosTimeout <= 0L)
+          return false;
+      //超时时间
+      final long deadline = System.nanoTime() + nanosTimeout;
+      //新增Node节点
+      final Node node = addWaiter(Node.EXCLUSIVE);
+      boolean failed = true;
+      try {
+          //自旋
+          for (;;) {
+              final Node p = node.predecessor();
+              //获取同步状态成功
+              if (p == head && tryAcquire(arg)) {
+                  setHead(node);
+                  p.next = null; // help GC
+                  failed = false;
+                  return true;
+              }
+              /*
+               * 获取失败，做超时、中断判断
+               */
+              //重新计算需要休眠的时间
+              nanosTimeout = deadline - System.nanoTime();
+              //已经超时，返回false
+              if (nanosTimeout <= 0L)
+                  return false;
+              //如果没有超时，则等待nanosTimeout纳秒
+              //注：该线程会直接从LockSupport.parkNanos中返回，
+              //LockSupport为JUC提供的一个阻塞和唤醒的工具类，后面做详细介绍
+              if (shouldParkAfterFailedAcquire(p, node) &&
+                      nanosTimeout > spinForTimeoutThreshold)
+                  LockSupport.parkNanos(this, nanosTimeout);
+              //线程是否已经中断了
+              if (Thread.interrupted())
+                  throw new InterruptedException();
+          }
+      } finally {
+          if (failed)
+              cancelAcquire(node);
+      }
+  }
+  ```
+  针对超时控制，程序首先记录唤醒时间deadline ，deadline = System.nanoTime() + nanosTimeout（时间间隔）。如果获取同步状态失败，则需要计算出需要休眠的时间间隔nanosTimeout（= deadline - System.nanoTime()），如果nanosTimeout <= 0 表示已经超时了，返回false，如果大于spinForTimeoutThreshold（1000L）则需要休眠nanosTimeout ，如果nanosTimeout <= spinForTimeoutThreshold ，就不需要休眠了，直接进入快速自旋的过程。原因在于 spinForTimeoutThreshold 已经非常小了，非常短的时间等待无法做到十分精确，如果这时再次进行超时等待，相反会让nanosTimeout 的超时从整体上面表现得不是那么精确，所以在超时非常短的场景中，AQS会进行无条件的快速自旋。
+
+  整个流程如下：
+  <img src="img/201701270001_thumb.png">
+
+### 独占式同步状态释放
+
+  当线程获取同步状态后，执行完相应逻辑后就需要释放同步状态。AQS提供了 **release(int arg)** 方法释放同步状态：
+  ```java
+  public final boolean release(int arg) {
+      if (tryRelease(arg)) {
+          Node h = head;
+          if (h != null && h.waitStatus != 0)
+              unparkSuccessor(h);
+          return true;
+      }
+      return false;
+  }
+  ```
+  该方法同样是先调用自定义同步器自定义的tryRelease(int arg)方法来释放同步状态，释放成功后，会调用unparkSuccessor(Node node)方法唤醒后继节点（如何唤醒LZ后面介绍）。
+
+  这里稍微总结下：
+
+  在AQS中维护着一个FIFO的同步队列，当线程获取同步状态失败后，则会加入到这个CLH同步队列的对尾并一直保持着自旋。在CLH同步队列中的线程在自旋时会判断其前驱节点是否为首节点，如果为首节点则不断尝试获取同步状态，获取成功则退出CLH同步队列。当线程执行完逻辑后，会释放同步状态，释放后会唤醒其后继节点。
+
+### 共享式
+共享式与独占式的最主要区别在于同一时刻独占式只能有一个线程获取同步状态，而共享式在同一时刻可以有多个线程获取同步状态。例如读操作可以有多个线程同时进行，而写操作同一时刻只能有一个线程进行写操作，其他操作都会被阻塞。
+
+### 共享式同步状态获取
+AQS提供 **acquireShared(int arg)方法** 共享式获取同步状态：
+  ```java
+  public final void acquireShared(int arg) {
+      if (tryAcquireShared(arg) < 0)
+		//获取失败，自旋获取同步状态
+          doAcquireShared(arg);
+  }
+  ```
+  从上面程序可以看出，方法首先是调用tryAcquireShared(int arg)方法尝试获取同步状态，如果获取失败则调用doAcquireShared(int arg)自旋方式获取同步状态，共享式获取同步状态的标志是返回 >= 0 的值表示获取成功。自选式获取同步状态如下：
+  ``` java
+  private void doAcquireShared(int arg) {
+      /共享式节点
+      final Node node = addWaiter(Node.SHARED);
+      boolean failed = true;
+      try {
+          boolean interrupted = false;
+          for (;;) {
+              //前驱节点
+              final Node p = node.predecessor();
+              //如果其前驱节点，获取同步状态
+              if (p == head) {
+                  //尝试获取同步
+                  int r = tryAcquireShared(arg);
+                  if (r >= 0) {
+                      setHeadAndPropagate(node, r);
+                      p.next = null; // help GC
+                      if (interrupted)
+                          selfInterrupt();
+                      failed = false;
+                      return;
+                  }
+              }
+              if (shouldParkAfterFailedAcquire(p, node) &&
+                      parkAndCheckInterrupt())
+                  interrupted = true;
+          }
+      } finally {
+          if (failed)
+              cancelAcquire(node);
+      }
+  }
+  ```
+  tryAcquireShared(int arg)方法尝试获取同步状态，返回值为int，当其 >= 0 时，表示能够获取到同步状态，这个时候就可以从自旋过程中退出。
+
+  acquireShared(int arg)方法不响应中断，与独占式相似，AQS也提供了响应中断、超时的方法，分别是：acquireSharedInterruptibly(int arg)、tryAcquireSharedNanos(int arg,long nanos)，这里就不做解释了。
+
+### 共享式同步状态释放
+  获取同步状态后，需要调用 **releaseShared(int arg)** 方法释放同步状态，方法如下：
+  ```java
+  public final boolean releaseShared(int arg) {
+      if (tryReleaseShared(arg)) {
+          doReleaseShared();
+          return true;
+      }
+      return false;
+  }
+  ```
+  因为可能会存在多个线程同时进行释放同步状态资源，所以需要确保同步状态安全地成功释放，一般都是通过CAS和循环来完成的。
+
+### 参考资料
+Doug Lea：《Java并发编程实战》
+方腾飞：《Java并发编程的艺术》
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/11 - J.U.C\344\271\213AQS\357\274\232\351\230\273\345\241\236\345\222\214\345\224\244\351\206\222\347\272\277\347\250\213.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/11 - J.U.C\344\271\213AQS\357\274\232\351\230\273\345\241\236\345\222\214\345\224\244\351\206\222\347\272\277\347\250\213.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/11 - J.U.C\344\271\213AQS\357\274\232\351\230\273\345\241\236\345\222\214\345\224\244\351\206\222\347\272\277\347\250\213.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/11 - J.U.C\344\271\213AQS\357\274\232\351\230\273\345\241\236\345\222\214\345\224\244\351\206\222\347\272\277\347\250\213.md"
index 8b1176e7..6c6d4f4a 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/11 - J.U.C\344\271\213AQS\357\274\232\351\230\273\345\241\236\345\222\214\345\224\244\351\206\222\347\272\277\347\250\213.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/11 - J.U.C\344\271\213AQS\357\274\232\351\230\273\345\241\236\345\222\214\345\224\244\351\206\222\347\272\277\347\250\213.md"	
@@ -1,123 +1,123 @@
-
-  在线程获取同步状态时如果获取失败，则加入CLH同步队列，通过自旋的方式不断获取同步状态，但是在自旋的过程中则需要判断当前线程是否需要阻塞，其主要方法在acquireQueued()：
-  ```java
-  if (shouldParkAfterFailedAcquire(p, node) &&
-        parkAndCheckInterrupt())
-        interrupted = true;
-  ```
-  通过这段代码我们可以看到，在获取同步状态失败后，线程并不是立马进行阻塞，需要检查该线程的状态，检查状态的方法为 shouldParkAfterFailedAcquire(Node pred, Node node) 方法，该方法主要靠前驱节点判断当前线程是否应该被阻塞，代码如下：
-  ```java
-  private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
-      //前驱节点
-      int ws = pred.waitStatus;
-      //状态为signal，表示当前线程处于等待状态，直接放回true
-      if (ws == Node.SIGNAL)
-          return true;
-      //前驱节点状态 > 0 ，则为Cancelled,表明该节点已经超时或者被中断了，需要从同步队列中取消
-      if (ws > 0) {
-          do {
-              node.prev = pred = pred.prev;
-          } while (pred.waitStatus > 0);
-          pred.next = node;
-      }
-      //前驱节点状态为Condition、propagate
-      else {
-          compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
-      }
-      return false;
-  }
-  ```
-  这段代码主要检查当前线程是否需要被阻塞，具体规则如下：
-
-  1. 如果当前线程的前驱节点状态为SINNAL，则表明当前线程需要被阻塞，调用unpark()方法唤醒，直接返回true，当前线程阻塞
-  2. 如果当前线程的前驱节点状态为CANCELLED（ws > 0），则表明该线程的前驱节点已经等待超时或者被中断了，则需要从CLH队列中将该前驱节点删除掉，直到回溯到前驱节点状态 <= 0 ，返回false
-  3. 如果前驱节点非SINNAL，非CANCELLED，则通过CAS的方式将其前驱节点设置为SINNAL，返回false
-
-
-  如果 shouldParkAfterFailedAcquire(Node pred, Node node) 方法返回true，则调用parkAndCheckInterrupt()方法阻塞当前线程：
-  ```java
-  private final boolean parkAndCheckInterrupt() {
-      LockSupport.park(this);
-      return Thread.interrupted();
-  }
-  ```
-  parkAndCheckInterrupt() 方法主要是把当前线程挂起，从而阻塞住线程的调用栈，同时返回当前线程的中断状态。其内部则是调用LockSupport工具类的park()方法来阻塞该方法。
-
-  当线程释放同步状态后，则需要唤醒该线程的后继节点：
-  ```java
-  public final boolean release(int arg) {
-      if (tryRelease(arg)) {
-          Node h = head;
-          if (h != null && h.waitStatus != 0)
-			//唤醒后继节点
-              unparkSuccessor(h);
-          return true;
-      }
-      return false;
-  }
-  ```
-  调用unparkSuccessor(Node node)唤醒后继节点：
-  ```java
-  private void unparkSuccessor(Node node) {
-      //当前节点状态
-      int ws = node.waitStatus;
-      //当前状态 < 0 则设置为 0
-      if (ws < 0)
-          compareAndSetWaitStatus(node, ws, 0);
-
-      //当前节点的后继节点
-      Node s = node.next;
-      //后继节点为null或者其状态 > 0 (超时或者被中断了)
-      if (s == null || s.waitStatus > 0) {
-          s = null;
-          //从tail节点来找可用节点
-          for (Node t = tail; t != null && t != node; t = t.prev)
-              if (t.waitStatus <= 0)
-                  s = t;
-      }
-      //唤醒后继节点
-      if (s != null)
-          LockSupport.unpark(s.thread);
-  }
-  ```
-  可能会存在当前线程的后继节点为null，超时、被中断的情况，如果遇到这种情况了，则需要跳过该节点，但是为何是从tail尾节点开始，而不是从node.next开始呢？原因在于node.next仍然可能会存在null或者取消了，所以采用tail回溯办法找第一个可用的线程。最后调用LockSupport的unpark(Thread thread)方法唤醒该线程。
-
-### LockSupport
-
-  从上面我可以看到，当需要阻塞或者唤醒一个线程的时候，AQS都是使用LockSupport这个工具类来完成的。
-
-    **LockSupport是用来创建锁和其他同步类的基本线程阻塞原语**
-
-  **每个使用LockSupport的线程都会与一个许可关联，如果该许可可用，并且可在进程中使用，则调用park()将会立即返回，否则可能阻塞。如果许可尚不可用，则可以调用 unpark 使其可用。** 但是注意许可不可重入，也就是说只能调用一次park()方法，否则会一直阻塞。
-
-  LockSupport定义了一系列以park开头的方法来阻塞当前线程，unpark(Thread thread)方法来唤醒一个被阻塞的线程。如下：
-  <img src="img/201701310001_thumb.jpg">
-
-  **park(Object blocker)** 方法的blocker参数，主要是用来标识当前线程在等待的对象，该对象主要用于问题排查和系统监控。
-
-  park方法和 **unpark(Thread thread)** 都是成对出现的，同时unpark必须要在park执行之后执行，当然并不是说没有不调用unpark线程就会一直阻塞，park有一个方法，它带了时间戳（parkNanos(long nanos)：为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用）。
-
-  park()方法的源码如下：
-  ```java
-  public static void park() {
-      UNSAFE.park(false, 0L);
-  }
-  ```
-  unpark(Thread thread)方法源码如下：
-
-  ```java
-  public static void unpark(Thread thread) {
-      if (thread != null)
-          UNSAFE.unpark(thread);
-  }
-  ```
-  从上面可以看出，其内部的实现都是通过UNSAFE（sun.misc.Unsafe UNSAFE）来实现的，其定义如下：
-  ```java
-  public native void park(boolean var1, long var2);
-  public native void unpark(Object var1);
-  ```
-  两个都是native本地方法。Unsafe 是一个比较危险的类，主要是用于执行低级别、不安全的方法集合。尽管这个类和所有的方法都是公开的（public），但是这个类的使用仍然受限，你无法在自己的java程序中直接使用该类，因为只有授信的代码才能获得该类的实例。
-
-### 参考资料
-方腾飞：《Java并发编程的艺术》
-LockSupport的park和unpark的基本使用,以及对线程中断的响应性 https://www.tuicool.com/articles/MveUNzF
+
+  在线程获取同步状态时如果获取失败，则加入CLH同步队列，通过自旋的方式不断获取同步状态，但是在自旋的过程中则需要判断当前线程是否需要阻塞，其主要方法在acquireQueued()：
+  ```java
+  if (shouldParkAfterFailedAcquire(p, node) &&
+        parkAndCheckInterrupt())
+        interrupted = true;
+  ```
+  通过这段代码我们可以看到，在获取同步状态失败后，线程并不是立马进行阻塞，需要检查该线程的状态，检查状态的方法为 shouldParkAfterFailedAcquire(Node pred, Node node) 方法，该方法主要靠前驱节点判断当前线程是否应该被阻塞，代码如下：
+  ```java
+  private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
+      //前驱节点
+      int ws = pred.waitStatus;
+      //状态为signal，表示当前线程处于等待状态，直接放回true
+      if (ws == Node.SIGNAL)
+          return true;
+      //前驱节点状态 > 0 ，则为Cancelled,表明该节点已经超时或者被中断了，需要从同步队列中取消
+      if (ws > 0) {
+          do {
+              node.prev = pred = pred.prev;
+          } while (pred.waitStatus > 0);
+          pred.next = node;
+      }
+      //前驱节点状态为Condition、propagate
+      else {
+          compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
+      }
+      return false;
+  }
+  ```
+  这段代码主要检查当前线程是否需要被阻塞，具体规则如下：
+
+  1. 如果当前线程的前驱节点状态为SINNAL，则表明当前线程需要被阻塞，调用unpark()方法唤醒，直接返回true，当前线程阻塞
+  2. 如果当前线程的前驱节点状态为CANCELLED（ws > 0），则表明该线程的前驱节点已经等待超时或者被中断了，则需要从CLH队列中将该前驱节点删除掉，直到回溯到前驱节点状态 <= 0 ，返回false
+  3. 如果前驱节点非SINNAL，非CANCELLED，则通过CAS的方式将其前驱节点设置为SINNAL，返回false
+
+
+  如果 shouldParkAfterFailedAcquire(Node pred, Node node) 方法返回true，则调用parkAndCheckInterrupt()方法阻塞当前线程：
+  ```java
+  private final boolean parkAndCheckInterrupt() {
+      LockSupport.park(this);
+      return Thread.interrupted();
+  }
+  ```
+  parkAndCheckInterrupt() 方法主要是把当前线程挂起，从而阻塞住线程的调用栈，同时返回当前线程的中断状态。其内部则是调用LockSupport工具类的park()方法来阻塞该方法。
+
+  当线程释放同步状态后，则需要唤醒该线程的后继节点：
+  ```java
+  public final boolean release(int arg) {
+      if (tryRelease(arg)) {
+          Node h = head;
+          if (h != null && h.waitStatus != 0)
+			//唤醒后继节点
+              unparkSuccessor(h);
+          return true;
+      }
+      return false;
+  }
+  ```
+  调用unparkSuccessor(Node node)唤醒后继节点：
+  ```java
+  private void unparkSuccessor(Node node) {
+      //当前节点状态
+      int ws = node.waitStatus;
+      //当前状态 < 0 则设置为 0
+      if (ws < 0)
+          compareAndSetWaitStatus(node, ws, 0);
+
+      //当前节点的后继节点
+      Node s = node.next;
+      //后继节点为null或者其状态 > 0 (超时或者被中断了)
+      if (s == null || s.waitStatus > 0) {
+          s = null;
+          //从tail节点来找可用节点
+          for (Node t = tail; t != null && t != node; t = t.prev)
+              if (t.waitStatus <= 0)
+                  s = t;
+      }
+      //唤醒后继节点
+      if (s != null)
+          LockSupport.unpark(s.thread);
+  }
+  ```
+  可能会存在当前线程的后继节点为null，超时、被中断的情况，如果遇到这种情况了，则需要跳过该节点，但是为何是从tail尾节点开始，而不是从node.next开始呢？原因在于node.next仍然可能会存在null或者取消了，所以采用tail回溯办法找第一个可用的线程。最后调用LockSupport的unpark(Thread thread)方法唤醒该线程。
+
+### LockSupport
+
+  从上面我可以看到，当需要阻塞或者唤醒一个线程的时候，AQS都是使用LockSupport这个工具类来完成的。
+
+    **LockSupport是用来创建锁和其他同步类的基本线程阻塞原语**
+
+  **每个使用LockSupport的线程都会与一个许可关联，如果该许可可用，并且可在进程中使用，则调用park()将会立即返回，否则可能阻塞。如果许可尚不可用，则可以调用 unpark 使其可用。** 但是注意许可不可重入，也就是说只能调用一次park()方法，否则会一直阻塞。
+
+  LockSupport定义了一系列以park开头的方法来阻塞当前线程，unpark(Thread thread)方法来唤醒一个被阻塞的线程。如下：
+  <img src="img/201701310001_thumb.jpg">
+
+  **park(Object blocker)** 方法的blocker参数，主要是用来标识当前线程在等待的对象，该对象主要用于问题排查和系统监控。
+
+  park方法和 **unpark(Thread thread)** 都是成对出现的，同时unpark必须要在park执行之后执行，当然并不是说没有不调用unpark线程就会一直阻塞，park有一个方法，它带了时间戳（parkNanos(long nanos)：为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用）。
+
+  park()方法的源码如下：
+  ```java
+  public static void park() {
+      UNSAFE.park(false, 0L);
+  }
+  ```
+  unpark(Thread thread)方法源码如下：
+
+  ```java
+  public static void unpark(Thread thread) {
+      if (thread != null)
+          UNSAFE.unpark(thread);
+  }
+  ```
+  从上面可以看出，其内部的实现都是通过UNSAFE（sun.misc.Unsafe UNSAFE）来实现的，其定义如下：
+  ```java
+  public native void park(boolean var1, long var2);
+  public native void unpark(Object var1);
+  ```
+  两个都是native本地方法。Unsafe 是一个比较危险的类，主要是用于执行低级别、不安全的方法集合。尽管这个类和所有的方法都是公开的（public），但是这个类的使用仍然受限，你无法在自己的java程序中直接使用该类，因为只有授信的代码才能获得该类的实例。
+
+### 参考资料
+方腾飞：《Java并发编程的艺术》
+LockSupport的park和unpark的基本使用,以及对线程中断的响应性 https://www.tuicool.com/articles/MveUNzF
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/12 - J.U.C\344\271\213\351\207\215\345\205\245\351\224\201\357\274\232ReentrantLock.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/12 - J.U.C\344\271\213\351\207\215\345\205\245\351\224\201\357\274\232ReentrantLock.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/12 - J.U.C\344\271\213\351\207\215\345\205\245\351\224\201\357\274\232ReentrantLock.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/12 - J.U.C\344\271\213\351\207\215\345\205\245\351\224\201\357\274\232ReentrantLock.md"
index e0a3991f..dba667d8 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/12 - J.U.C\344\271\213\351\207\215\345\205\245\351\224\201\357\274\232ReentrantLock.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/12 - J.U.C\344\271\213\351\207\215\345\205\245\351\224\201\357\274\232ReentrantLock.md"	
@@ -1,172 +1,172 @@
-
-  ReentrantLock，`可重入锁`，是一种`递归无阻塞`的同步机制。它可以等同于synchronized的使用，但是ReentrantLock提供了比synchronized更强大、灵活的锁机制，可以减少死锁发生的概率。
-  API介绍如下：
-
-    **一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。**
-
-  ReentrantLock还提供了`公平锁`与`非公平锁`的选择，构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，否则为非公平锁。
-  公平锁与非公平锁的区别在于公平锁的锁获取是有顺序的。但是公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量。
-
-  底层采用AQS实现，通过内部Sync继承AQS
-  <img src="img/201702010001_thumb.jpg">
-
-### 获取锁
-  我们一般都是这么使用ReentrantLock获取锁的：
-  ``` java
-  //非公平锁
-  ReentrantLock lock = new ReentrantLock();
-  lock.lock();
-  ```
-  lock方法：
-  ```java
-  public void lock() {
-      sync.lock();
-  }
-  ```
-  Sync为ReentrantLock里面的一个内部类，它继承AQS（AbstractQueuedSynchronizer），它有两个子类：`公平锁FairSync`和`非公平锁NonfairSync`。
-
-  ReentrantLock里面大部分的功能都是委托给Sync来实现的，同时Sync内部定义了lock()抽象方法由其子类去实现，默认实现了nonfairTryAcquire(int acquires)方法，可以看出它是非公平锁的默认实现方式。下面我们看非公平锁的lock()方法：
-
-  ```java
-  final void lock() {
-      //尝试获取锁
-      if (compareAndSetState(0, 1))
-          setExclusiveOwnerThread(Thread.currentThread());
-      else
-          //获取失败，调用AQS的acquire(int arg)方法
-          acquire(1);
-  }
-  ```
-  首先会第一次尝试快速获取锁，如果获取失败，则调用acquire(int arg)方法，该方法定义在AQS中，如下：
-  ```java
-  public final void acquire(int arg) {
-      if (!tryAcquire(arg) &&
-              acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
-          selfInterrupt();
-  }
-  ```
-  这个方法首先调用tryAcquire(int arg)方法，在AQS中讲述过，tryAcquire(int arg)需要自定义同步组件提供实现，非公平锁实现如下：
-  ```java
-  protected final boolean tryAcquire(int acquires) {
-      return nonfairTryAcquire(acquires);
-  }
-
-  final boolean nonfairTryAcquire(int acquires) {
-      //当前线程
-      final Thread current = Thread.currentThread();
-      //获取同步状态
-      int c = getState();
-      //state == 0,表示没有该锁处于空闲状态
-      if (c == 0) {
-          //获取锁成功，设置为当前线程所有
-          if (compareAndSetState(0, acquires)) {
-              setExclusiveOwnerThread(current);
-              return true;
-          }
-      }
-      //线程重入
-      //判断锁持有的线程是否为当前线程
-      else if (current == getExclusiveOwnerThread()) {
-          int nextc = c + acquires;
-          if (nextc < 0) // overflow
-              throw new Error("Maximum lock count exceeded");
-          setState(nextc);
-          return true;
-      }
-      return false;
-  }
-  ```
-  该方法主要逻辑：首先判断同步状态state == 0 ?，如果是表示该锁还没有被线程持有，直接通过CAS获取同步状态，如果成功返回true。如果state != 0，则判断当前线程是否为获取锁的线程，如果是则获取锁，成功返回true。成功获取锁的线程再次获取锁，这是增加了同步状态state。
-
-### 释放锁
-  获取同步锁后，使用完毕则需要释放锁，ReentrantLock提供了unlock释放锁：
-  ```java
-  public void unlock() {
-      sync.release(1);
-  }
-  ```
-  unlock内部使用Sync的release(int arg)释放锁，release(int arg)是在AQS中定义的：
-  ```java
-  public final boolean release(int arg) {
-      if (tryRelease(arg)) {
-          Node h = head;
-          if (h != null && h.waitStatus != 0)
-              unparkSuccessor(h);
-          return true;
-      }
-      return false;
-  }
-  ```
-  与获取同步状态的acquire(int arg)方法相似，释放同步状态的tryRelease(int arg)同样是需要自定义同步组件自己实现：
-  ```java
-  protected final boolean tryRelease(int releases) {
-      //减掉releases
-      int c = getState() - releases;
-      //如果释放的不是持有锁的线程，抛出异常
-      if (Thread.currentThread() != getExclusiveOwnerThread())
-          throw new IllegalMonitorStateException();
-      boolean free = false;
-      //state == 0 表示已经释放完全了，其他线程可以获取同步状态了
-      if (c == 0) {
-          free = true;
-          setExclusiveOwnerThread(null);
-      }
-      setState(c);
-      return free;
-  }
-  ```
-  只有当同步状态彻底释放后该方法才会返回true。当state == 0 时，则将锁持有线程设置为null，free= true，表示释放成功。
-
-### 公平锁与非公平锁
-
-  公平锁与非公平锁的区别在于`获取锁`的时候是否按照FIFO的顺序来。`释放锁``不存在`公平性和非公平性，上面以非公平锁为例，下面我们来看看公平锁的tryAcquire(int arg)：
-
-  ```java
-  protected final boolean tryAcquire(int acquires) {
-      final Thread current = Thread.currentThread();
-      int c = getState();
-      if (c == 0) {
-          if (!hasQueuedPredecessors() &&
-                  compareAndSetState(0, acquires)) {
-              setExclusiveOwnerThread(current);
-              return true;
-          }
-      }
-      else if (current == getExclusiveOwnerThread()) {
-          int nextc = c + acquires;
-          if (nextc < 0)
-              throw new Error("Maximum lock count exceeded");
-          setState(nextc);
-          return true;
-      }
-      return false;
-  }
-  ```
-  比较非公平锁和公平锁获取同步状态的过程，会发现两者唯一的区别就在于公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()，定义如下：
-
-  ```java
-  public final boolean hasQueuedPredecessors() {
-      Node t = tail;  //尾节点
-      Node h = head;  //头节点
-      Node s;
-
-      //头节点 != 尾节点
-      //同步队列第一个节点不为null
-      //当前线程是同步队列第一个节点
-      return h != t &&
-              ((s = h.next) == null || s.thread != Thread.currentThread());
-  }
-  ```
-  该方法主要做一件事情：主要是判断当前线程是否位于CLH同步队列中的第一个。如果是则返回true，否则返回false。
-
-### ReentrantLock与synchronized的区别
-
-  前面提到ReentrantLock提供了比synchronized更加灵活和强大的锁机制，那么它的灵活和强大之处在哪里呢？他们之间又有什么相异之处呢？
-
-  首先他们肯定具有`相同的` `功能`和`内存语义`。
-
-  与synchronized相比，ReentrantLock提供了`更多，更加全面的功能`，具备`更强的扩展性`。例如：`时间锁等候`，`可中断锁等候`，`锁投票`。
-  ReentrantLock还提供了`条件Condition`，对线程的等待、唤醒操作更加详细和灵活，所以在`多个条件变量`和`高度竞争锁`的地方，ReentrantLock更加适合（以后会阐述Condition）。
-  ReentrantLock提供了`可轮询`的锁请求。它会尝试着去获取锁，如果成功则继续，否则可以等到下次运行时处理，而synchronized则一旦进入锁请求要么成功要么阻塞，所以相比synchronized而言，ReentrantLock`会不容易产生死锁些`。
-  ReentrantLock支持更加灵活的同步代码块，但是使用synchronized时，只能在同一个synchronized块结构中获取和释放。注：ReentrantLock的锁释放一定要在finally中处理，否则可能会产生严重的后果。
-  ReentrantLock支持中断处理，且性能较synchronized会好些。
+
+  ReentrantLock，`可重入锁`，是一种`递归无阻塞`的同步机制。它可以等同于synchronized的使用，但是ReentrantLock提供了比synchronized更强大、灵活的锁机制，可以减少死锁发生的概率。
+  API介绍如下：
+
+    **一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。**
+
+  ReentrantLock还提供了`公平锁`与`非公平锁`的选择，构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，否则为非公平锁。
+  公平锁与非公平锁的区别在于公平锁的锁获取是有顺序的。但是公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量。
+
+  底层采用AQS实现，通过内部Sync继承AQS
+  <img src="img/201702010001_thumb.jpg">
+
+### 获取锁
+  我们一般都是这么使用ReentrantLock获取锁的：
+  ``` java
+  //非公平锁
+  ReentrantLock lock = new ReentrantLock();
+  lock.lock();
+  ```
+  lock方法：
+  ```java
+  public void lock() {
+      sync.lock();
+  }
+  ```
+  Sync为ReentrantLock里面的一个内部类，它继承AQS（AbstractQueuedSynchronizer），它有两个子类：`公平锁FairSync`和`非公平锁NonfairSync`。
+
+  ReentrantLock里面大部分的功能都是委托给Sync来实现的，同时Sync内部定义了lock()抽象方法由其子类去实现，默认实现了nonfairTryAcquire(int acquires)方法，可以看出它是非公平锁的默认实现方式。下面我们看非公平锁的lock()方法：
+
+  ```java
+  final void lock() {
+      //尝试获取锁
+      if (compareAndSetState(0, 1))
+          setExclusiveOwnerThread(Thread.currentThread());
+      else
+          //获取失败，调用AQS的acquire(int arg)方法
+          acquire(1);
+  }
+  ```
+  首先会第一次尝试快速获取锁，如果获取失败，则调用acquire(int arg)方法，该方法定义在AQS中，如下：
+  ```java
+  public final void acquire(int arg) {
+      if (!tryAcquire(arg) &&
+              acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
+          selfInterrupt();
+  }
+  ```
+  这个方法首先调用tryAcquire(int arg)方法，在AQS中讲述过，tryAcquire(int arg)需要自定义同步组件提供实现，非公平锁实现如下：
+  ```java
+  protected final boolean tryAcquire(int acquires) {
+      return nonfairTryAcquire(acquires);
+  }
+
+  final boolean nonfairTryAcquire(int acquires) {
+      //当前线程
+      final Thread current = Thread.currentThread();
+      //获取同步状态
+      int c = getState();
+      //state == 0,表示没有该锁处于空闲状态
+      if (c == 0) {
+          //获取锁成功，设置为当前线程所有
+          if (compareAndSetState(0, acquires)) {
+              setExclusiveOwnerThread(current);
+              return true;
+          }
+      }
+      //线程重入
+      //判断锁持有的线程是否为当前线程
+      else if (current == getExclusiveOwnerThread()) {
+          int nextc = c + acquires;
+          if (nextc < 0) // overflow
+              throw new Error("Maximum lock count exceeded");
+          setState(nextc);
+          return true;
+      }
+      return false;
+  }
+  ```
+  该方法主要逻辑：首先判断同步状态state == 0 ?，如果是表示该锁还没有被线程持有，直接通过CAS获取同步状态，如果成功返回true。如果state != 0，则判断当前线程是否为获取锁的线程，如果是则获取锁，成功返回true。成功获取锁的线程再次获取锁，这是增加了同步状态state。
+
+### 释放锁
+  获取同步锁后，使用完毕则需要释放锁，ReentrantLock提供了unlock释放锁：
+  ```java
+  public void unlock() {
+      sync.release(1);
+  }
+  ```
+  unlock内部使用Sync的release(int arg)释放锁，release(int arg)是在AQS中定义的：
+  ```java
+  public final boolean release(int arg) {
+      if (tryRelease(arg)) {
+          Node h = head;
+          if (h != null && h.waitStatus != 0)
+              unparkSuccessor(h);
+          return true;
+      }
+      return false;
+  }
+  ```
+  与获取同步状态的acquire(int arg)方法相似，释放同步状态的tryRelease(int arg)同样是需要自定义同步组件自己实现：
+  ```java
+  protected final boolean tryRelease(int releases) {
+      //减掉releases
+      int c = getState() - releases;
+      //如果释放的不是持有锁的线程，抛出异常
+      if (Thread.currentThread() != getExclusiveOwnerThread())
+          throw new IllegalMonitorStateException();
+      boolean free = false;
+      //state == 0 表示已经释放完全了，其他线程可以获取同步状态了
+      if (c == 0) {
+          free = true;
+          setExclusiveOwnerThread(null);
+      }
+      setState(c);
+      return free;
+  }
+  ```
+  只有当同步状态彻底释放后该方法才会返回true。当state == 0 时，则将锁持有线程设置为null，free= true，表示释放成功。
+
+### 公平锁与非公平锁
+
+  公平锁与非公平锁的区别在于`获取锁`的时候是否按照FIFO的顺序来。`释放锁``不存在`公平性和非公平性，上面以非公平锁为例，下面我们来看看公平锁的tryAcquire(int arg)：
+
+  ```java
+  protected final boolean tryAcquire(int acquires) {
+      final Thread current = Thread.currentThread();
+      int c = getState();
+      if (c == 0) {
+          if (!hasQueuedPredecessors() &&
+                  compareAndSetState(0, acquires)) {
+              setExclusiveOwnerThread(current);
+              return true;
+          }
+      }
+      else if (current == getExclusiveOwnerThread()) {
+          int nextc = c + acquires;
+          if (nextc < 0)
+              throw new Error("Maximum lock count exceeded");
+          setState(nextc);
+          return true;
+      }
+      return false;
+  }
+  ```
+  比较非公平锁和公平锁获取同步状态的过程，会发现两者唯一的区别就在于公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()，定义如下：
+
+  ```java
+  public final boolean hasQueuedPredecessors() {
+      Node t = tail;  //尾节点
+      Node h = head;  //头节点
+      Node s;
+
+      //头节点 != 尾节点
+      //同步队列第一个节点不为null
+      //当前线程是同步队列第一个节点
+      return h != t &&
+              ((s = h.next) == null || s.thread != Thread.currentThread());
+  }
+  ```
+  该方法主要做一件事情：主要是判断当前线程是否位于CLH同步队列中的第一个。如果是则返回true，否则返回false。
+
+### ReentrantLock与synchronized的区别
+
+  前面提到ReentrantLock提供了比synchronized更加灵活和强大的锁机制，那么它的灵活和强大之处在哪里呢？他们之间又有什么相异之处呢？
+
+  首先他们肯定具有`相同的` `功能`和`内存语义`。
+
+  与synchronized相比，ReentrantLock提供了`更多，更加全面的功能`，具备`更强的扩展性`。例如：`时间锁等候`，`可中断锁等候`，`锁投票`。
+  ReentrantLock还提供了`条件Condition`，对线程的等待、唤醒操作更加详细和灵活，所以在`多个条件变量`和`高度竞争锁`的地方，ReentrantLock更加适合（以后会阐述Condition）。
+  ReentrantLock提供了`可轮询`的锁请求。它会尝试着去获取锁，如果成功则继续，否则可以等到下次运行时处理，而synchronized则一旦进入锁请求要么成功要么阻塞，所以相比synchronized而言，ReentrantLock`会不容易产生死锁些`。
+  ReentrantLock支持更加灵活的同步代码块，但是使用synchronized时，只能在同一个synchronized块结构中获取和释放。注：ReentrantLock的锁释放一定要在finally中处理，否则可能会产生严重的后果。
+  ReentrantLock支持中断处理，且性能较synchronized会好些。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/13 - J.U.C\344\271\213\350\257\273\345\206\231\351\224\201\357\274\232ReentrantReadWriteLock.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/13 - J.U.C\344\271\213\350\257\273\345\206\231\351\224\201\357\274\232ReentrantReadWriteLock.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/13 - J.U.C\344\271\213\350\257\273\345\206\231\351\224\201\357\274\232ReentrantReadWriteLock.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/13 - J.U.C\344\271\213\350\257\273\345\206\231\351\224\201\357\274\232ReentrantReadWriteLock.md"
index 3d8df585..5911127f 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/13 - J.U.C\344\271\213\350\257\273\345\206\231\351\224\201\357\274\232ReentrantReadWriteLock.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/13 - J.U.C\344\271\213\350\257\273\345\206\231\351\224\201\357\274\232ReentrantReadWriteLock.md"	
@@ -1,413 +1,413 @@
-
-  重入锁ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，但是在大多数场景下，大部分时间都是提供读服务，而写服务占有的时间较少。然而读服务不存在数据竞争问题，如果一个线程在读时禁止其他线程读势必会导致性能降低。所以就提供了读写锁。
-
-  读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时，所有读线程和写线程都会被阻塞。
-
-  **读写锁** 的主要特性：
-
-  1. 公平性：支持公平性和非公平性。
-  2. 重入性：支持重入。读写锁最多支持65535个递归写入锁和65535个递归读取锁。
-  3. 锁降级：遵循获取写锁、获取读锁在释放写锁的次序，写锁能够降级成为读锁
-
-  读写锁ReentrantReadWriteLock实现接口ReadWriteLock，该接口维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。
-  **只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。**
-
-  ```java
-  public interface ReadWriteLock {
-      Lock readLock();
-      Lock writeLock();
-  }
-  ```
-  ReadWriteLock定义了两个方法。readLock()返回用于读操作的锁，writeLock()返回用于写操作的锁。ReentrantReadWriteLock定义如下：
-  ```java
-  /** 内部类  读锁 */
-  private final ReentrantReadWriteLock.ReadLock readerLock;
-  /** 内部类  写锁 */
-  private final ReentrantReadWriteLock.WriteLock writerLock;
-
-  final Sync sync;
-
-  /** 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock */
-  public ReentrantReadWriteLock() {
-      this(false);
-  }
-
-  /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
-  public ReentrantReadWriteLock(boolean fair) {
-      sync = fair ? new FairSync() : new NonfairSync();
-      readerLock = new ReadLock(this);
-      writerLock = new WriteLock(this);
-  }
-
-  /** 返回用于写入操作的锁 */
-  public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
-  /** 返回用于读取操作的锁 */
-  public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
-
-  abstract static class Sync extends AbstractQueuedSynchronizer {
-      /**
-       * 省略其余源代码
-       */
-  }
-  public static class WriteLock implements Lock, java.io.Serializable{
-      /**
-       * 省略其余源代码
-       */
-  }
-
-  public static class ReadLock implements Lock, java.io.Serializable {
-      /**
-       * 省略其余源代码
-       */
-  }
-  ```
-
-  ReentrantReadWriteLock与ReentrantLock一样，其锁主体依然是 `Sync`，它的读锁、写锁都是依靠Sync来实现的。所以ReentrantReadWriteLock实际上`只有一个锁`，只是在获取读取锁和写入锁的方式上不一样而已，它的读写锁其实就是两个类：ReadLock、writeLock，这两个类都是lock实现。
-
-  在ReentrantLock中使用一个int类型的state来表示同步状态，该值表示锁被一个线程重复获取的次数。但是读写锁ReentrantReadWriteLock内部维护着两个一对锁，需要用一个变量维护多种状态。
-  所以读写锁采用“按位切割使用”的方式来维护这个变量，将其切分为两部分，高16为表示读，低16为表示写。
-  分割之后，读写锁是如何迅速确定读锁和写锁的状态呢？
-  通过为运算。假如当前同步状态为S，那么写状态等于 S & 0x0000FFFF（将高16位全部抹去），读状态等于S >>> 16(无符号补0右移16位)。代码如下：
-
-  ```java
-  static final int SHARED_SHIFT   = 16;
-  static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
-  static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
-  static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
-
-  static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
-  static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
-  ```
-### 写锁
-  写锁就是一个支持可重入的排他锁。
-
-#### 写锁的获取
-  写锁的获取最终会调用tryAcquire(int arg)，该方法在内部类Sync中实现：
-  ```java
-  protected final boolean tryAcquire(int acquires) {
-      Thread current = Thread.currentThread();
-      //当前锁个数
-      int c = getState();
-      //写锁
-      int w = exclusiveCount(c);
-      if (c != 0) {
-          //c != 0 && w == 0 表示存在读锁
-          //当前线程不是已经获取写锁的线程
-          if (w == 0 || current != getExclusiveOwnerThread())
-              return false;
-          //超出最大范围
-          if (w + exclusiveCount(acquires) > MAX_COUNT)
-              throw new Error("Maximum lock count exceeded");
-          setState(c + acquires);
-          return true;
-      }
-      //是否需要阻塞
-      if (writerShouldBlock() ||
-              !compareAndSetState(c, c + acquires))
-          return false;
-      //设置获取锁的线程为当前线程
-      setExclusiveOwnerThread(current);
-      return true;
-  }
-  ```
-  该方法和ReentrantLock的tryAcquire(int arg)大致一样，在判断重入时增加了一项条件：读锁是否存在。因为要确保写锁的操作对读锁是可见的，如果在存在读锁的情况下允许获取写锁，那么那些已经获取读锁的其他线程可能就无法感知当前写线程的操作。因此只有等读锁完全释放后，写锁才能够被当前线程所获取，一旦写锁获取了，所有其他读、写线程均会被阻塞。
-
-#### 写锁的释放
-  获取了写锁用完了则需要释放，WriteLock提供了unlock()方法释放写锁：
-  ```java
-  public void unlock() {
-      sync.release(1);
-  }
-
-  public final boolean release(int arg) {
-      if (tryRelease(arg)) {
-          Node h = head;
-          if (h != null && h.waitStatus != 0)
-              unparkSuccessor(h);
-          return true;
-      }
-      return false;
-  }
-  ```
-  写锁的释放最终还是会调用AQS的模板方法release(int arg)方法，该方法首先调用tryRelease(int arg)方法尝试释放锁，tryRelease(int arg)方法为读写锁内部类Sync中定义了，如下：
-  ```java
-  protected final boolean tryRelease(int releases) {
-      //释放的线程不为锁的持有者
-      if (!isHeldExclusively())
-          throw new IllegalMonitorStateException();
-      int nextc = getState() - releases;
-      //若写锁的新线程数为0，则将锁的持有者设置为null
-      boolean free = exclusiveCount(nextc) == 0;
-      if (free)
-          setExclusiveOwnerThread(null);
-      setState(nextc);
-      return free;
-  }
-  ```
-  写锁释放锁的整个过程和独占锁ReentrantLock相似，每次释放均是减少写状态，当写状态为0时表示 写锁已经完全释放了，从而等待的其他线程可以继续访问读写锁，获取同步状态，同时此次写线程的修改对后续的线程可见。
-
-### 读锁
-  读锁为一个可重入的共享锁，它能够被多个线程同时持有，在没有其他写线程访问时，读锁总是或获取成功。
-
-#### 读锁的获取
-  读锁的获取可以通过ReadLock的lock()方法：
-  ```java
-  public void lock() {
-      sync.acquireShared(1);
-  }
-  ```
-  Sync的acquireShared(int arg)定义在AQS中：
-  ```java
-  public final void acquireShared(int arg) {
-      if (tryAcquireShared(arg) < 0)
-          doAcquireShared(arg);
-  }
-  ```
-  tryAcqurireShared(int arg)尝试获取读同步状态，该方法主要用于获取共享式同步状态，获取成功返回 >= 0的返回结果，否则返回 < 0 的返回结果。
-  ```java
-  protected final int tryAcquireShared(int unused) {
-      //当前线程
-      Thread current = Thread.currentThread();
-      int c = getState();
-      //exclusiveCount(c)计算写锁
-      //如果存在写锁，且锁的持有者不是当前线程，直接返回-1
-      //存在锁降级问题，后续阐述
-      if (exclusiveCount(c) != 0 &&
-              getExclusiveOwnerThread() != current)
-          return -1;
-      //读锁
-      int r = sharedCount(c);
-
-      /*
-       * readerShouldBlock():读锁是否需要等待（公平锁原则）
-       * r < MAX_COUNT：持有线程小于最大数（65535）
-       * compareAndSetState(c, c + SHARED_UNIT)：设置读取锁状态
-       */
-      if (!readerShouldBlock() &&
-              r < MAX_COUNT &&
-              compareAndSetState(c, c + SHARED_UNIT)) {
-          /*
-           * holdCount部分后面讲解
-           */
-          if (r == 0) {
-              firstReader = current;
-              firstReaderHoldCount = 1;
-          } else if (firstReader == current) {
-              firstReaderHoldCount++;
-          } else {
-              HoldCounter rh = cachedHoldCounter;
-              if (rh == null || rh.tid != getThreadId(current))
-                  cachedHoldCounter = rh = readHolds.get();
-              else if (rh.count == 0)
-                  readHolds.set(rh);
-              rh.count++;
-          }
-          return 1;
-      }
-      return fullTryAcquireShared(current);
-  }
-  ```
-  读锁获取的过程相对于独占锁而言会稍微复杂下，整个过程如下：
-
-  因为存在锁降级情况，如果存在写锁且锁的持有者不是当前线程则直接返回失败，否则继续
-  依据公平性原则，判断读锁是否需要阻塞，读锁持有线程数小于最大值（65535），且设置锁状态成功，执行以下代码（对于HoldCounter下面再阐述），并返回1。如果不满足改条件，执行fullTryAcquireShared()。
-  ```java
-  final int fullTryAcquireShared(Thread current) {
-      HoldCounter rh = null;
-      for (;;) {
-          int c = getState();
-          //锁降级
-          if (exclusiveCount(c) != 0) {
-              if (getExclusiveOwnerThread() != current)
-                  return -1;
-          }
-          //读锁需要阻塞
-          else if (readerShouldBlock()) {
-              //列头为当前线程
-              if (firstReader == current) {
-              }
-              //HoldCounter后面讲解
-              else {
-                  if (rh == null) {
-                      rh = cachedHoldCounter;
-                      if (rh == null || rh.tid != getThreadId(current)) {
-                          rh = readHolds.get();
-                          if (rh.count == 0)
-                              readHolds.remove();
-                      }
-                  }
-                  if (rh.count == 0)
-                      return -1;
-              }
-          }
-          //读锁超出最大范围
-          if (sharedCount(c) == MAX_COUNT)
-              throw new Error("Maximum lock count exceeded");
-          //CAS设置读锁成功
-          if (compareAndSetState(c, c + SHARED_UNIT)) {
-              //如果是第1次获取“读取锁”，则更新firstReader和firstReaderHoldCount
-              if (sharedCount(c) == 0) {
-                  firstReader = current;
-                  firstReaderHoldCount = 1;
-              }
-              //如果想要获取锁的线程(current)是第1个获取锁(firstReader)的线程,则将firstReaderHoldCount+1
-              else if (firstReader == current) {
-                  firstReaderHoldCount++;
-              } else {
-                  if (rh == null)
-                      rh = cachedHoldCounter;
-                  if (rh == null || rh.tid != getThreadId(current))
-                      rh = readHolds.get();
-                  else if (rh.count == 0)
-                      readHolds.set(rh);
-                  //更新线程的获取“读取锁”的共享计数
-                  rh.count++;
-                  cachedHoldCounter = rh; // cache for release
-              }
-              return 1;
-          }
-      }
-  }
-  ```
-  fullTryAcquireShared(Thread current)会根据“是否需要阻塞等待”，“读取锁的共享计数是否超过限制”等等进行处理。如果不需要阻塞等待，并且锁的共享计数没有超过限制，则通过CAS尝试获取锁，并返回1
-
-#### 读锁的释放
-  与写锁相同，读锁也提供了unlock()释放读锁：
-  ```JAVA
-  public void unlock() {
-      sync.releaseShared(1);
-  }
-  ```
-  unlcok()方法内部使用Sync的releaseShared(int arg)方法，该方法定义在AQS中：
-  ```JAVA
-  public final boolean releaseShared(int arg) {
-      if (tryReleaseShared(arg)) {
-          doReleaseShared();
-          return true;
-      }
-      return false;
-  }
-  ```
-  调用tryReleaseShared(int arg)尝试释放读锁，该方法定义在读写锁的Sync内部类中：
-  ```JAVA
- protected final boolean tryReleaseShared(int unused) {
-      Thread current = Thread.currentThread();
-      //如果想要释放锁的线程为第一个获取锁的线程
-      if (firstReader == current) {
-          //仅获取了一次，则需要将firstReader 设置null，否则 firstReaderHoldCount - 1
-          if (firstReaderHoldCount == 1)
-              firstReader = null;
-          else
-              firstReaderHoldCount--;
-      }
-      //获取rh对象，并更新“当前线程获取锁的信息”
-      else {
-          HoldCounter rh = cachedHoldCounter;
-          if (rh == null || rh.tid != getThreadId(current))
-              rh = readHolds.get();
-          int count = rh.count;
-          if (count <= 1) {
-              readHolds.remove();
-              if (count <= 0)
-                  throw unmatchedUnlockException();
-          }
-          --rh.count;
-      }
-      //CAS更新同步状态
-      for (;;) {
-          int c = getState();
-          int nextc = c - SHARED_UNIT;
-          if (compareAndSetState(c, nextc))
-              return nextc == 0;
-      }
-  }
-  ```
-
-### HoldCounter
-  在读锁获取锁和释放锁的过程中，我们一直都可以看到一个变量rh （HoldCounter ），该变量在读锁中扮演着非常重要的作用。
-
-  我们了解读锁的内在机制其实就是一个共享锁，为了更好理解HoldCounter ，我们暂且认为它不是一个锁的概率，而相当于一个计数器。一次共享锁的操作就相当于在该计数器的操作。获取共享锁，则该计数器 + 1，释放共享锁，该计数器 - 1。只有当线程获取共享锁后才能对共享锁进行释放、重入操作。所以HoldCounter的作用就是当前线程持有共享锁的数量，这个数量必须要与线程绑定在一起，否则操作其他线程锁就会抛出异常。我们先看HoldCounter的定义：
-  ```JAVA
-  static final class HoldCounter {
-      int count = 0;
-      final long tid = getThreadId(Thread.currentThread());
-  }
-  ```
-  HoldCounter 定义非常简单，就是一个计数器count 和线程 id tid 两个变量。按照这个意思我们看到HoldCounter 是需要和某给线程进行绑定了，我们知道如果要将一个对象和线程绑定仅仅有tid是不够的，而且从上面的代码我们可以看到HoldCounter 仅仅只是记录了tid，根本起不到绑定线程的作用。那么怎么实现呢？答案是ThreadLocal，定义如下：
-  ```JAVA
-  static final class ThreadLocalHoldCounter
-      extends ThreadLocal<HoldCounter> {
-      public HoldCounter initialValue() {
-          return new HoldCounter();
-      }
-  }
-  ```
-  通过上面代码HoldCounter就可以与线程进行绑定了。故而，HoldCounter应该就是绑定线程上的一个计数器，而ThradLocalHoldCounter则是线程绑定的ThreadLocal。从上面我们可以看到ThreadLocal将HoldCounter绑定到当前线程上，同时HoldCounter也持有线程Id，这样在释放锁的时候才能知道ReadWriteLock里面缓存的上一个读取线程（cachedHoldCounter）是否是当前线程。这样做的好处是可以减少ThreadLocal.get()的次数，因为这也是一个耗时操作。需要说明的是这样HoldCounter绑定线程id而不绑定线程对象的原因是避免HoldCounter和ThreadLocal互相绑定而GC难以释放它们（尽管GC能够智能的发现这种引用而回收它们，但是这需要一定的代价），所以其实这样做只是为了帮助GC快速回收对象而已。
-
-  看到这里我们明白了HoldCounter作用了，我们在看一个获取读锁的代码段：
-  ```JAVA
-  else if (firstReader == current) {
-      firstReaderHoldCount++;
-  } else {
-      if (rh == null)
-          rh = cachedHoldCounter;
-      if (rh == null || rh.tid != getThreadId(current))
-          rh = readHolds.get();
-      else if (rh.count == 0)
-          readHolds.set(rh);
-      rh.count++;
-      cachedHoldCounter = rh; // cache for release
-  }
-  ```
-  这段代码涉及了几个变量：firstReader 、firstReaderHoldCount、cachedHoldCounter 。我们先理清楚这几个变量：
-  ```JAVA
-  private transient Thread firstReader = null;
-  private transient int firstReaderHoldCount;
-  private transient HoldCounter cachedHoldCounter;
-  ```
-  firstReader 看名字就明白了为第一个获取读锁的线程，firstReaderHoldCount为第一个获取读锁的重入数，cachedHoldCounter为HoldCounter的缓存。
-
-  理清楚上面所有的变量了，HoldCounter也明白了，我们就来给上面那段代码标明注释，如下：
-  ```JAVA
-  //如果获取读锁的线程为第一次获取读锁的线程，则firstReaderHoldCount重入数 + 1
-  else if (firstReader == current) {
-      firstReaderHoldCount++;
-  } else {
-      //非firstReader计数
-      if (rh == null)
-          rh = cachedHoldCounter;
-      //rh == null 或者 rh.tid != current.getId()，需要获取rh
-      if (rh == null || rh.tid != getThreadId(current))
-          rh = readHolds.get();
-          //加入到readHolds中
-      else if (rh.count == 0)
-          readHolds.set(rh);
-      //计数+1
-      rh.count++;
-      cachedHoldCounter = rh; // cache for release
-  }
-  ```
-  这里解释下为何要引入firstRead、firstReaderHoldCount。这是为了一个效率问题，firstReader是不会放入到readHolds中的，如果读锁仅有一个的情况下就会避免查找readHolds。
-
-### 锁降级
-  上开篇是LZ就阐述了读写锁有一个特性就是锁降级，**锁降级就意味着写锁是可以降级为读锁的，但是需要遵循先获取写锁、获取读锁在释放写锁的次序。** 注意如果当前线程先获取写锁，然后释放写锁，再获取读锁这个过程不能称之为锁降级，锁降级一定要遵循那个次序。
-
-  在获取读锁的方法tryAcquireShared(int unused)中，有一段代码就是来判读锁降级的：
-  ```JAVA
-  int c = getState();
-  //exclusiveCount(c)计算写锁
-  //如果存在写锁，且锁的持有者不是当前线程，直接返回-1
-  //存在锁降级问题，后续阐述
-  if (exclusiveCount(c) != 0 &&
-          getExclusiveOwnerThread() != current)
-      return -1;
-  //读锁
-  int r = sharedCount(c);
-  ```
-  锁降级中读锁的获取释放为必要？肯定是必要的。试想，假如当前线程A不获取读锁而是直接释放了写锁，这个时候另外一个线程B获取了写锁，那么这个线程B对数据的修改是不会对当前线程A可见的。如果获取了读锁，则线程B在获取写锁过程中判断如果有读锁还没有释放则会被阻塞，只有当前线程A释放读锁后，线程B才会获取写锁成功。
-
-### 参考资料
-Doug Lea：《Java并发编程实战》
-方腾飞：《Java并发编程的艺术》
-【Java并发编程实战】—–“J.U.C”：ReentrantReadWriteLock http://cmsblogs.com/?p=1679
-Java多线程（十）之ReentrantReadWriteLock深入分析 https://my.oschina.net/adan1/blog/158107
+
+  重入锁ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，但是在大多数场景下，大部分时间都是提供读服务，而写服务占有的时间较少。然而读服务不存在数据竞争问题，如果一个线程在读时禁止其他线程读势必会导致性能降低。所以就提供了读写锁。
+
+  读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时，所有读线程和写线程都会被阻塞。
+
+  **读写锁** 的主要特性：
+
+  1. 公平性：支持公平性和非公平性。
+  2. 重入性：支持重入。读写锁最多支持65535个递归写入锁和65535个递归读取锁。
+  3. 锁降级：遵循获取写锁、获取读锁在释放写锁的次序，写锁能够降级成为读锁
+
+  读写锁ReentrantReadWriteLock实现接口ReadWriteLock，该接口维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。
+  **只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。**
+
+  ```java
+  public interface ReadWriteLock {
+      Lock readLock();
+      Lock writeLock();
+  }
+  ```
+  ReadWriteLock定义了两个方法。readLock()返回用于读操作的锁，writeLock()返回用于写操作的锁。ReentrantReadWriteLock定义如下：
+  ```java
+  /** 内部类  读锁 */
+  private final ReentrantReadWriteLock.ReadLock readerLock;
+  /** 内部类  写锁 */
+  private final ReentrantReadWriteLock.WriteLock writerLock;
+
+  final Sync sync;
+
+  /** 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock */
+  public ReentrantReadWriteLock() {
+      this(false);
+  }
+
+  /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
+  public ReentrantReadWriteLock(boolean fair) {
+      sync = fair ? new FairSync() : new NonfairSync();
+      readerLock = new ReadLock(this);
+      writerLock = new WriteLock(this);
+  }
+
+  /** 返回用于写入操作的锁 */
+  public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
+  /** 返回用于读取操作的锁 */
+  public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
+
+  abstract static class Sync extends AbstractQueuedSynchronizer {
+      /**
+       * 省略其余源代码
+       */
+  }
+  public static class WriteLock implements Lock, java.io.Serializable{
+      /**
+       * 省略其余源代码
+       */
+  }
+
+  public static class ReadLock implements Lock, java.io.Serializable {
+      /**
+       * 省略其余源代码
+       */
+  }
+  ```
+
+  ReentrantReadWriteLock与ReentrantLock一样，其锁主体依然是 `Sync`，它的读锁、写锁都是依靠Sync来实现的。所以ReentrantReadWriteLock实际上`只有一个锁`，只是在获取读取锁和写入锁的方式上不一样而已，它的读写锁其实就是两个类：ReadLock、writeLock，这两个类都是lock实现。
+
+  在ReentrantLock中使用一个int类型的state来表示同步状态，该值表示锁被一个线程重复获取的次数。但是读写锁ReentrantReadWriteLock内部维护着两个一对锁，需要用一个变量维护多种状态。
+  所以读写锁采用“按位切割使用”的方式来维护这个变量，将其切分为两部分，高16为表示读，低16为表示写。
+  分割之后，读写锁是如何迅速确定读锁和写锁的状态呢？
+  通过为运算。假如当前同步状态为S，那么写状态等于 S & 0x0000FFFF（将高16位全部抹去），读状态等于S >>> 16(无符号补0右移16位)。代码如下：
+
+  ```java
+  static final int SHARED_SHIFT   = 16;
+  static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
+  static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
+  static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
+
+  static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
+  static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
+  ```
+### 写锁
+  写锁就是一个支持可重入的排他锁。
+
+#### 写锁的获取
+  写锁的获取最终会调用tryAcquire(int arg)，该方法在内部类Sync中实现：
+  ```java
+  protected final boolean tryAcquire(int acquires) {
+      Thread current = Thread.currentThread();
+      //当前锁个数
+      int c = getState();
+      //写锁
+      int w = exclusiveCount(c);
+      if (c != 0) {
+          //c != 0 && w == 0 表示存在读锁
+          //当前线程不是已经获取写锁的线程
+          if (w == 0 || current != getExclusiveOwnerThread())
+              return false;
+          //超出最大范围
+          if (w + exclusiveCount(acquires) > MAX_COUNT)
+              throw new Error("Maximum lock count exceeded");
+          setState(c + acquires);
+          return true;
+      }
+      //是否需要阻塞
+      if (writerShouldBlock() ||
+              !compareAndSetState(c, c + acquires))
+          return false;
+      //设置获取锁的线程为当前线程
+      setExclusiveOwnerThread(current);
+      return true;
+  }
+  ```
+  该方法和ReentrantLock的tryAcquire(int arg)大致一样，在判断重入时增加了一项条件：读锁是否存在。因为要确保写锁的操作对读锁是可见的，如果在存在读锁的情况下允许获取写锁，那么那些已经获取读锁的其他线程可能就无法感知当前写线程的操作。因此只有等读锁完全释放后，写锁才能够被当前线程所获取，一旦写锁获取了，所有其他读、写线程均会被阻塞。
+
+#### 写锁的释放
+  获取了写锁用完了则需要释放，WriteLock提供了unlock()方法释放写锁：
+  ```java
+  public void unlock() {
+      sync.release(1);
+  }
+
+  public final boolean release(int arg) {
+      if (tryRelease(arg)) {
+          Node h = head;
+          if (h != null && h.waitStatus != 0)
+              unparkSuccessor(h);
+          return true;
+      }
+      return false;
+  }
+  ```
+  写锁的释放最终还是会调用AQS的模板方法release(int arg)方法，该方法首先调用tryRelease(int arg)方法尝试释放锁，tryRelease(int arg)方法为读写锁内部类Sync中定义了，如下：
+  ```java
+  protected final boolean tryRelease(int releases) {
+      //释放的线程不为锁的持有者
+      if (!isHeldExclusively())
+          throw new IllegalMonitorStateException();
+      int nextc = getState() - releases;
+      //若写锁的新线程数为0，则将锁的持有者设置为null
+      boolean free = exclusiveCount(nextc) == 0;
+      if (free)
+          setExclusiveOwnerThread(null);
+      setState(nextc);
+      return free;
+  }
+  ```
+  写锁释放锁的整个过程和独占锁ReentrantLock相似，每次释放均是减少写状态，当写状态为0时表示 写锁已经完全释放了，从而等待的其他线程可以继续访问读写锁，获取同步状态，同时此次写线程的修改对后续的线程可见。
+
+### 读锁
+  读锁为一个可重入的共享锁，它能够被多个线程同时持有，在没有其他写线程访问时，读锁总是或获取成功。
+
+#### 读锁的获取
+  读锁的获取可以通过ReadLock的lock()方法：
+  ```java
+  public void lock() {
+      sync.acquireShared(1);
+  }
+  ```
+  Sync的acquireShared(int arg)定义在AQS中：
+  ```java
+  public final void acquireShared(int arg) {
+      if (tryAcquireShared(arg) < 0)
+          doAcquireShared(arg);
+  }
+  ```
+  tryAcqurireShared(int arg)尝试获取读同步状态，该方法主要用于获取共享式同步状态，获取成功返回 >= 0的返回结果，否则返回 < 0 的返回结果。
+  ```java
+  protected final int tryAcquireShared(int unused) {
+      //当前线程
+      Thread current = Thread.currentThread();
+      int c = getState();
+      //exclusiveCount(c)计算写锁
+      //如果存在写锁，且锁的持有者不是当前线程，直接返回-1
+      //存在锁降级问题，后续阐述
+      if (exclusiveCount(c) != 0 &&
+              getExclusiveOwnerThread() != current)
+          return -1;
+      //读锁
+      int r = sharedCount(c);
+
+      /*
+       * readerShouldBlock():读锁是否需要等待（公平锁原则）
+       * r < MAX_COUNT：持有线程小于最大数（65535）
+       * compareAndSetState(c, c + SHARED_UNIT)：设置读取锁状态
+       */
+      if (!readerShouldBlock() &&
+              r < MAX_COUNT &&
+              compareAndSetState(c, c + SHARED_UNIT)) {
+          /*
+           * holdCount部分后面讲解
+           */
+          if (r == 0) {
+              firstReader = current;
+              firstReaderHoldCount = 1;
+          } else if (firstReader == current) {
+              firstReaderHoldCount++;
+          } else {
+              HoldCounter rh = cachedHoldCounter;
+              if (rh == null || rh.tid != getThreadId(current))
+                  cachedHoldCounter = rh = readHolds.get();
+              else if (rh.count == 0)
+                  readHolds.set(rh);
+              rh.count++;
+          }
+          return 1;
+      }
+      return fullTryAcquireShared(current);
+  }
+  ```
+  读锁获取的过程相对于独占锁而言会稍微复杂下，整个过程如下：
+
+  因为存在锁降级情况，如果存在写锁且锁的持有者不是当前线程则直接返回失败，否则继续
+  依据公平性原则，判断读锁是否需要阻塞，读锁持有线程数小于最大值（65535），且设置锁状态成功，执行以下代码（对于HoldCounter下面再阐述），并返回1。如果不满足改条件，执行fullTryAcquireShared()。
+  ```java
+  final int fullTryAcquireShared(Thread current) {
+      HoldCounter rh = null;
+      for (;;) {
+          int c = getState();
+          //锁降级
+          if (exclusiveCount(c) != 0) {
+              if (getExclusiveOwnerThread() != current)
+                  return -1;
+          }
+          //读锁需要阻塞
+          else if (readerShouldBlock()) {
+              //列头为当前线程
+              if (firstReader == current) {
+              }
+              //HoldCounter后面讲解
+              else {
+                  if (rh == null) {
+                      rh = cachedHoldCounter;
+                      if (rh == null || rh.tid != getThreadId(current)) {
+                          rh = readHolds.get();
+                          if (rh.count == 0)
+                              readHolds.remove();
+                      }
+                  }
+                  if (rh.count == 0)
+                      return -1;
+              }
+          }
+          //读锁超出最大范围
+          if (sharedCount(c) == MAX_COUNT)
+              throw new Error("Maximum lock count exceeded");
+          //CAS设置读锁成功
+          if (compareAndSetState(c, c + SHARED_UNIT)) {
+              //如果是第1次获取“读取锁”，则更新firstReader和firstReaderHoldCount
+              if (sharedCount(c) == 0) {
+                  firstReader = current;
+                  firstReaderHoldCount = 1;
+              }
+              //如果想要获取锁的线程(current)是第1个获取锁(firstReader)的线程,则将firstReaderHoldCount+1
+              else if (firstReader == current) {
+                  firstReaderHoldCount++;
+              } else {
+                  if (rh == null)
+                      rh = cachedHoldCounter;
+                  if (rh == null || rh.tid != getThreadId(current))
+                      rh = readHolds.get();
+                  else if (rh.count == 0)
+                      readHolds.set(rh);
+                  //更新线程的获取“读取锁”的共享计数
+                  rh.count++;
+                  cachedHoldCounter = rh; // cache for release
+              }
+              return 1;
+          }
+      }
+  }
+  ```
+  fullTryAcquireShared(Thread current)会根据“是否需要阻塞等待”，“读取锁的共享计数是否超过限制”等等进行处理。如果不需要阻塞等待，并且锁的共享计数没有超过限制，则通过CAS尝试获取锁，并返回1
+
+#### 读锁的释放
+  与写锁相同，读锁也提供了unlock()释放读锁：
+  ```JAVA
+  public void unlock() {
+      sync.releaseShared(1);
+  }
+  ```
+  unlcok()方法内部使用Sync的releaseShared(int arg)方法，该方法定义在AQS中：
+  ```JAVA
+  public final boolean releaseShared(int arg) {
+      if (tryReleaseShared(arg)) {
+          doReleaseShared();
+          return true;
+      }
+      return false;
+  }
+  ```
+  调用tryReleaseShared(int arg)尝试释放读锁，该方法定义在读写锁的Sync内部类中：
+  ```JAVA
+ protected final boolean tryReleaseShared(int unused) {
+      Thread current = Thread.currentThread();
+      //如果想要释放锁的线程为第一个获取锁的线程
+      if (firstReader == current) {
+          //仅获取了一次，则需要将firstReader 设置null，否则 firstReaderHoldCount - 1
+          if (firstReaderHoldCount == 1)
+              firstReader = null;
+          else
+              firstReaderHoldCount--;
+      }
+      //获取rh对象，并更新“当前线程获取锁的信息”
+      else {
+          HoldCounter rh = cachedHoldCounter;
+          if (rh == null || rh.tid != getThreadId(current))
+              rh = readHolds.get();
+          int count = rh.count;
+          if (count <= 1) {
+              readHolds.remove();
+              if (count <= 0)
+                  throw unmatchedUnlockException();
+          }
+          --rh.count;
+      }
+      //CAS更新同步状态
+      for (;;) {
+          int c = getState();
+          int nextc = c - SHARED_UNIT;
+          if (compareAndSetState(c, nextc))
+              return nextc == 0;
+      }
+  }
+  ```
+
+### HoldCounter
+  在读锁获取锁和释放锁的过程中，我们一直都可以看到一个变量rh （HoldCounter ），该变量在读锁中扮演着非常重要的作用。
+
+  我们了解读锁的内在机制其实就是一个共享锁，为了更好理解HoldCounter ，我们暂且认为它不是一个锁的概率，而相当于一个计数器。一次共享锁的操作就相当于在该计数器的操作。获取共享锁，则该计数器 + 1，释放共享锁，该计数器 - 1。只有当线程获取共享锁后才能对共享锁进行释放、重入操作。所以HoldCounter的作用就是当前线程持有共享锁的数量，这个数量必须要与线程绑定在一起，否则操作其他线程锁就会抛出异常。我们先看HoldCounter的定义：
+  ```JAVA
+  static final class HoldCounter {
+      int count = 0;
+      final long tid = getThreadId(Thread.currentThread());
+  }
+  ```
+  HoldCounter 定义非常简单，就是一个计数器count 和线程 id tid 两个变量。按照这个意思我们看到HoldCounter 是需要和某给线程进行绑定了，我们知道如果要将一个对象和线程绑定仅仅有tid是不够的，而且从上面的代码我们可以看到HoldCounter 仅仅只是记录了tid，根本起不到绑定线程的作用。那么怎么实现呢？答案是ThreadLocal，定义如下：
+  ```JAVA
+  static final class ThreadLocalHoldCounter
+      extends ThreadLocal<HoldCounter> {
+      public HoldCounter initialValue() {
+          return new HoldCounter();
+      }
+  }
+  ```
+  通过上面代码HoldCounter就可以与线程进行绑定了。故而，HoldCounter应该就是绑定线程上的一个计数器，而ThradLocalHoldCounter则是线程绑定的ThreadLocal。从上面我们可以看到ThreadLocal将HoldCounter绑定到当前线程上，同时HoldCounter也持有线程Id，这样在释放锁的时候才能知道ReadWriteLock里面缓存的上一个读取线程（cachedHoldCounter）是否是当前线程。这样做的好处是可以减少ThreadLocal.get()的次数，因为这也是一个耗时操作。需要说明的是这样HoldCounter绑定线程id而不绑定线程对象的原因是避免HoldCounter和ThreadLocal互相绑定而GC难以释放它们（尽管GC能够智能的发现这种引用而回收它们，但是这需要一定的代价），所以其实这样做只是为了帮助GC快速回收对象而已。
+
+  看到这里我们明白了HoldCounter作用了，我们在看一个获取读锁的代码段：
+  ```JAVA
+  else if (firstReader == current) {
+      firstReaderHoldCount++;
+  } else {
+      if (rh == null)
+          rh = cachedHoldCounter;
+      if (rh == null || rh.tid != getThreadId(current))
+          rh = readHolds.get();
+      else if (rh.count == 0)
+          readHolds.set(rh);
+      rh.count++;
+      cachedHoldCounter = rh; // cache for release
+  }
+  ```
+  这段代码涉及了几个变量：firstReader 、firstReaderHoldCount、cachedHoldCounter 。我们先理清楚这几个变量：
+  ```JAVA
+  private transient Thread firstReader = null;
+  private transient int firstReaderHoldCount;
+  private transient HoldCounter cachedHoldCounter;
+  ```
+  firstReader 看名字就明白了为第一个获取读锁的线程，firstReaderHoldCount为第一个获取读锁的重入数，cachedHoldCounter为HoldCounter的缓存。
+
+  理清楚上面所有的变量了，HoldCounter也明白了，我们就来给上面那段代码标明注释，如下：
+  ```JAVA
+  //如果获取读锁的线程为第一次获取读锁的线程，则firstReaderHoldCount重入数 + 1
+  else if (firstReader == current) {
+      firstReaderHoldCount++;
+  } else {
+      //非firstReader计数
+      if (rh == null)
+          rh = cachedHoldCounter;
+      //rh == null 或者 rh.tid != current.getId()，需要获取rh
+      if (rh == null || rh.tid != getThreadId(current))
+          rh = readHolds.get();
+          //加入到readHolds中
+      else if (rh.count == 0)
+          readHolds.set(rh);
+      //计数+1
+      rh.count++;
+      cachedHoldCounter = rh; // cache for release
+  }
+  ```
+  这里解释下为何要引入firstRead、firstReaderHoldCount。这是为了一个效率问题，firstReader是不会放入到readHolds中的，如果读锁仅有一个的情况下就会避免查找readHolds。
+
+### 锁降级
+  上开篇是LZ就阐述了读写锁有一个特性就是锁降级，**锁降级就意味着写锁是可以降级为读锁的，但是需要遵循先获取写锁、获取读锁在释放写锁的次序。** 注意如果当前线程先获取写锁，然后释放写锁，再获取读锁这个过程不能称之为锁降级，锁降级一定要遵循那个次序。
+
+  在获取读锁的方法tryAcquireShared(int unused)中，有一段代码就是来判读锁降级的：
+  ```JAVA
+  int c = getState();
+  //exclusiveCount(c)计算写锁
+  //如果存在写锁，且锁的持有者不是当前线程，直接返回-1
+  //存在锁降级问题，后续阐述
+  if (exclusiveCount(c) != 0 &&
+          getExclusiveOwnerThread() != current)
+      return -1;
+  //读锁
+  int r = sharedCount(c);
+  ```
+  锁降级中读锁的获取释放为必要？肯定是必要的。试想，假如当前线程A不获取读锁而是直接释放了写锁，这个时候另外一个线程B获取了写锁，那么这个线程B对数据的修改是不会对当前线程A可见的。如果获取了读锁，则线程B在获取写锁过程中判断如果有读锁还没有释放则会被阻塞，只有当前线程A释放读锁后，线程B才会获取写锁成功。
+
+### 参考资料
+Doug Lea：《Java并发编程实战》
+方腾飞：《Java并发编程的艺术》
+【Java并发编程实战】—–“J.U.C”：ReentrantReadWriteLock http://cmsblogs.com/?p=1679
+Java多线程（十）之ReentrantReadWriteLock深入分析 https://my.oschina.net/adan1/blog/158107
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/14 - J.U.C\344\271\213Condition.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/14 - J.U.C\344\271\213Condition.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/14 - J.U.C\344\271\213Condition.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/14 - J.U.C\344\271\213Condition.md"
index b0b6be9a..1943b94d 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/14 - J.U.C\344\271\213Condition.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/14 - J.U.C\344\271\213Condition.md"	
@@ -1,269 +1,269 @@
-  在没有Lock之前，我们使用synchronized来控制同步，配合Object的wait()、notify()系列方法可以实现等待/通知模式。
-
-  在Java SE5后，Java提供了Lock接口，相对于Synchronized而言，**Lock提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活。**
-
-  下图是Condition与Object的监视器方法的对比（摘自《Java并发编程的艺术》）
-  <img src="img/201702060001_thumb.jpg">
-
-  Condition提供了一系列的方法来对阻塞和唤醒线程：
-
-  1. `await()` ：造成当前线程在接到信号或被中断之前一直处于等待状态。
-  2. `await(long time, TimeUnit unit)` ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
-  3. `awaitNanos(long nanosTimeout)` ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在nanosTimesout之前唤醒，那么返回值 = nanosTimeout - 消耗时间，如果返回值 <= 0 ,则可以认定它已经超时了。
-  4. `awaitUninterruptibly()` ：造成当前线程在接到信号之前一直处于等待状态。【注意：该方法对中断不敏感】。
-  5. `awaitUntil(Date deadline)` ：造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知，则返回true，否则表示到了指定时间，返回返回false。
-  6. `signal()`：唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。
-  7. `signal()All`：唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。
-
-
-  Condition是一种广义上的条件队列。他为线程提供了一种更为灵活的等待/通知模式，线程在调用await方法后执行挂起操作，直到线程等待的某个条件为真时才会被唤醒。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。
-
-### Condtion的实现
-  获取一个Condition必须要通过Lock的newCondition()方法。该方法定义在接口Lock下面，返回的结果是绑定到此 Lock 实例的新 Condition 实例。Condition为一个接口，其下仅有一个实现类ConditionObject，由于Condition的操作需要获取相关的锁，而AQS则是同步锁的实现基础，所以ConditionObject则定义为AQS的内部类。定义如下：
-  ```java
-  public class ConditionObject implements Condition, java.io.Serializable {
-  }
-  ```
-#### 等待队列
-  每个Condition对象都包含着一个FIFO队列，该队列是Condition对象通知/等待功能的关键。在队列中每一个节点都包含着一个线程引用，该线程就是在该Condition对象上等待的线程。我们看Condition的定义就明白了：
-  ```java
-  public class ConditionObject implements Condition, java.io.Serializable {
-      private static final long serialVersionUID = 1173984872572414699L;
-
-      //头节点
-      private transient Node firstWaiter;
-      //尾节点
-      private transient Node lastWaiter;
-
-      public ConditionObject() {
-      }
-
-      /** 省略方法 **/
-  }
-  ```
-  从上面代码可以看出Condition拥有首节点（firstWaiter），尾节点（lastWaiter）。当前线程调用await()方法，将会以当前线程构造成一个节点（Node），并将节点加入到该队列的尾部。结构如下：
-
-  <img src="img/201702060002.jpg">
-
-  Node里面包含了当前线程的引用。Node定义与AQS的CLH同步队列的节点使用的都是同一个类（AbstractQueuedSynchronized.Node静态内部类）。
-
-  Condition的队列结构比CLH同步队列的结构简单些，新增过程较为简单只需要将原尾节点的nextWaiter指向新增节点，然后更新lastWaiter即可。
-
-### 等待
-  调用Condition的await()方法会使当前线程进入等待状态，同时会加入到Condition等待队列同时释放锁。当从await()方法返回时，当前线程一定是获取了Condition相关连的锁。
-  ```java
-  public final void await() throws InterruptedException {
-      // 当前线程中断
-      if (Thread.interrupted())
-          throw new InterruptedException();
-      //当前线程加入等待队列
-      Node node = addConditionWaiter();
-      //释放锁
-      long savedState = fullyRelease(node);
-      int interruptMode = 0;
-      /**
-       * 检测此节点的线程是否在同步队上，如果不在，则说明该线程还不具备竞争锁的资格，则继续等待
-       * 直到检测到此节点在同步队列上
-       */
-      while (!isOnSyncQueue(node)) {
-          //线程挂起
-          LockSupport.park(this);
-          //如果已经中断了，则退出
-          if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
-              break;
-      }
-      //竞争同步状态
-      if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
-          interruptMode = REINTERRUPT;
-      //清理下条件队列中的不是在等待条件的节点
-      if (node.nextWaiter != null) // clean up if cancelled
-          unlinkCancelledWaiters();
-      if (interruptMode != 0)
-          reportInterruptAfterWait(interruptMode);
-  }
-  ```
-  此段代码的逻辑是：首先将当前线程新建一个节点同时加入到条件队列中，然后释放当前线程持有的同步状态。然后则是不断检测该节点代表的线程释放出现在CLH同步队列中（收到signal信号之后就会在AQS队列中检测到），如果不存在则一直挂起，否则参与竞争同步状态。
-
-  加入条件队列（addConditionWaiter()）源码如下：
-  ```java
-  private Node addConditionWaiter() {
-      Node t = lastWaiter;    //尾节点
-      //Node的节点状态如果不为CONDITION，则表示该节点不处于等待状态，需要清除节点
-      if (t != null && t.waitStatus != Node.CONDITION) {
-          //清除条件队列中所有状态不为Condition的节点
-          unlinkCancelledWaiters();
-          t = lastWaiter;
-      }
-      //当前线程新建节点，状态CONDITION
-      Node node = new Node(Thread.currentThread(), Node.CONDITION);
-      /**
-       * 将该节点加入到条件队列中最后一个位置
-       */
-      if (t == null)
-          firstWaiter = node;
-      else
-          t.nextWaiter = node;
-      lastWaiter = node;
-      return node;
-  }
-  ```
-  该方法主要是将当前线程加入到Condition条件队列中。当然在加入到尾节点之前会清楚所有状态不为Condition的节点。
-
-  fullyRelease(Node node)，负责释放该线程持有的锁。
-  ```java
-  final long fullyRelease(Node node) {
-      boolean failed = true;
-      try {
-          //节点状态--其实就是持有锁的数量
-          long savedState = getState();
-          //释放锁
-          if (release(savedState)) {
-              failed = false;
-              return savedState;
-          } else {
-              throw new IllegalMonitorStateException();
-          }
-      } finally {
-          if (failed)
-              node.waitStatus = Node.CANCELLED;
-      }
-  }
-  ```
-  isOnSyncQueue(Node node)：如果一个节点刚开始在条件队列上，现在在同步队列上获取锁则返回true
-  ```java
-  final boolean isOnSyncQueue(Node node) {
-      //状态为Condition，获取前驱节点为null，返回false
-      if (node.waitStatus == Node.CONDITION || node.prev == null)
-          return false;
-      //后继节点不为null，肯定在CLH同步队列中
-      if (node.next != null)
-          return true;
-
-      return findNodeFromTail(node);
-  }
-  ```
-  unlinkCancelledWaiters()：负责将条件队列中状态不为Condition的节点删除
-  ```java
-  private void unlinkCancelledWaiters() {
-      Node t = firstWaiter;
-      Node trail = null;
-      while (t != null) {
-          Node next = t.nextWaiter;
-          if (t.waitStatus != Node.CONDITION) {
-              t.nextWaiter = null;
-              if (trail == null)
-                  firstWaiter = next;
-              else
-                  trail.nextWaiter = next;
-              if (next == null)
-                  lastWaiter = trail;
-          }
-          else
-              trail = t;
-          t = next;
-      }
-  }
-  ```
-#### 通知
-  调用Condition的signal()方法，将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点），在唤醒节点前，会将节点移到CLH同步队列中。
-  ```java
-  public final void signal() {
-      //检测当前线程是否为拥有锁的独
-      if (!isHeldExclusively())
-          throw new IllegalMonitorStateException();
-      //头节点，唤醒条件队列中的第一个节点
-      Node first = firstWaiter;
-      if (first != null)
-          doSignal(first);    //唤醒
-  }
-  ```
-  该方法首先会判断当前线程是否已经获得了锁，这是前置条件。然后唤醒条件队列中的头节点。
-
-  doSignal(Node first)：唤醒头节点
-  ```java
-  private void doSignal(Node first) {
-      do {
-          //修改头结点，完成旧头结点的移出工作
-          if ( (firstWaiter = first.nextWaiter) == null)
-              lastWaiter = null;
-          first.nextWaiter = null;
-      } while (!transferForSignal(first) &&
-              (first = firstWaiter) != null);
-  }
-  ```
-  doSignal(Node first)主要是做两件事：1.修改头节点，2.调用transferForSignal(Node first) 方法将节点移动到CLH同步队列中。transferForSignal(Node first)源码如下：
-  ```java
-   final boolean transferForSignal(Node node) {
-      //将该节点从状态CONDITION改变为初始状态0,
-      if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
-          return false;
-
-      //将节点加入到syn队列中去，返回的是syn队列中node节点前面的一个节点
-      Node p = enq(node);
-      int ws = p.waitStatus;
-      //如果结点p的状态为cancel 或者修改waitStatus失败，则直接唤醒
-      if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
-          LockSupport.unpark(node.thread);
-      return true;
-  }
-  ```
-  整个通知的流程如下：
-
-  1. 判断当前线程是否已经获取了锁，如果没有获取则直接抛出异常，因为获取锁为通知的前置条件。
-  2. 如果线程已经获取了锁，则将唤醒条件队列的首节点
-  3. 唤醒首节点是先将条件队列中的头节点移出，然后调用AQS的enq(Node node)方法将其安全地移到CLH同步队列中
-  4. 最后判断如果该节点的同步状态是否为Cancel，或者修改状态为Signal失败时，则直接调用LockSupport唤醒该节点的线程。
-
-#### 总结
-
-  一个线程获取锁后，通过调用Condition的`await()`方法，会将当前线程先加入到条件队列中，然后释放锁，最后通过isOnSyncQueue(Node node)方法不断自检看节点是否已经在CLH同步队列了，如果是则尝试获取锁，否则一直挂起。当线程调用`signal()`方法后，程序首先检查当前线程是否获取了锁，然后通过doSignal(Node first)方法唤醒CLH同步队列的首节点。被唤醒的线程，将从await()方法中的while循环中退出来，然后调用acquireQueued()方法竞争同步状态。
-
-### Condition的应用
-
-  只知道原理，如果不知道使用那就坑爹了，下面是用Condition实现的生产者消费者问题：
-  ```java
-  public class ConditionTest {
-      private LinkedList<String> buffer;    //容器
-      private int maxSize ;           //容器最大
-      private Lock lock;
-      private Condition fullCondition;
-      private Condition notFullCondition;
-
-      ConditionTest(int maxSize){
-          this.maxSize = maxSize;
-          buffer = new LinkedList<String>();
-          lock = new ReentrantLock();
-          fullCondition = lock.newCondition();
-          notFullCondition = lock.newCondition();
-      }
-
-      public void set(String string) throws InterruptedException {
-          lock.lock();    //获取锁
-          try {
-              while (maxSize == buffer.size()){
-                  notFullCondition.await();       //满了，添加的线程进入等待状态
-              }
-
-              buffer.add(string);
-              fullCondition.signal();
-          } finally {
-              lock.unlock();      //记得释放锁
-          }
-      }
-
-      public String get() throws InterruptedException {
-          String string;
-          lock.lock();
-          try {
-              while (buffer.size() == 0){
-                  fullCondition.await();
-              }
-              string = buffer.poll();
-              notFullCondition.signal();
-          } finally {
-              lock.unlock();
-          }
-          return string;
-      }
-  }
-  ```
+  在没有Lock之前，我们使用synchronized来控制同步，配合Object的wait()、notify()系列方法可以实现等待/通知模式。
+
+  在Java SE5后，Java提供了Lock接口，相对于Synchronized而言，**Lock提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活。**
+
+  下图是Condition与Object的监视器方法的对比（摘自《Java并发编程的艺术》）
+  <img src="img/201702060001_thumb.jpg">
+
+  Condition提供了一系列的方法来对阻塞和唤醒线程：
+
+  1. `await()` ：造成当前线程在接到信号或被中断之前一直处于等待状态。
+  2. `await(long time, TimeUnit unit)` ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
+  3. `awaitNanos(long nanosTimeout)` ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在nanosTimesout之前唤醒，那么返回值 = nanosTimeout - 消耗时间，如果返回值 <= 0 ,则可以认定它已经超时了。
+  4. `awaitUninterruptibly()` ：造成当前线程在接到信号之前一直处于等待状态。【注意：该方法对中断不敏感】。
+  5. `awaitUntil(Date deadline)` ：造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知，则返回true，否则表示到了指定时间，返回返回false。
+  6. `signal()`：唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。
+  7. `signal()All`：唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。
+
+
+  Condition是一种广义上的条件队列。他为线程提供了一种更为灵活的等待/通知模式，线程在调用await方法后执行挂起操作，直到线程等待的某个条件为真时才会被唤醒。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。
+
+### Condtion的实现
+  获取一个Condition必须要通过Lock的newCondition()方法。该方法定义在接口Lock下面，返回的结果是绑定到此 Lock 实例的新 Condition 实例。Condition为一个接口，其下仅有一个实现类ConditionObject，由于Condition的操作需要获取相关的锁，而AQS则是同步锁的实现基础，所以ConditionObject则定义为AQS的内部类。定义如下：
+  ```java
+  public class ConditionObject implements Condition, java.io.Serializable {
+  }
+  ```
+#### 等待队列
+  每个Condition对象都包含着一个FIFO队列，该队列是Condition对象通知/等待功能的关键。在队列中每一个节点都包含着一个线程引用，该线程就是在该Condition对象上等待的线程。我们看Condition的定义就明白了：
+  ```java
+  public class ConditionObject implements Condition, java.io.Serializable {
+      private static final long serialVersionUID = 1173984872572414699L;
+
+      //头节点
+      private transient Node firstWaiter;
+      //尾节点
+      private transient Node lastWaiter;
+
+      public ConditionObject() {
+      }
+
+      /** 省略方法 **/
+  }
+  ```
+  从上面代码可以看出Condition拥有首节点（firstWaiter），尾节点（lastWaiter）。当前线程调用await()方法，将会以当前线程构造成一个节点（Node），并将节点加入到该队列的尾部。结构如下：
+
+  <img src="img/201702060002.jpg">
+
+  Node里面包含了当前线程的引用。Node定义与AQS的CLH同步队列的节点使用的都是同一个类（AbstractQueuedSynchronized.Node静态内部类）。
+
+  Condition的队列结构比CLH同步队列的结构简单些，新增过程较为简单只需要将原尾节点的nextWaiter指向新增节点，然后更新lastWaiter即可。
+
+### 等待
+  调用Condition的await()方法会使当前线程进入等待状态，同时会加入到Condition等待队列同时释放锁。当从await()方法返回时，当前线程一定是获取了Condition相关连的锁。
+  ```java
+  public final void await() throws InterruptedException {
+      // 当前线程中断
+      if (Thread.interrupted())
+          throw new InterruptedException();
+      //当前线程加入等待队列
+      Node node = addConditionWaiter();
+      //释放锁
+      long savedState = fullyRelease(node);
+      int interruptMode = 0;
+      /**
+       * 检测此节点的线程是否在同步队上，如果不在，则说明该线程还不具备竞争锁的资格，则继续等待
+       * 直到检测到此节点在同步队列上
+       */
+      while (!isOnSyncQueue(node)) {
+          //线程挂起
+          LockSupport.park(this);
+          //如果已经中断了，则退出
+          if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
+              break;
+      }
+      //竞争同步状态
+      if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
+          interruptMode = REINTERRUPT;
+      //清理下条件队列中的不是在等待条件的节点
+      if (node.nextWaiter != null) // clean up if cancelled
+          unlinkCancelledWaiters();
+      if (interruptMode != 0)
+          reportInterruptAfterWait(interruptMode);
+  }
+  ```
+  此段代码的逻辑是：首先将当前线程新建一个节点同时加入到条件队列中，然后释放当前线程持有的同步状态。然后则是不断检测该节点代表的线程释放出现在CLH同步队列中（收到signal信号之后就会在AQS队列中检测到），如果不存在则一直挂起，否则参与竞争同步状态。
+
+  加入条件队列（addConditionWaiter()）源码如下：
+  ```java
+  private Node addConditionWaiter() {
+      Node t = lastWaiter;    //尾节点
+      //Node的节点状态如果不为CONDITION，则表示该节点不处于等待状态，需要清除节点
+      if (t != null && t.waitStatus != Node.CONDITION) {
+          //清除条件队列中所有状态不为Condition的节点
+          unlinkCancelledWaiters();
+          t = lastWaiter;
+      }
+      //当前线程新建节点，状态CONDITION
+      Node node = new Node(Thread.currentThread(), Node.CONDITION);
+      /**
+       * 将该节点加入到条件队列中最后一个位置
+       */
+      if (t == null)
+          firstWaiter = node;
+      else
+          t.nextWaiter = node;
+      lastWaiter = node;
+      return node;
+  }
+  ```
+  该方法主要是将当前线程加入到Condition条件队列中。当然在加入到尾节点之前会清楚所有状态不为Condition的节点。
+
+  fullyRelease(Node node)，负责释放该线程持有的锁。
+  ```java
+  final long fullyRelease(Node node) {
+      boolean failed = true;
+      try {
+          //节点状态--其实就是持有锁的数量
+          long savedState = getState();
+          //释放锁
+          if (release(savedState)) {
+              failed = false;
+              return savedState;
+          } else {
+              throw new IllegalMonitorStateException();
+          }
+      } finally {
+          if (failed)
+              node.waitStatus = Node.CANCELLED;
+      }
+  }
+  ```
+  isOnSyncQueue(Node node)：如果一个节点刚开始在条件队列上，现在在同步队列上获取锁则返回true
+  ```java
+  final boolean isOnSyncQueue(Node node) {
+      //状态为Condition，获取前驱节点为null，返回false
+      if (node.waitStatus == Node.CONDITION || node.prev == null)
+          return false;
+      //后继节点不为null，肯定在CLH同步队列中
+      if (node.next != null)
+          return true;
+
+      return findNodeFromTail(node);
+  }
+  ```
+  unlinkCancelledWaiters()：负责将条件队列中状态不为Condition的节点删除
+  ```java
+  private void unlinkCancelledWaiters() {
+      Node t = firstWaiter;
+      Node trail = null;
+      while (t != null) {
+          Node next = t.nextWaiter;
+          if (t.waitStatus != Node.CONDITION) {
+              t.nextWaiter = null;
+              if (trail == null)
+                  firstWaiter = next;
+              else
+                  trail.nextWaiter = next;
+              if (next == null)
+                  lastWaiter = trail;
+          }
+          else
+              trail = t;
+          t = next;
+      }
+  }
+  ```
+#### 通知
+  调用Condition的signal()方法，将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点），在唤醒节点前，会将节点移到CLH同步队列中。
+  ```java
+  public final void signal() {
+      //检测当前线程是否为拥有锁的独
+      if (!isHeldExclusively())
+          throw new IllegalMonitorStateException();
+      //头节点，唤醒条件队列中的第一个节点
+      Node first = firstWaiter;
+      if (first != null)
+          doSignal(first);    //唤醒
+  }
+  ```
+  该方法首先会判断当前线程是否已经获得了锁，这是前置条件。然后唤醒条件队列中的头节点。
+
+  doSignal(Node first)：唤醒头节点
+  ```java
+  private void doSignal(Node first) {
+      do {
+          //修改头结点，完成旧头结点的移出工作
+          if ( (firstWaiter = first.nextWaiter) == null)
+              lastWaiter = null;
+          first.nextWaiter = null;
+      } while (!transferForSignal(first) &&
+              (first = firstWaiter) != null);
+  }
+  ```
+  doSignal(Node first)主要是做两件事：1.修改头节点，2.调用transferForSignal(Node first) 方法将节点移动到CLH同步队列中。transferForSignal(Node first)源码如下：
+  ```java
+   final boolean transferForSignal(Node node) {
+      //将该节点从状态CONDITION改变为初始状态0,
+      if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
+          return false;
+
+      //将节点加入到syn队列中去，返回的是syn队列中node节点前面的一个节点
+      Node p = enq(node);
+      int ws = p.waitStatus;
+      //如果结点p的状态为cancel 或者修改waitStatus失败，则直接唤醒
+      if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
+          LockSupport.unpark(node.thread);
+      return true;
+  }
+  ```
+  整个通知的流程如下：
+
+  1. 判断当前线程是否已经获取了锁，如果没有获取则直接抛出异常，因为获取锁为通知的前置条件。
+  2. 如果线程已经获取了锁，则将唤醒条件队列的首节点
+  3. 唤醒首节点是先将条件队列中的头节点移出，然后调用AQS的enq(Node node)方法将其安全地移到CLH同步队列中
+  4. 最后判断如果该节点的同步状态是否为Cancel，或者修改状态为Signal失败时，则直接调用LockSupport唤醒该节点的线程。
+
+#### 总结
+
+  一个线程获取锁后，通过调用Condition的`await()`方法，会将当前线程先加入到条件队列中，然后释放锁，最后通过isOnSyncQueue(Node node)方法不断自检看节点是否已经在CLH同步队列了，如果是则尝试获取锁，否则一直挂起。当线程调用`signal()`方法后，程序首先检查当前线程是否获取了锁，然后通过doSignal(Node first)方法唤醒CLH同步队列的首节点。被唤醒的线程，将从await()方法中的while循环中退出来，然后调用acquireQueued()方法竞争同步状态。
+
+### Condition的应用
+
+  只知道原理，如果不知道使用那就坑爹了，下面是用Condition实现的生产者消费者问题：
+  ```java
+  public class ConditionTest {
+      private LinkedList<String> buffer;    //容器
+      private int maxSize ;           //容器最大
+      private Lock lock;
+      private Condition fullCondition;
+      private Condition notFullCondition;
+
+      ConditionTest(int maxSize){
+          this.maxSize = maxSize;
+          buffer = new LinkedList<String>();
+          lock = new ReentrantLock();
+          fullCondition = lock.newCondition();
+          notFullCondition = lock.newCondition();
+      }
+
+      public void set(String string) throws InterruptedException {
+          lock.lock();    //获取锁
+          try {
+              while (maxSize == buffer.size()){
+                  notFullCondition.await();       //满了，添加的线程进入等待状态
+              }
+
+              buffer.add(string);
+              fullCondition.signal();
+          } finally {
+              lock.unlock();      //记得释放锁
+          }
+      }
+
+      public String get() throws InterruptedException {
+          String string;
+          lock.lock();
+          try {
+              while (buffer.size() == 0){
+                  fullCondition.await();
+              }
+              string = buffer.poll();
+              notFullCondition.signal();
+          } finally {
+              lock.unlock();
+          }
+          return string;
+      }
+  }
+  ```
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/15 - \346\267\261\345\205\245\345\210\206\346\236\220CAS Aotmic\347\261\273.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/15 - \346\267\261\345\205\245\345\210\206\346\236\220CAS Aotmic\347\261\273.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/15 - \346\267\261\345\205\245\345\210\206\346\236\220CAS Aotmic\347\261\273.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/15 - \346\267\261\345\205\245\345\210\206\346\236\220CAS Aotmic\347\261\273.md"
index 8094e0b5..910b215d 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/15 - \346\267\261\345\205\245\345\210\206\346\236\220CAS Aotmic\347\261\273.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/15 - \346\267\261\345\205\245\345\210\206\346\236\220CAS Aotmic\347\261\273.md"	
@@ -1,231 +1,231 @@
-CAS，**Compare And Swap**，即比较并交换。Doug lea大神在同步组件中大量使用CAS技术鬼斧神工地实现了Java多线程的并发操作。
-整个`AQS同步组件`、`Atomic原子类`操作等等都是以CAS实现的，甚至ConcurrentHashMap在1.8的版本中也调整为了CAS+Synchronized。可以说CAS是整个JUC的基石。
-<img src="img/201703090001_thumb.png">
-
-### CAS分析
-  在CAS中有三个参数：内存值V、旧的预期值A、要更新的值B，当且仅当内存值V的值等于旧的预期值A时才会将内存值V的值修改为B，否则什么都不干。其伪代码如下：
-  ```java
-  if(this.value == A){
-  	this.value = B
-  	return true;
-  }else{
-  	return false;
-  }
-  ```
-  JUC下的atomic类都是通过CAS来实现的，下面就以AtomicInteger为例来阐述CAS的实现。如下：
-  ```java
-  private static final Unsafe unsafe = Unsafe.getUnsafe();
-  private static final long valueOffset;
-
-  static {
-      try {
-          valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
-      } catch (Exception ex) {
-          throw new Error(ex);
-      }
-  }
-
-  private volatile int value;
-  ```
-  `Unsafe`是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，JVM还是开了一个后门：`Unsafe`，它提供了硬件级别的原子操作。
-
-  `valueOffset`为变量值在内存中的偏移地址，unsafe就是通过偏移地址来得到数据的原值的。
-
-  `value`当前值，使用volatile修饰，保证多线程环境下看见的是同一个。
-
-  我们就以AtomicInteger的addAndGet()方法来做说明，先看源代码：
-  ```java
-  public final int addAndGet(int delta) {
-      return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
-  }
-
-  public final int getAndAddInt(Object var1, long var2, int var4) {
-      int var5;
-      do {
-          var5 = this.getIntVolatile(var1, var2);
-      } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
-
-      return var5;
-  }
-  ```
-  内部调用unsafe的getAndAddInt方法，在getAndAddInt方法中主要是看compareAndSwapInt方法：
-  ```java
-  public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
-  ```
-  该方法为本地方法，有四个参数，分别代表：`对象`、`对象的地址`、`预期值`、`修改值`（有位伙伴告诉我他面试的时候就问到这四个变量是啥意思… +_ +）。该方法的实现这里就不做详细介绍了，有兴趣的伙伴可以看看openjdk的源码。
-
-  CAS可以保证一次的`读-改-写`操作是原子操作，在单处理器上该操作容易实现，但是在多处理器上实现就有点儿复杂了。
-
-  CPU提供了两种方法来实现多处理器的原子操作：`总线加锁`或者`缓存加锁`。
-
-  总线加锁：总线加锁就是就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住,那么该处理器可以独占使用共享内存。但是这种处理方式显得有点儿霸道，不厚道，他把CPU和内存之间的通信锁住了，在锁定期间，其他处理器都不能其他内存地址的数据，其开销有点儿大。所以就有了缓存加锁。
-
-  缓存加锁：其实针对于上面那种情况我们只需要保证在同一时刻对某个内存地址的操作是原子性的即可。缓存加锁就是缓存在内存区域的数据如果在加锁期间，当它执行锁操作写回内存时，处理器不在输出LOCK#信号，而是修改内部的内存地址，利用缓存一致性协议来保证原子性。缓存一致性机制可以保证同一个内存区域的数据仅能被一个处理器修改，也就是说当CPU1修改缓存行中的i时使用缓存锁定，那么CPU2就不能同时缓存了i的缓存行。
-
-### CAS缺陷
-
-  CAS虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方法：循环时间太长、只能保证一个共享变量原子操作、ABA问题。
-
-  **循环时间太长**
-
-  如果CAS一直不成功呢？这种情况绝对有可能发生，如果自旋CAS长时间地不成功，则会给CPU带来非常大的开销。在JUC中有些地方就限制了CAS自旋的次数，例如BlockingQueue的SynchronousQueue。
-
-  **只能保证一个共享变量原子操作**
-
-  看了CAS的实现就知道这只能针对一个共享变量，如果是多个共享变量就只能使用锁了，当然如果你有办法把多个变量整成一个变量，利用CAS也不错。例如读写锁中state的高地位
-
-  **ABA问题**
-
-  CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —> B —> A，变成1A —> 2B —> 3A。
-
-  用一个例子来阐述ABA问题所带来的影响。
-
-  有如下链表
-  <img src="img/201703090002_thumb.png">
-
-  假如我们想要把B替换为A，也就是compareAndSet(this,A,B)。线程1执行B替换A操作，线程2主要执行如下动作，A 、B出栈，然后C、A入栈，最终该链表如下：
-
-  <img src="img/201703090003_thumb.png">
-
-  完成后线程1发现仍然是A，那么compareAndSet(this,A,B)成功，但是这时会存在一个问题就是B.next = null,compareAndSet(this,A,B)后，会导致C丢失，改栈仅有一个B元素，平白无故把C给丢失了。
-
-  CAS的ABA隐患问题，解决方案则是版本号，Java提供了AtomicStampedReference来解决。AtomicStampedReference通过包装[E,Integer]的元组来对对象标记版本戳stamp，从而避免ABA问题。对于上面的案例应该线程1会失败。
-
-  AtomicStampedReference的compareAndSet()方法定义如下：
-  ```java
-  public boolean compareAndSet(V   expectedReference,
-                               V   newReference,
-                               int expectedStamp,
-                               int newStamp) {
-      Pair<V> current = pair;
-      return
-          expectedReference == current.reference &&
-          expectedStamp == current.stamp &&
-          ((newReference == current.reference &&
-            newStamp == current.stamp) ||
-           casPair(current, Pair.of(newReference, newStamp)));
-  }
-  ```
-  compareAndSet有四个参数，分别表示：预期引用、更新后的引用、预期标志、更新后的标志。源码部门很好理解预期的引用 == 当前引用，预期的标识 == 当前标识，如果更新后的引用和标志和当前的引用和标志相等则直接返回true，否则通过Pair生成一个新的pair对象与当前pair CAS替换。Pair为AtomicStampedReference的内部类，主要用于记录引用和版本戳信息（标识），定义如下：
-  ```java
-  private static class Pair<T> {
-      final T reference;
-      final int stamp;
-      private Pair(T reference, int stamp) {
-          this.reference = reference;
-          this.stamp = stamp;
-      }
-      static <T> Pair<T> of(T reference, int stamp) {
-          return new Pair<T>(reference, stamp);
-      }
-  }
-
-  private volatile Pair<V> pair;
-  ```
-  Pair记录着对象的引用和版本戳，版本戳为int型，保持自增。同时Pair是一个不可变对象，其所有属性全部定义为final，对外提供一个of方法，该方法返回一个新建的Pari对象。pair对象定义为volatile，保证多线程环境下的可见性。在AtomicStampedReference中，大多方法都是通过调用Pair的of方法来产生一个新的Pair对象，然后赋值给变量pair。如set方法：
-  ```java
-  public void set(V newReference, int newStamp) {
-      Pair<V> current = pair;
-      if (newReference != current.reference || newStamp != current.stamp)
-          this.pair = Pair.of(newReference, newStamp);
-  }
-  ```
-  下面我们将通过一个例子可以可以看到AtomicStampedReference和AtomicInteger的区别。我们定义两个线程，线程1负责将100 —> 110 —> 100，线程2执行 100 —>120，看两者之间的区别。
-  ```java
-  public class Test {
-      private static AtomicInteger atomicInteger = new AtomicInteger(100);
-      private static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(100,1);
-
-      public static void main(String[] args) throws InterruptedException {
-
-          //AtomicInteger
-          Thread at1 = new Thread(new Runnable() {
-              @Override
-              public void run() {
-                  atomicInteger.compareAndSet(100,110);
-                  atomicInteger.compareAndSet(110,100);
-              }
-          });
-
-          Thread at2 = new Thread(new Runnable() {
-              @Override
-              public void run() {
-                  try {
-                      TimeUnit.SECONDS.sleep(2);      // at1,执行完
-                  } catch (InterruptedException e) {
-                      e.printStackTrace();
-                  }
-                  System.out.println("AtomicInteger:" + atomicInteger.compareAndSet(100,120));
-              }
-          });
-
-          at1.start();
-          at2.start();
-
-          at1.join();
-          at2.join();
-
-          //AtomicStampedReference
-
-          Thread tsf1 = new Thread(new Runnable() {
-              @Override
-              public void run() {
-                  try {
-                      //让 tsf2先获取stamp，导致预期时间戳不一致
-                      TimeUnit.SECONDS.sleep(2);
-                  } catch (InterruptedException e) {
-                      e.printStackTrace();
-                  }
-                  // 预期引用：100，更新后的引用：110，预期标识getStamp() 更新后的标识getStamp() + 1
-                  atomicStampedReference.compareAndSet(100,110,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
-                  atomicStampedReference.compareAndSet(110,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
-              }
-          });
-
-          Thread tsf2 = new Thread(new Runnable() {
-              @Override
-              public void run() {
-                  int stamp = atomicStampedReference.getStamp();
-
-                  try {
-                      TimeUnit.SECONDS.sleep(2);      //线程tsf1执行完
-                  } catch (InterruptedException e) {
-                      e.printStackTrace();
-                  }
-                  System.out.println("AtomicStampedReference:" +atomicStampedReference.compareAndSet(100,120,stamp,stamp + 1));
-              }
-          });
-
-          tsf1.start();
-          tsf2.start();
-      }
-
-  }
-  ```
-  运行结果：
-
-    <img src="img/201703090004_2_thumb.jpg">
-
-  运行结果充分展示了AtomicInteger的ABA问题和AtomicStampedReference解决ABA问题。
-
-### Atomic
-
-基本类型 通过原子的方式更新基本类型
- AtomicBoolean
- AtomicInteger
- AtomicLong
-
-数组 通过原子的方式更新数组里的某个元素
-  AtomicIntegerArray
-  AtomicLongArray
-  AtomicReferenceArray
-
-引用类型 如果要原子的更新多个变量，就需要使用这个原子更新引用类型提供的类
-  AtomicReference
-  AtomicReferenceFiledUpdater
-  AtomicMarkableReference
-
-字段类 我们只需要更新某个类里的某个字段，那么需要使用原子更新字段类
-  AtomicIntegerFiledUpdater
-  AtomicLongFiledUpdater
-  AtomicStampedReference
+CAS，**Compare And Swap**，即比较并交换。Doug lea大神在同步组件中大量使用CAS技术鬼斧神工地实现了Java多线程的并发操作。
+整个`AQS同步组件`、`Atomic原子类`操作等等都是以CAS实现的，甚至ConcurrentHashMap在1.8的版本中也调整为了CAS+Synchronized。可以说CAS是整个JUC的基石。
+<img src="img/201703090001_thumb.png">
+
+### CAS分析
+  在CAS中有三个参数：内存值V、旧的预期值A、要更新的值B，当且仅当内存值V的值等于旧的预期值A时才会将内存值V的值修改为B，否则什么都不干。其伪代码如下：
+  ```java
+  if(this.value == A){
+  	this.value = B
+  	return true;
+  }else{
+  	return false;
+  }
+  ```
+  JUC下的atomic类都是通过CAS来实现的，下面就以AtomicInteger为例来阐述CAS的实现。如下：
+  ```java
+  private static final Unsafe unsafe = Unsafe.getUnsafe();
+  private static final long valueOffset;
+
+  static {
+      try {
+          valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
+      } catch (Exception ex) {
+          throw new Error(ex);
+      }
+  }
+
+  private volatile int value;
+  ```
+  `Unsafe`是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，JVM还是开了一个后门：`Unsafe`，它提供了硬件级别的原子操作。
+
+  `valueOffset`为变量值在内存中的偏移地址，unsafe就是通过偏移地址来得到数据的原值的。
+
+  `value`当前值，使用volatile修饰，保证多线程环境下看见的是同一个。
+
+  我们就以AtomicInteger的addAndGet()方法来做说明，先看源代码：
+  ```java
+  public final int addAndGet(int delta) {
+      return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
+  }
+
+  public final int getAndAddInt(Object var1, long var2, int var4) {
+      int var5;
+      do {
+          var5 = this.getIntVolatile(var1, var2);
+      } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+
+      return var5;
+  }
+  ```
+  内部调用unsafe的getAndAddInt方法，在getAndAddInt方法中主要是看compareAndSwapInt方法：
+  ```java
+  public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
+  ```
+  该方法为本地方法，有四个参数，分别代表：`对象`、`对象的地址`、`预期值`、`修改值`（有位伙伴告诉我他面试的时候就问到这四个变量是啥意思… +_ +）。该方法的实现这里就不做详细介绍了，有兴趣的伙伴可以看看openjdk的源码。
+
+  CAS可以保证一次的`读-改-写`操作是原子操作，在单处理器上该操作容易实现，但是在多处理器上实现就有点儿复杂了。
+
+  CPU提供了两种方法来实现多处理器的原子操作：`总线加锁`或者`缓存加锁`。
+
+  总线加锁：总线加锁就是就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住,那么该处理器可以独占使用共享内存。但是这种处理方式显得有点儿霸道，不厚道，他把CPU和内存之间的通信锁住了，在锁定期间，其他处理器都不能其他内存地址的数据，其开销有点儿大。所以就有了缓存加锁。
+
+  缓存加锁：其实针对于上面那种情况我们只需要保证在同一时刻对某个内存地址的操作是原子性的即可。缓存加锁就是缓存在内存区域的数据如果在加锁期间，当它执行锁操作写回内存时，处理器不在输出LOCK#信号，而是修改内部的内存地址，利用缓存一致性协议来保证原子性。缓存一致性机制可以保证同一个内存区域的数据仅能被一个处理器修改，也就是说当CPU1修改缓存行中的i时使用缓存锁定，那么CPU2就不能同时缓存了i的缓存行。
+
+### CAS缺陷
+
+  CAS虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方法：循环时间太长、只能保证一个共享变量原子操作、ABA问题。
+
+  **循环时间太长**
+
+  如果CAS一直不成功呢？这种情况绝对有可能发生，如果自旋CAS长时间地不成功，则会给CPU带来非常大的开销。在JUC中有些地方就限制了CAS自旋的次数，例如BlockingQueue的SynchronousQueue。
+
+  **只能保证一个共享变量原子操作**
+
+  看了CAS的实现就知道这只能针对一个共享变量，如果是多个共享变量就只能使用锁了，当然如果你有办法把多个变量整成一个变量，利用CAS也不错。例如读写锁中state的高地位
+
+  **ABA问题**
+
+  CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —> B —> A，变成1A —> 2B —> 3A。
+
+  用一个例子来阐述ABA问题所带来的影响。
+
+  有如下链表
+  <img src="img/201703090002_thumb.png">
+
+  假如我们想要把B替换为A，也就是compareAndSet(this,A,B)。线程1执行B替换A操作，线程2主要执行如下动作，A 、B出栈，然后C、A入栈，最终该链表如下：
+
+  <img src="img/201703090003_thumb.png">
+
+  完成后线程1发现仍然是A，那么compareAndSet(this,A,B)成功，但是这时会存在一个问题就是B.next = null,compareAndSet(this,A,B)后，会导致C丢失，改栈仅有一个B元素，平白无故把C给丢失了。
+
+  CAS的ABA隐患问题，解决方案则是版本号，Java提供了AtomicStampedReference来解决。AtomicStampedReference通过包装[E,Integer]的元组来对对象标记版本戳stamp，从而避免ABA问题。对于上面的案例应该线程1会失败。
+
+  AtomicStampedReference的compareAndSet()方法定义如下：
+  ```java
+  public boolean compareAndSet(V   expectedReference,
+                               V   newReference,
+                               int expectedStamp,
+                               int newStamp) {
+      Pair<V> current = pair;
+      return
+          expectedReference == current.reference &&
+          expectedStamp == current.stamp &&
+          ((newReference == current.reference &&
+            newStamp == current.stamp) ||
+           casPair(current, Pair.of(newReference, newStamp)));
+  }
+  ```
+  compareAndSet有四个参数，分别表示：预期引用、更新后的引用、预期标志、更新后的标志。源码部门很好理解预期的引用 == 当前引用，预期的标识 == 当前标识，如果更新后的引用和标志和当前的引用和标志相等则直接返回true，否则通过Pair生成一个新的pair对象与当前pair CAS替换。Pair为AtomicStampedReference的内部类，主要用于记录引用和版本戳信息（标识），定义如下：
+  ```java
+  private static class Pair<T> {
+      final T reference;
+      final int stamp;
+      private Pair(T reference, int stamp) {
+          this.reference = reference;
+          this.stamp = stamp;
+      }
+      static <T> Pair<T> of(T reference, int stamp) {
+          return new Pair<T>(reference, stamp);
+      }
+  }
+
+  private volatile Pair<V> pair;
+  ```
+  Pair记录着对象的引用和版本戳，版本戳为int型，保持自增。同时Pair是一个不可变对象，其所有属性全部定义为final，对外提供一个of方法，该方法返回一个新建的Pari对象。pair对象定义为volatile，保证多线程环境下的可见性。在AtomicStampedReference中，大多方法都是通过调用Pair的of方法来产生一个新的Pair对象，然后赋值给变量pair。如set方法：
+  ```java
+  public void set(V newReference, int newStamp) {
+      Pair<V> current = pair;
+      if (newReference != current.reference || newStamp != current.stamp)
+          this.pair = Pair.of(newReference, newStamp);
+  }
+  ```
+  下面我们将通过一个例子可以可以看到AtomicStampedReference和AtomicInteger的区别。我们定义两个线程，线程1负责将100 —> 110 —> 100，线程2执行 100 —>120，看两者之间的区别。
+  ```java
+  public class Test {
+      private static AtomicInteger atomicInteger = new AtomicInteger(100);
+      private static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(100,1);
+
+      public static void main(String[] args) throws InterruptedException {
+
+          //AtomicInteger
+          Thread at1 = new Thread(new Runnable() {
+              @Override
+              public void run() {
+                  atomicInteger.compareAndSet(100,110);
+                  atomicInteger.compareAndSet(110,100);
+              }
+          });
+
+          Thread at2 = new Thread(new Runnable() {
+              @Override
+              public void run() {
+                  try {
+                      TimeUnit.SECONDS.sleep(2);      // at1,执行完
+                  } catch (InterruptedException e) {
+                      e.printStackTrace();
+                  }
+                  System.out.println("AtomicInteger:" + atomicInteger.compareAndSet(100,120));
+              }
+          });
+
+          at1.start();
+          at2.start();
+
+          at1.join();
+          at2.join();
+
+          //AtomicStampedReference
+
+          Thread tsf1 = new Thread(new Runnable() {
+              @Override
+              public void run() {
+                  try {
+                      //让 tsf2先获取stamp，导致预期时间戳不一致
+                      TimeUnit.SECONDS.sleep(2);
+                  } catch (InterruptedException e) {
+                      e.printStackTrace();
+                  }
+                  // 预期引用：100，更新后的引用：110，预期标识getStamp() 更新后的标识getStamp() + 1
+                  atomicStampedReference.compareAndSet(100,110,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
+                  atomicStampedReference.compareAndSet(110,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
+              }
+          });
+
+          Thread tsf2 = new Thread(new Runnable() {
+              @Override
+              public void run() {
+                  int stamp = atomicStampedReference.getStamp();
+
+                  try {
+                      TimeUnit.SECONDS.sleep(2);      //线程tsf1执行完
+                  } catch (InterruptedException e) {
+                      e.printStackTrace();
+                  }
+                  System.out.println("AtomicStampedReference:" +atomicStampedReference.compareAndSet(100,120,stamp,stamp + 1));
+              }
+          });
+
+          tsf1.start();
+          tsf2.start();
+      }
+
+  }
+  ```
+  运行结果：
+
+    <img src="img/201703090004_2_thumb.jpg">
+
+  运行结果充分展示了AtomicInteger的ABA问题和AtomicStampedReference解决ABA问题。
+
+### Atomic
+
+基本类型 通过原子的方式更新基本类型
+ AtomicBoolean
+ AtomicInteger
+ AtomicLong
+
+数组 通过原子的方式更新数组里的某个元素
+  AtomicIntegerArray
+  AtomicLongArray
+  AtomicReferenceArray
+
+引用类型 如果要原子的更新多个变量，就需要使用这个原子更新引用类型提供的类
+  AtomicReference
+  AtomicReferenceFiledUpdater
+  AtomicMarkableReference
+
+字段类 我们只需要更新某个类里的某个字段，那么需要使用原子更新字段类
+  AtomicIntegerFiledUpdater
+  AtomicLongFiledUpdater
+  AtomicStampedReference
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/16 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CyclicBarrier.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/16 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CyclicBarrier.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/16 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CyclicBarrier.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/16 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CyclicBarrier.md"
index 4114846a..28d72238 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/16 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CyclicBarrier.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/16 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CyclicBarrier.md"	
@@ -1,208 +1,208 @@
-  CyclicBarrier，一个同步辅助类，在API中是这么介绍的：
-
-  **它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。**
-
-  通俗点讲就是：让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
-
-  实现分析
-  CyclicBarrier的结构如下：
-  <img src="img/201702100001_thumb.jpg">
-
-  通过上图我们可以看到 **CyclicBarrier的底层是使用重入锁ReentrantLock和Condition。** 它有两个构造函数：
-
-  * CyclicBarrier(int parties)：创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在启动 barrier 时执行预定义的操作。
-
-  * CyclicBarrier(int parties, Runnable barrierAction) ：创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。
-
-  parties表示拦截线程的数量。
-
-  barrierAction 为CyclicBarrier接收的Runnable命令，用于在线程到达屏障时，优先执行barrierAction ，用于处理更加复杂的业务场景。
-  ```java
-  public CyclicBarrier(int parties, Runnable barrierAction) {
-      if (parties <= 0) throw new IllegalArgumentException();
-      this.parties = parties;
-      this.count = parties;
-      this.barrierCommand = barrierAction;
-  }
-
-  public CyclicBarrier(int parties) {
-      this(parties, null);
-  }
-  ```
-  在CyclicBarrier中最重要的方法莫过于await()方法，在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。如下：
-  ```java
-  public int await() throws InterruptedException, BrokenBarrierException {
-      try {
-          return dowait(false, 0L);//不超时等待
-      } catch (TimeoutException toe) {
-          throw new Error(toe); // cannot happen
-      }
-  }
-  ```
-  await()方法内部调用dowait(boolean timed, long nanos)方法：
-  ```java
-  private int dowait(boolean timed, long nanos)
-          throws InterruptedException, BrokenBarrierException,
-          TimeoutException {
-      //获取锁
-      final ReentrantLock lock = this.lock;
-      lock.lock();
-      try {
-          //分代
-          final Generation g = generation;
-
-          //当前generation“已损坏”，抛出BrokenBarrierException异常
-          //抛出该异常一般都是某个线程在等待某个处于“断开”状态的CyclicBarrie
-          if (g.broken)
-              //当某个线程试图等待处于断开状态的 barrier 时，或者 barrier 进入断开状态而线程处于等待状态时，抛出该异常
-              throw new BrokenBarrierException();
-
-          //如果线程中断，终止CyclicBarrier
-          if (Thread.interrupted()) {
-              breakBarrier();
-              throw new InterruptedException();
-          }
-
-          //进来一个线程 count - 1
-          int index = --count;
-          //count == 0 表示所有线程均已到位，触发Runnable任务
-          if (index == 0) {  // tripped
-              boolean ranAction = false;
-              try {
-                  final Runnable command = barrierCommand;
-                  //触发任务
-                  if (command != null)
-                      command.run();
-                  ranAction = true;
-                  //唤醒所有等待线程，并更新generation
-                  nextGeneration();
-                  return 0;
-              } finally {
-                  if (!ranAction)
-                      breakBarrier();
-              }
-          }
-
-
-          for (;;) {
-              try {
-                  //如果不是超时等待，则调用Condition.await()方法等待
-                  if (!timed)
-                      trip.await();
-                  else if (nanos > 0L)
-                      //超时等待，调用Condition.awaitNanos()方法等待
-                      nanos = trip.awaitNanos(nanos);
-              } catch (InterruptedException ie) {
-                  if (g == generation && ! g.broken) {
-                      breakBarrier();
-                      throw ie;
-                  } else {
-                      // We're about to finish waiting even if we had not
-                      // been interrupted, so this interrupt is deemed to
-                      // "belong" to subsequent execution.
-                      Thread.currentThread().interrupt();
-                  }
-              }
-
-              if (g.broken)
-                  throw new BrokenBarrierException();
-
-              //generation已经更新，返回index
-              if (g != generation)
-                  return index;
-
-              //“超时等待”，并且时间已到,终止CyclicBarrier，并抛出异常
-              if (timed && nanos <= 0L) {
-                  breakBarrier();
-                  throw new TimeoutException();
-              }
-          }
-      } finally {
-          //释放锁
-          lock.unlock();
-      }
-  }
-  ```
-  其实await()的处理逻辑还是比较简单的：如果该线程不是到达的最后一个线程，则他会一直处于等待状态，除非发生以下情况：
-
-  1. 最后一个线程到达，即index == 0
-  2. 超出了指定时间（超时等待）
-  3. 其他的某个线程中断当前线程
-  4. 其他的某个线程中断另一个等待的线程
-  5. 其他的某个线程在等待barrier超时
-  6. 其他的某个线程在此barrier调用reset()方法。reset()方法用于将屏障重置为初始状态。
-
-
-  在上面的源代码中，我们可能需要注意Generation 对象，在上述代码中我们总是可以看到抛出BrokenBarrierException异常，那么什么时候抛出异常呢？如果一个线程处于等待状态时，如果其他线程调用reset()，或者调用的barrier原本就是被损坏的，则抛出BrokenBarrierException异常。同时，任何线程在等待时被中断了，则其他所有线程都将抛出BrokenBarrierException异常，并将barrier置于损坏状态。
-
-  同时，Generation描述着CyclicBarrier的更显换代。在CyclicBarrier中，同一批线程属于同一代。当有parties个线程到达barrier，generation就会被更新换代。其中broken标识该当前CyclicBarrier是否已经处于中断状态。
-  ```java
-  private static class Generation {
-        boolean broken = false;
-  }
-  ```
-  默认barrier是没有损坏的。
-
-  当barrier损坏了或者有一个线程中断了，则通过breakBarrier()来终止所有的线程：
-  ```java
-  private void breakBarrier() {
-       generation.broken = true;
-       count = parties;
-       trip.signalAll();
-  }
-  ```
-  在breakBarrier()中除了将broken设置为true，还会调用signalAll将在CyclicBarrier处于等待状态的线程全部唤醒。
-
-  当所有线程都已经到达barrier处（index == 0），则会通过nextGeneration()进行更新换地操作，在这个步骤中，做了三件事：唤醒所有线程，重置count，generation。
-  ```java
-  private void nextGeneration() {
-      trip.signalAll();
-      count = parties;
-      generation = new Generation();
-  }
-  ```
-  CyclicBarrier同时也提供了await(long timeout, TimeUnit unit) 方法来做超时控制，内部还是通过调用doawait()实现的。
-### 总结
-
-  CyclicBarrier parties参数，await()等到parties个线程都执行后再获取到锁。
-
-### 应用场景
-
-  **CyclicBarrier试用于多线程结果合并的操作，用于多线程计算数据，最后合并计算结果的应用场景。** 比如我们需要统计多个Excel中的数据，然后等到一个总结果。我们可以通过多线程处理每一个Excel，执行完成后得到相应的结果，最后通过barrierAction来计算这些线程的计算结果，得到所有Excel的总和。
-
-  应用示例
-  比如我们开会只有等所有的人到齐了才会开会，如下：
-  ```java
-  public class CyclicBarrierTest {
-
-      private static CyclicBarrier cyclicBarrier;
-
-      static class CyclicBarrierThread extends Thread{
-          public void run() {
-              System.out.println(Thread.currentThread().getName() + "到了");
-              //等待
-              try {
-                  cyclicBarrier.await();
-              } catch (Exception e) {
-                  e.printStackTrace();
-              }
-          }
-      }
-
-      public static void main(String[] args){
-
-          cyclicBarrier = new CyclicBarrier(5, new Runnable() {
-              @Override
-              public void run() {
-                  System.out.println("人到齐了，开会吧....");
-              }
-          });
-
-          for(int i = 0 ; i < 5 ; i++){
-              new CyclicBarrierThread().start();
-          }
-      }
-  }
-  ```
-运行结果：
-<img src="img/201702110001_2.jpg">
+  CyclicBarrier，一个同步辅助类，在API中是这么介绍的：
+
+  **它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。**
+
+  通俗点讲就是：让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
+
+  实现分析
+  CyclicBarrier的结构如下：
+  <img src="img/201702100001_thumb.jpg">
+
+  通过上图我们可以看到 **CyclicBarrier的底层是使用重入锁ReentrantLock和Condition。** 它有两个构造函数：
+
+  * CyclicBarrier(int parties)：创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在启动 barrier 时执行预定义的操作。
+
+  * CyclicBarrier(int parties, Runnable barrierAction) ：创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。
+
+  parties表示拦截线程的数量。
+
+  barrierAction 为CyclicBarrier接收的Runnable命令，用于在线程到达屏障时，优先执行barrierAction ，用于处理更加复杂的业务场景。
+  ```java
+  public CyclicBarrier(int parties, Runnable barrierAction) {
+      if (parties <= 0) throw new IllegalArgumentException();
+      this.parties = parties;
+      this.count = parties;
+      this.barrierCommand = barrierAction;
+  }
+
+  public CyclicBarrier(int parties) {
+      this(parties, null);
+  }
+  ```
+  在CyclicBarrier中最重要的方法莫过于await()方法，在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。如下：
+  ```java
+  public int await() throws InterruptedException, BrokenBarrierException {
+      try {
+          return dowait(false, 0L);//不超时等待
+      } catch (TimeoutException toe) {
+          throw new Error(toe); // cannot happen
+      }
+  }
+  ```
+  await()方法内部调用dowait(boolean timed, long nanos)方法：
+  ```java
+  private int dowait(boolean timed, long nanos)
+          throws InterruptedException, BrokenBarrierException,
+          TimeoutException {
+      //获取锁
+      final ReentrantLock lock = this.lock;
+      lock.lock();
+      try {
+          //分代
+          final Generation g = generation;
+
+          //当前generation“已损坏”，抛出BrokenBarrierException异常
+          //抛出该异常一般都是某个线程在等待某个处于“断开”状态的CyclicBarrie
+          if (g.broken)
+              //当某个线程试图等待处于断开状态的 barrier 时，或者 barrier 进入断开状态而线程处于等待状态时，抛出该异常
+              throw new BrokenBarrierException();
+
+          //如果线程中断，终止CyclicBarrier
+          if (Thread.interrupted()) {
+              breakBarrier();
+              throw new InterruptedException();
+          }
+
+          //进来一个线程 count - 1
+          int index = --count;
+          //count == 0 表示所有线程均已到位，触发Runnable任务
+          if (index == 0) {  // tripped
+              boolean ranAction = false;
+              try {
+                  final Runnable command = barrierCommand;
+                  //触发任务
+                  if (command != null)
+                      command.run();
+                  ranAction = true;
+                  //唤醒所有等待线程，并更新generation
+                  nextGeneration();
+                  return 0;
+              } finally {
+                  if (!ranAction)
+                      breakBarrier();
+              }
+          }
+
+
+          for (;;) {
+              try {
+                  //如果不是超时等待，则调用Condition.await()方法等待
+                  if (!timed)
+                      trip.await();
+                  else if (nanos > 0L)
+                      //超时等待，调用Condition.awaitNanos()方法等待
+                      nanos = trip.awaitNanos(nanos);
+              } catch (InterruptedException ie) {
+                  if (g == generation && ! g.broken) {
+                      breakBarrier();
+                      throw ie;
+                  } else {
+                      // We're about to finish waiting even if we had not
+                      // been interrupted, so this interrupt is deemed to
+                      // "belong" to subsequent execution.
+                      Thread.currentThread().interrupt();
+                  }
+              }
+
+              if (g.broken)
+                  throw new BrokenBarrierException();
+
+              //generation已经更新，返回index
+              if (g != generation)
+                  return index;
+
+              //“超时等待”，并且时间已到,终止CyclicBarrier，并抛出异常
+              if (timed && nanos <= 0L) {
+                  breakBarrier();
+                  throw new TimeoutException();
+              }
+          }
+      } finally {
+          //释放锁
+          lock.unlock();
+      }
+  }
+  ```
+  其实await()的处理逻辑还是比较简单的：如果该线程不是到达的最后一个线程，则他会一直处于等待状态，除非发生以下情况：
+
+  1. 最后一个线程到达，即index == 0
+  2. 超出了指定时间（超时等待）
+  3. 其他的某个线程中断当前线程
+  4. 其他的某个线程中断另一个等待的线程
+  5. 其他的某个线程在等待barrier超时
+  6. 其他的某个线程在此barrier调用reset()方法。reset()方法用于将屏障重置为初始状态。
+
+
+  在上面的源代码中，我们可能需要注意Generation 对象，在上述代码中我们总是可以看到抛出BrokenBarrierException异常，那么什么时候抛出异常呢？如果一个线程处于等待状态时，如果其他线程调用reset()，或者调用的barrier原本就是被损坏的，则抛出BrokenBarrierException异常。同时，任何线程在等待时被中断了，则其他所有线程都将抛出BrokenBarrierException异常，并将barrier置于损坏状态。
+
+  同时，Generation描述着CyclicBarrier的更显换代。在CyclicBarrier中，同一批线程属于同一代。当有parties个线程到达barrier，generation就会被更新换代。其中broken标识该当前CyclicBarrier是否已经处于中断状态。
+  ```java
+  private static class Generation {
+        boolean broken = false;
+  }
+  ```
+  默认barrier是没有损坏的。
+
+  当barrier损坏了或者有一个线程中断了，则通过breakBarrier()来终止所有的线程：
+  ```java
+  private void breakBarrier() {
+       generation.broken = true;
+       count = parties;
+       trip.signalAll();
+  }
+  ```
+  在breakBarrier()中除了将broken设置为true，还会调用signalAll将在CyclicBarrier处于等待状态的线程全部唤醒。
+
+  当所有线程都已经到达barrier处（index == 0），则会通过nextGeneration()进行更新换地操作，在这个步骤中，做了三件事：唤醒所有线程，重置count，generation。
+  ```java
+  private void nextGeneration() {
+      trip.signalAll();
+      count = parties;
+      generation = new Generation();
+  }
+  ```
+  CyclicBarrier同时也提供了await(long timeout, TimeUnit unit) 方法来做超时控制，内部还是通过调用doawait()实现的。
+### 总结
+
+  CyclicBarrier parties参数，await()等到parties个线程都执行后再获取到锁。
+
+### 应用场景
+
+  **CyclicBarrier试用于多线程结果合并的操作，用于多线程计算数据，最后合并计算结果的应用场景。** 比如我们需要统计多个Excel中的数据，然后等到一个总结果。我们可以通过多线程处理每一个Excel，执行完成后得到相应的结果，最后通过barrierAction来计算这些线程的计算结果，得到所有Excel的总和。
+
+  应用示例
+  比如我们开会只有等所有的人到齐了才会开会，如下：
+  ```java
+  public class CyclicBarrierTest {
+
+      private static CyclicBarrier cyclicBarrier;
+
+      static class CyclicBarrierThread extends Thread{
+          public void run() {
+              System.out.println(Thread.currentThread().getName() + "到了");
+              //等待
+              try {
+                  cyclicBarrier.await();
+              } catch (Exception e) {
+                  e.printStackTrace();
+              }
+          }
+      }
+
+      public static void main(String[] args){
+
+          cyclicBarrier = new CyclicBarrier(5, new Runnable() {
+              @Override
+              public void run() {
+                  System.out.println("人到齐了，开会吧....");
+              }
+          });
+
+          for(int i = 0 ; i < 5 ; i++){
+              new CyclicBarrierThread().start();
+          }
+      }
+  }
+  ```
+运行结果：
+<img src="img/201702110001_2.jpg">
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/17 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CountDownLatch.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/17 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CountDownLatch.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/17 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CountDownLatch.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/17 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CountDownLatch.md"
index a3b5d149..11a04434 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/17 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CountDownLatch.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/17 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232CountDownLatch.md"	
@@ -1,198 +1,198 @@
-  在上篇博客中介绍了Java四大并发工具之一的CyclicBarrier，今天要介绍的CountDownLatch与CyclicBarrier有点儿相似。
-
-  CyclicBarrier所描述的是“允许一组线程互相等待，直到到达某个公共屏障点，才会进行后续任务"，而CountDownLatch所描述的是”在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待“。在API中是这样描述的：
-
-  **用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。**
-  <img src="img/2017021200001_thumb.png">
-
-  CountDownLatch是通过一个计数器来实现的，当我们在new 一个CountDownLatch对象的时候需要带入该计数器值，该值就表示了线程的数量。每当一个线程完成自己的任务后，计数器的值就会减1。当计数器的值变为0时，就表示所有的线程均已经完成了任务，然后就可以恢复等待的线程继续执行了。
-
-  虽然，CountDownlatch与CyclicBarrier有那么点相似，但是他们还是存在一些区别的：
-
-  1. CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；而CyclicBarrier则是允许N个线程相互等待
-  2. CountDownLatch的计数器无法被重置；CyclicBarrier的计数器可以被重置后使用，因此它被称为是循环的barrier
-
-### 实现分析
-  CountDownLatch结构如下
-  <img src="img/201702110002_thumb.jpg">
-  通过上面的结构图我们可以看到，**CountDownLatch内部依赖Sync实现，而Sync继承AQS。** CountDownLatch仅提供了一个构造方法：
-
-  CountDownLatch(int count) ： 构造一个用给定计数初始化的 CountDownLatch
-  ```java
-  public CountDownLatch(int count) {
-      if (count < 0) throw new IllegalArgumentException("count < 0");
-      this.sync = new Sync(count);
-  }
-  ```
-  sync为 CountDownLatch的一个内部类，其定义如下：
-  ```java
-  private static final class Sync extends AbstractQueuedSynchronizer {
-      private static final long serialVersionUID = 4982264981922014374L;
-
-      Sync(int count) {
-          setState(count);
-      }
-
-      //获取同步状态
-      int getCount() {
-          return getState();
-      }
-
-      //获取同步状态
-      protected int tryAcquireShared(int acquires) {
-          return (getState() == 0) ? 1 : -1;
-      }
-
-      //释放同步状态
-      protected boolean tryReleaseShared(int releases) {
-          for (;;) {
-              int c = getState();
-              if (c == 0)
-                  return false;
-              int nextc = c-1;
-              if (compareAndSetState(c, nextc))
-                  return nextc == 0;
-          }
-      }
-  }
-  ```
-  **通过这个内部类Sync我们可以清楚地看到CountDownLatch是采用共享锁来实现的。**
-
-  await()
-  CountDownLatch提供await()方法来使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断，定义如下：
-  ```java
-  public void await() throws InterruptedException {
-      sync.acquireSharedInterruptibly(1);
-  }
-  ```
-  await其内部使用AQS的acquireSharedInterruptibly(int arg)：
-  ```java
-  public final void acquireSharedInterruptibly(int arg)
-          throws InterruptedException {
-      if (Thread.interrupted())
-          throw new InterruptedException();
-      if (tryAcquireShared(arg) < 0)
-          doAcquireSharedInterruptibly(arg);
-  }
-  ```
-  在内部类Sync中重写了tryAcquireShared(int arg)方法：
-  ```java
-  protected int tryAcquireShared(int acquires) {
-      return (getState() == 0) ? 1 : -1;
-  }
-  ```
-  getState()获取同步状态，其值等于计数器的值，从这里我们可以看到如果计数器值不等于0，则会调用doAcquireSharedInterruptibly(int arg)，该方法为一个自旋方法会尝试一直去获取同步状态：
-  ```java
-  private void doAcquireSharedInterruptibly(int arg)
-          throws InterruptedException {
-      final Node node = addWaiter(Node.SHARED);
-      boolean failed = true;
-      try {
-          for (;;) {
-              final Node p = node.predecessor();
-              if (p == head) {
-                  /**
-                   * 对于CountDownLatch而言，如果计数器值不等于0，那么r 会一直小于0
-                   */
-                  int r = tryAcquireShared(arg);
-                  if (r >= 0) {
-                      setHeadAndPropagate(node, r);
-                      p.next = null; // help GC
-                      failed = false;
-                      return;
-                  }
-              }
-              //等待
-              if (shouldParkAfterFailedAcquire(p, node) &&
-                      parkAndCheckInterrupt())
-                  throw new InterruptedException();
-          }
-      } finally {
-          if (failed)
-              cancelAcquire(node);
-      }
-  }
-  ```
-countDown()
-  CountDownLatch提供countDown() 方法递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
-  ```java
-  public void countDown() {
-      sync.releaseShared(1);
-  }
-  ```
-  内部调用AQS的releaseShared(int arg)方法来释放共享锁同步状态：
-  ```java
-  public final boolean releaseShared(int arg) {
-      if (tryReleaseShared(arg)) {
-          doReleaseShared();
-          return true;
-      }
-      return false;
-  }
-  ```
-  tryReleaseShared(int arg)方法被CountDownLatch的内部类Sync重写：
-  ```java
-  protected boolean tryReleaseShared(int releases) {
-      for (;;) {
-          //获取锁状态
-          int c = getState();
-          //c == 0 直接返回，释放锁成功
-          if (c == 0)
-              return false;
-          //计算新“锁计数器”
-          int nextc = c-1;
-          //更新锁状态（计数器）
-          if (compareAndSetState(c, nextc))
-              return nextc == 0;
-      }
-  }
-  ```
-### 总结
-  CountDownLatch内部通过`共享锁`实现。在创建CountDownLatch实例时，需要传递一个int型的参数：count，该参数为计数器的初始值，也可以理解为该共享锁可以获取的总次数。当某个线程调用`await()`方法，程序首先判断count的值是否为0，如果不会0的话则会一直等待直到为0为止。当其他线程调用`countDown()`方法时，则执行释放共享锁状态，使count值 - 1。当在创建CountDownLatch时初始化的count参数，必须要有count线程调用countDown方法才会使计数器count等于0，锁才会释放，前面等待的线程才会继续运行。注意CountDownLatch不能回滚重置。
-
-### 应用示例
-  示例仍然使用开会案例。老板进入会议室等待5个人全部到达会议室才会开会。所以这里有两个线程老板等待开会线程、员工到达会议室：
-  ```java
-  public class CountDownLatchTest {
-      private static CountDownLatch countDownLatch = new CountDownLatch(5);
-
-      /**
-       * Boss线程，等待员工到达开会
-       */
-      static class BossThread extends Thread{
-          @Override
-          public void run() {
-              System.out.println("Boss在会议室等待，总共有" + countDownLatch.getCount() + "个人开会...");
-              try {
-                  //Boss等待
-                  countDownLatch.await();
-              } catch (InterruptedException e) {
-                  e.printStackTrace();
-              }
-
-              System.out.println("所有人都已经到齐了，开会吧...");
-          }
-      }
-
-      //员工到达会议室
-      static class EmpleoyeeThread  extends Thread{
-          @Override
-          public void run() {
-              System.out.println(Thread.currentThread().getName() + "，到达会议室....");
-              //员工到达会议室 count - 1
-              countDownLatch.countDown();
-          }
-      }
-
-      public static void main(String[] args){
-          //Boss线程启动
-          new BossThread().start();
-
-          for(int i = 0 ; i < countDownLatch.getCount() ; i++){
-              new EmpleoyeeThread().start();
-          }
-      }
-  }
-  ```
-  运行结果：
-  <img src="img/2017021200002_thumb.jpg">
+  在上篇博客中介绍了Java四大并发工具之一的CyclicBarrier，今天要介绍的CountDownLatch与CyclicBarrier有点儿相似。
+
+  CyclicBarrier所描述的是“允许一组线程互相等待，直到到达某个公共屏障点，才会进行后续任务"，而CountDownLatch所描述的是”在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待“。在API中是这样描述的：
+
+  **用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。**
+  <img src="img/2017021200001_thumb.png">
+
+  CountDownLatch是通过一个计数器来实现的，当我们在new 一个CountDownLatch对象的时候需要带入该计数器值，该值就表示了线程的数量。每当一个线程完成自己的任务后，计数器的值就会减1。当计数器的值变为0时，就表示所有的线程均已经完成了任务，然后就可以恢复等待的线程继续执行了。
+
+  虽然，CountDownlatch与CyclicBarrier有那么点相似，但是他们还是存在一些区别的：
+
+  1. CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；而CyclicBarrier则是允许N个线程相互等待
+  2. CountDownLatch的计数器无法被重置；CyclicBarrier的计数器可以被重置后使用，因此它被称为是循环的barrier
+
+### 实现分析
+  CountDownLatch结构如下
+  <img src="img/201702110002_thumb.jpg">
+  通过上面的结构图我们可以看到，**CountDownLatch内部依赖Sync实现，而Sync继承AQS。** CountDownLatch仅提供了一个构造方法：
+
+  CountDownLatch(int count) ： 构造一个用给定计数初始化的 CountDownLatch
+  ```java
+  public CountDownLatch(int count) {
+      if (count < 0) throw new IllegalArgumentException("count < 0");
+      this.sync = new Sync(count);
+  }
+  ```
+  sync为 CountDownLatch的一个内部类，其定义如下：
+  ```java
+  private static final class Sync extends AbstractQueuedSynchronizer {
+      private static final long serialVersionUID = 4982264981922014374L;
+
+      Sync(int count) {
+          setState(count);
+      }
+
+      //获取同步状态
+      int getCount() {
+          return getState();
+      }
+
+      //获取同步状态
+      protected int tryAcquireShared(int acquires) {
+          return (getState() == 0) ? 1 : -1;
+      }
+
+      //释放同步状态
+      protected boolean tryReleaseShared(int releases) {
+          for (;;) {
+              int c = getState();
+              if (c == 0)
+                  return false;
+              int nextc = c-1;
+              if (compareAndSetState(c, nextc))
+                  return nextc == 0;
+          }
+      }
+  }
+  ```
+  **通过这个内部类Sync我们可以清楚地看到CountDownLatch是采用共享锁来实现的。**
+
+  await()
+  CountDownLatch提供await()方法来使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断，定义如下：
+  ```java
+  public void await() throws InterruptedException {
+      sync.acquireSharedInterruptibly(1);
+  }
+  ```
+  await其内部使用AQS的acquireSharedInterruptibly(int arg)：
+  ```java
+  public final void acquireSharedInterruptibly(int arg)
+          throws InterruptedException {
+      if (Thread.interrupted())
+          throw new InterruptedException();
+      if (tryAcquireShared(arg) < 0)
+          doAcquireSharedInterruptibly(arg);
+  }
+  ```
+  在内部类Sync中重写了tryAcquireShared(int arg)方法：
+  ```java
+  protected int tryAcquireShared(int acquires) {
+      return (getState() == 0) ? 1 : -1;
+  }
+  ```
+  getState()获取同步状态，其值等于计数器的值，从这里我们可以看到如果计数器值不等于0，则会调用doAcquireSharedInterruptibly(int arg)，该方法为一个自旋方法会尝试一直去获取同步状态：
+  ```java
+  private void doAcquireSharedInterruptibly(int arg)
+          throws InterruptedException {
+      final Node node = addWaiter(Node.SHARED);
+      boolean failed = true;
+      try {
+          for (;;) {
+              final Node p = node.predecessor();
+              if (p == head) {
+                  /**
+                   * 对于CountDownLatch而言，如果计数器值不等于0，那么r 会一直小于0
+                   */
+                  int r = tryAcquireShared(arg);
+                  if (r >= 0) {
+                      setHeadAndPropagate(node, r);
+                      p.next = null; // help GC
+                      failed = false;
+                      return;
+                  }
+              }
+              //等待
+              if (shouldParkAfterFailedAcquire(p, node) &&
+                      parkAndCheckInterrupt())
+                  throw new InterruptedException();
+          }
+      } finally {
+          if (failed)
+              cancelAcquire(node);
+      }
+  }
+  ```
+countDown()
+  CountDownLatch提供countDown() 方法递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
+  ```java
+  public void countDown() {
+      sync.releaseShared(1);
+  }
+  ```
+  内部调用AQS的releaseShared(int arg)方法来释放共享锁同步状态：
+  ```java
+  public final boolean releaseShared(int arg) {
+      if (tryReleaseShared(arg)) {
+          doReleaseShared();
+          return true;
+      }
+      return false;
+  }
+  ```
+  tryReleaseShared(int arg)方法被CountDownLatch的内部类Sync重写：
+  ```java
+  protected boolean tryReleaseShared(int releases) {
+      for (;;) {
+          //获取锁状态
+          int c = getState();
+          //c == 0 直接返回，释放锁成功
+          if (c == 0)
+              return false;
+          //计算新“锁计数器”
+          int nextc = c-1;
+          //更新锁状态（计数器）
+          if (compareAndSetState(c, nextc))
+              return nextc == 0;
+      }
+  }
+  ```
+### 总结
+  CountDownLatch内部通过`共享锁`实现。在创建CountDownLatch实例时，需要传递一个int型的参数：count，该参数为计数器的初始值，也可以理解为该共享锁可以获取的总次数。当某个线程调用`await()`方法，程序首先判断count的值是否为0，如果不会0的话则会一直等待直到为0为止。当其他线程调用`countDown()`方法时，则执行释放共享锁状态，使count值 - 1。当在创建CountDownLatch时初始化的count参数，必须要有count线程调用countDown方法才会使计数器count等于0，锁才会释放，前面等待的线程才会继续运行。注意CountDownLatch不能回滚重置。
+
+### 应用示例
+  示例仍然使用开会案例。老板进入会议室等待5个人全部到达会议室才会开会。所以这里有两个线程老板等待开会线程、员工到达会议室：
+  ```java
+  public class CountDownLatchTest {
+      private static CountDownLatch countDownLatch = new CountDownLatch(5);
+
+      /**
+       * Boss线程，等待员工到达开会
+       */
+      static class BossThread extends Thread{
+          @Override
+          public void run() {
+              System.out.println("Boss在会议室等待，总共有" + countDownLatch.getCount() + "个人开会...");
+              try {
+                  //Boss等待
+                  countDownLatch.await();
+              } catch (InterruptedException e) {
+                  e.printStackTrace();
+              }
+
+              System.out.println("所有人都已经到齐了，开会吧...");
+          }
+      }
+
+      //员工到达会议室
+      static class EmpleoyeeThread  extends Thread{
+          @Override
+          public void run() {
+              System.out.println(Thread.currentThread().getName() + "，到达会议室....");
+              //员工到达会议室 count - 1
+              countDownLatch.countDown();
+          }
+      }
+
+      public static void main(String[] args){
+          //Boss线程启动
+          new BossThread().start();
+
+          for(int i = 0 ; i < countDownLatch.getCount() ; i++){
+              new EmpleoyeeThread().start();
+          }
+      }
+  }
+  ```
+  运行结果：
+  <img src="img/2017021200002_thumb.jpg">
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/18 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Semaphore.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/18 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Semaphore.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/18 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Semaphore.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/18 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Semaphore.md"
index 2aaeee28..1e7556cd 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/18 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Semaphore.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/18 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Semaphore.md"	
@@ -1,182 +1,182 @@
-  信号量Semaphore是 **一个控制访问多个共享资源的计数器**，和CountDownLatch一样，其本质上是一个 **“共享锁”**。
-
-  Semaphore，在API是这么介绍的：
-
-  一个计数信号量。**从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。**
-
-  Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。
-
-  下面我们就一个停车场的简单例子来阐述Semaphore：
-
-  为了简单起见我们假设停车场仅有5个停车位，一开始停车场没有车辆所有车位全部空着，然后先后到来三辆车，停车场车位够，安排进去停车，然后又来三辆，这个时候由于只有两个停车位，所有只能停两辆，其余一辆必须在外面候着，直到停车场有空车位，当然以后每来一辆都需要在外面候着。当停车场有车开出去，里面有空位了，则安排一辆车进去（至于是哪辆 要看选择的机制是公平还是非公平）。
-
-  从程序角度看，停车场就相当于信号量Semaphore，其中许可数为5，车辆就相对线程。当来一辆车时，许可数就会减 1 ，当停车场没有车位了（许可书 == 0 ），其他来的车辆需要在外面等候着。如果有一辆车开出停车场，许可数 + 1，然后放进来一辆车。
-
-  **信号量Semaphore是一个非负整数（>=1）。当一个线程想要访问某个共享资源时，它必须要先获取Semaphore，当Semaphore >0时，获取该资源并使Semaphore – 1。如果Semaphore值 = 0，则表示全部的共享资源已经被其他线程全部占用，线程必须要等待其他线程释放资源。当线程释放资源时，Semaphore则+1**
-
-  实现分析
-  Semaphore结构如下：
-  <img src="img/201702170001_thumb.jpg">
-  从上图可以看出 **Semaphore内部包含公平锁（FairSync）和非公平锁（NonfairSync），继承内部类Sync，其中Sync继承AQS（再一次阐述AQS的重要性）。**
-
-  Semaphore提供了两个构造函数：
-
-  1. Semaphore(int permits) ：创建具有给定的许可数和非公平的公平设置的 Semaphore。
-  2. Semaphore(int permits, boolean fair) ：创建具有给定的许可数和给定的公平设置的 Semaphore。
-
-  实现如下：
-  ```JAVA
-  public Semaphore(int permits) {
-      sync = new NonfairSync(permits);
-  }
-
-  public Semaphore(int permits, boolean fair) {
-      sync = fair ? new FairSync(permits) : new NonfairSync(permits);
-  }
-  ```
-  Semaphore默认选择非公平锁。
-
-  当信号量Semaphore = 1 时，它可以当作互斥锁使用。其中0、1就相当于它的状态，当=1时表示其他线程可以获取，当=0时，排他，即其他线程必须要等待。
-
-  信号量获取
-  Semaphore提供了acquire()方法来获取一个许可。
-  ```JAVA
-  public void acquire() throws InterruptedException {
-      sync.acquireSharedInterruptibly(1);
-  }
-  ```
-  内部调用AQS的acquireSharedInterruptibly(int arg)，该方法以共享模式获取同步状态：
-  ```JAVA
-  public final void acquireSharedInterruptibly(int arg)
-          throws InterruptedException {
-      if (Thread.interrupted())
-          throw new InterruptedException();
-      if (tryAcquireShared(arg) < 0)
-          doAcquireSharedInterruptibly(arg);
-  }
-  ```
-  在acquireSharedInterruptibly(int arg)中，tryAcquireShared(int arg)由子类来实现，对于Semaphore而言，如果我们选择非公平模式，则调用NonfairSync的tryAcquireShared(int arg)方法，否则调用FairSync的tryAcquireShared(int arg)方法。
-
-### 公平
-  ```JAVA
-  protected int tryAcquireShared(int acquires) {
-      for (;;) {
-          //判断该线程是否位于CLH队列的列头
-          if (hasQueuedPredecessors())
-              return -1;
-          //获取当前的信号量许可
-          int available = getState();
-
-          //设置“获得acquires个信号量许可之后，剩余的信号量许可数”
-          int remaining = available - acquires;
-
-          //CAS设置信号量
-          if (remaining < 0 ||
-                  compareAndSetState(available, remaining))
-              return remaining;
-      }
-  }
-  ```
-
-### 非公平
-
-  对于非公平而言，因为它不需要判断当前线程是否位于CLH同步队列列头，所以相对而言会简单些。
-  ```JAVA
-  protected int tryAcquireShared(int acquires) {
-      return nonfairTryAcquireShared(acquires);
-  }
-
-  final int nonfairTryAcquireShared(int acquires) {
-      for (;;) {
-          int available = getState();
-          int remaining = available - acquires;
-          if (remaining < 0 ||
-              compareAndSetState(available, remaining))
-              return remaining;
-      }
-  }
-  ```
-
-###信号量释放
-  获取了许可，当用完之后就需要释放，Semaphore提供release()来释放许可。
-  ```JAVA
-  public void release() {
-      sync.releaseShared(1);
-  }
-  ```
-  内部调用AQS的releaseShared(int arg)：
-  ```JAVA
-  public final boolean releaseShared(int arg) {
-      if (tryReleaseShared(arg)) {
-          doReleaseShared();
-          return true;
-      }
-      return false;
-  }
-  ```
-  releaseShared(int arg)调用Semaphore内部类Sync的tryReleaseShared(int arg)：
-  ```JAVA
-  protected final boolean tryReleaseShared(int releases) {
-      for (;;) {
-          int current = getState();
-          //信号量的许可数 = 当前信号许可数 + 待释放的信号许可数
-          int next = current + releases;
-          if (next < current) // overflow
-              throw new Error("Maximum permit count exceeded");
-          //设置可获取的信号许可数为next
-          if (compareAndSetState(current, next))
-              return true;
-      }
-  }
-  ```
-
-### 总结
-  semaphore permits参数 信号量 ， acquire()获取 ，release()释放
-
-### 应用示例
-**通常用于限制可以访问某些资源（物理或逻辑的）的线程数目**
-我们已停车为示例：
-  ```java
-  public class SemaphoreTest {
-      static class Parking{
-          //信号量
-          private Semaphore semaphore;
-          Parking(int count){
-              semaphore = new Semaphore(count);
-          }
-          public void park(){
-              try {
-                  //获取信号量
-                  semaphore.acquire();
-                  long time = (long) (Math.random() * 10);
-                  System.out.println(Thread.currentThread().getName() + "进入停车场，停车" + time + "秒..." );
-                  Thread.sleep(time);
-                  System.out.println(Thread.currentThread().getName() + "开出停车场...");
-              } catch (InterruptedException e) {
-                  e.printStackTrace();
-              } finally {
-                  semaphore.release();
-              }
-          }
-      }
-      static class Car extends Thread {
-          Parking parking ;
-          Car(Parking parking){
-              this.parking = parking;
-          }
-          @Override
-          public void run() {
-              parking.park();     //进入停车场
-          }
-      }
-      public static void main(String[] args){
-          Parking parking = new Parking(3);
-
-          for(int i = 0 ; i < 5 ; i++){
-              new Car(parking).start();
-          }
-      }
-  }
-  ```
-  运行结果如下：
-  <img src="img/201702170002.jpg">
+  信号量Semaphore是 **一个控制访问多个共享资源的计数器**，和CountDownLatch一样，其本质上是一个 **“共享锁”**。
+
+  Semaphore，在API是这么介绍的：
+
+  一个计数信号量。**从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。**
+
+  Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。
+
+  下面我们就一个停车场的简单例子来阐述Semaphore：
+
+  为了简单起见我们假设停车场仅有5个停车位，一开始停车场没有车辆所有车位全部空着，然后先后到来三辆车，停车场车位够，安排进去停车，然后又来三辆，这个时候由于只有两个停车位，所有只能停两辆，其余一辆必须在外面候着，直到停车场有空车位，当然以后每来一辆都需要在外面候着。当停车场有车开出去，里面有空位了，则安排一辆车进去（至于是哪辆 要看选择的机制是公平还是非公平）。
+
+  从程序角度看，停车场就相当于信号量Semaphore，其中许可数为5，车辆就相对线程。当来一辆车时，许可数就会减 1 ，当停车场没有车位了（许可书 == 0 ），其他来的车辆需要在外面等候着。如果有一辆车开出停车场，许可数 + 1，然后放进来一辆车。
+
+  **信号量Semaphore是一个非负整数（>=1）。当一个线程想要访问某个共享资源时，它必须要先获取Semaphore，当Semaphore >0时，获取该资源并使Semaphore – 1。如果Semaphore值 = 0，则表示全部的共享资源已经被其他线程全部占用，线程必须要等待其他线程释放资源。当线程释放资源时，Semaphore则+1**
+
+  实现分析
+  Semaphore结构如下：
+  <img src="img/201702170001_thumb.jpg">
+  从上图可以看出 **Semaphore内部包含公平锁（FairSync）和非公平锁（NonfairSync），继承内部类Sync，其中Sync继承AQS（再一次阐述AQS的重要性）。**
+
+  Semaphore提供了两个构造函数：
+
+  1. Semaphore(int permits) ：创建具有给定的许可数和非公平的公平设置的 Semaphore。
+  2. Semaphore(int permits, boolean fair) ：创建具有给定的许可数和给定的公平设置的 Semaphore。
+
+  实现如下：
+  ```JAVA
+  public Semaphore(int permits) {
+      sync = new NonfairSync(permits);
+  }
+
+  public Semaphore(int permits, boolean fair) {
+      sync = fair ? new FairSync(permits) : new NonfairSync(permits);
+  }
+  ```
+  Semaphore默认选择非公平锁。
+
+  当信号量Semaphore = 1 时，它可以当作互斥锁使用。其中0、1就相当于它的状态，当=1时表示其他线程可以获取，当=0时，排他，即其他线程必须要等待。
+
+  信号量获取
+  Semaphore提供了acquire()方法来获取一个许可。
+  ```JAVA
+  public void acquire() throws InterruptedException {
+      sync.acquireSharedInterruptibly(1);
+  }
+  ```
+  内部调用AQS的acquireSharedInterruptibly(int arg)，该方法以共享模式获取同步状态：
+  ```JAVA
+  public final void acquireSharedInterruptibly(int arg)
+          throws InterruptedException {
+      if (Thread.interrupted())
+          throw new InterruptedException();
+      if (tryAcquireShared(arg) < 0)
+          doAcquireSharedInterruptibly(arg);
+  }
+  ```
+  在acquireSharedInterruptibly(int arg)中，tryAcquireShared(int arg)由子类来实现，对于Semaphore而言，如果我们选择非公平模式，则调用NonfairSync的tryAcquireShared(int arg)方法，否则调用FairSync的tryAcquireShared(int arg)方法。
+
+### 公平
+  ```JAVA
+  protected int tryAcquireShared(int acquires) {
+      for (;;) {
+          //判断该线程是否位于CLH队列的列头
+          if (hasQueuedPredecessors())
+              return -1;
+          //获取当前的信号量许可
+          int available = getState();
+
+          //设置“获得acquires个信号量许可之后，剩余的信号量许可数”
+          int remaining = available - acquires;
+
+          //CAS设置信号量
+          if (remaining < 0 ||
+                  compareAndSetState(available, remaining))
+              return remaining;
+      }
+  }
+  ```
+
+### 非公平
+
+  对于非公平而言，因为它不需要判断当前线程是否位于CLH同步队列列头，所以相对而言会简单些。
+  ```JAVA
+  protected int tryAcquireShared(int acquires) {
+      return nonfairTryAcquireShared(acquires);
+  }
+
+  final int nonfairTryAcquireShared(int acquires) {
+      for (;;) {
+          int available = getState();
+          int remaining = available - acquires;
+          if (remaining < 0 ||
+              compareAndSetState(available, remaining))
+              return remaining;
+      }
+  }
+  ```
+
+###信号量释放
+  获取了许可，当用完之后就需要释放，Semaphore提供release()来释放许可。
+  ```JAVA
+  public void release() {
+      sync.releaseShared(1);
+  }
+  ```
+  内部调用AQS的releaseShared(int arg)：
+  ```JAVA
+  public final boolean releaseShared(int arg) {
+      if (tryReleaseShared(arg)) {
+          doReleaseShared();
+          return true;
+      }
+      return false;
+  }
+  ```
+  releaseShared(int arg)调用Semaphore内部类Sync的tryReleaseShared(int arg)：
+  ```JAVA
+  protected final boolean tryReleaseShared(int releases) {
+      for (;;) {
+          int current = getState();
+          //信号量的许可数 = 当前信号许可数 + 待释放的信号许可数
+          int next = current + releases;
+          if (next < current) // overflow
+              throw new Error("Maximum permit count exceeded");
+          //设置可获取的信号许可数为next
+          if (compareAndSetState(current, next))
+              return true;
+      }
+  }
+  ```
+
+### 总结
+  semaphore permits参数 信号量 ， acquire()获取 ，release()释放
+
+### 应用示例
+**通常用于限制可以访问某些资源（物理或逻辑的）的线程数目**
+我们已停车为示例：
+  ```java
+  public class SemaphoreTest {
+      static class Parking{
+          //信号量
+          private Semaphore semaphore;
+          Parking(int count){
+              semaphore = new Semaphore(count);
+          }
+          public void park(){
+              try {
+                  //获取信号量
+                  semaphore.acquire();
+                  long time = (long) (Math.random() * 10);
+                  System.out.println(Thread.currentThread().getName() + "进入停车场，停车" + time + "秒..." );
+                  Thread.sleep(time);
+                  System.out.println(Thread.currentThread().getName() + "开出停车场...");
+              } catch (InterruptedException e) {
+                  e.printStackTrace();
+              } finally {
+                  semaphore.release();
+              }
+          }
+      }
+      static class Car extends Thread {
+          Parking parking ;
+          Car(Parking parking){
+              this.parking = parking;
+          }
+          @Override
+          public void run() {
+              parking.park();     //进入停车场
+          }
+      }
+      public static void main(String[] args){
+          Parking parking = new Parking(3);
+
+          for(int i = 0 ; i < 5 ; i++){
+              new Car(parking).start();
+          }
+      }
+  }
+  ```
+  运行结果如下：
+  <img src="img/201702170002.jpg">
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/19 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Exchanger.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/19 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Exchanger.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/19 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Exchanger.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/19 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Exchanger.md"
index 589ce7aa..81f87e4f 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/19 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Exchanger.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/19 - J.U.C\344\271\213\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\357\274\232Exchanger.md"	
@@ -1,98 +1,98 @@
-
-  前面三篇博客分别介绍了CyclicBarrier、CountDownLatch、Semaphore，现在介绍并发工具类中的最后一个Exchange。Exchange是最简单的也是最复杂的，简单在于API非常简单，就一个构造方法和两个exchange()方法，最复杂在于它的实现是最复杂的（反正我是看晕了的）。
-
-  在API是这么介绍的：可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。Exchanger 可能在应用程序（比如遗传算法和管道设计）中很有用。
-
-  Exchanger，它允许在并发任务之间交换数据。具体来说，Exchanger类允许在两个线程之间定义同步点。当两个线程都到达同步点时，他们交换数据结构，因此第一个线程的数据结构进入到第二个线程中，第二个线程的数据结构进入到第一个线程中。
-
-  应用示例
-  Exchange实现较为复杂，我们先看其怎么使用，然后再来分析其源码。现在我们用Exchange来模拟生产-消费者问题：
-  ```java
-  public class ExchangerTest {
-      static class Producer implements Runnable{
-
-          //生产者、消费者交换的数据结构
-          private List<String> buffer;
-
-          //步生产者和消费者的交换对象
-          private Exchanger<List<String>> exchanger;
-
-          Producer(List<String> buffer,Exchanger<List<String>> exchanger){
-              this.buffer = buffer;
-              this.exchanger = exchanger;
-          }
-
-          @Override
-          public void run() {
-              for(int i = 1 ; i < 5 ; i++){
-                  System.out.println("生产者第" + i + "次提供");
-                  for(int j = 1 ; j <= 3 ; j++){
-                      System.out.println("生产者装入" + i  + "--" + j);
-                      buffer.add("buffer：" + i + "--" + j);
-                  }
-
-                  System.out.println("生产者装满，等待与消费者交换...");
-                  try {
-                      exchanger.exchange(buffer);
-                  } catch (InterruptedException e) {
-                      e.printStackTrace();
-                  }
-              }
-          }
-      }
-
-      static class Consumer implements Runnable {
-          private List<String> buffer;
-
-          private final Exchanger<List<String>> exchanger;
-
-          public Consumer(List<String> buffer, Exchanger<List<String>> exchanger) {
-              this.buffer = buffer;
-              this.exchanger = exchanger;
-          }
-
-          @Override
-          public void run() {
-              for (int i = 1; i < 5; i++) {
-                  //调用exchange()与消费者进行数据交换
-                  try {
-                      buffer = exchanger.exchange(buffer);
-                  } catch (InterruptedException e) {
-                      e.printStackTrace();
-                  }
-
-                  System.out.println("消费者第" + i + "次提取");
-                  for (int j = 1; j <= 3 ; j++) {
-                      System.out.println("消费者 : " + buffer.get(0));
-                      buffer.remove(0);
-                  }
-              }
-          }
-      }
-
-      public static void main(String[] args){
-          List<String> buffer1 = new ArrayList<String>();
-          List<String> buffer2 = new ArrayList<String>();
-
-          Exchanger<List<String>> exchanger = new Exchanger<List<String>>();
-
-          Thread producerThread = new Thread(new Producer(buffer1,exchanger));
-          Thread consumerThread = new Thread(new Consumer(buffer2,exchanger));
-
-          producerThread.start();
-          consumerThread.start();
-      }
-  }
-  ```
-  运行结果：
-  <img src="img/2017022100011_thumb.jpg">
-
-  首先生产者Producer、消费者Consumer首先都创建一个缓冲列表，通过Exchanger来同步交换数据。消费中通过调用Exchanger与生产者进行同步来获取数据，而生产者则通过for循环向缓存队列存储数据并使用exchanger对象消费者同步。到消费者从exchanger哪里得到数据后，他的缓冲列表中有3个数据，而生产者得到的则是一个空的列表。上面的例子充分展示了消费者-生产者是如何利用Exchanger来完成数据交换的。
-
-  在Exchanger中，如果一个线程已经到达了exchanger节点时，对于它的伙伴节点的情况有三种：
-
-  如果它的伙伴节点在该线程到达之前已经调用了exchanger方法，则它会唤醒它的伙伴然后进行数据交换，得到各自数据返回。
-  如果它的伙伴节点还没有到达交换点，则该线程将会被挂起，等待它的伙伴节点到达被唤醒，完成数据交换。
-  如果当前线程被中断了则抛出异常，或者等待超时了，则抛出超时异常。
-
-### 实现分析
+
+  前面三篇博客分别介绍了CyclicBarrier、CountDownLatch、Semaphore，现在介绍并发工具类中的最后一个Exchange。Exchange是最简单的也是最复杂的，简单在于API非常简单，就一个构造方法和两个exchange()方法，最复杂在于它的实现是最复杂的（反正我是看晕了的）。
+
+  在API是这么介绍的：可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。Exchanger 可能在应用程序（比如遗传算法和管道设计）中很有用。
+
+  Exchanger，它允许在并发任务之间交换数据。具体来说，Exchanger类允许在两个线程之间定义同步点。当两个线程都到达同步点时，他们交换数据结构，因此第一个线程的数据结构进入到第二个线程中，第二个线程的数据结构进入到第一个线程中。
+
+  应用示例
+  Exchange实现较为复杂，我们先看其怎么使用，然后再来分析其源码。现在我们用Exchange来模拟生产-消费者问题：
+  ```java
+  public class ExchangerTest {
+      static class Producer implements Runnable{
+
+          //生产者、消费者交换的数据结构
+          private List<String> buffer;
+
+          //步生产者和消费者的交换对象
+          private Exchanger<List<String>> exchanger;
+
+          Producer(List<String> buffer,Exchanger<List<String>> exchanger){
+              this.buffer = buffer;
+              this.exchanger = exchanger;
+          }
+
+          @Override
+          public void run() {
+              for(int i = 1 ; i < 5 ; i++){
+                  System.out.println("生产者第" + i + "次提供");
+                  for(int j = 1 ; j <= 3 ; j++){
+                      System.out.println("生产者装入" + i  + "--" + j);
+                      buffer.add("buffer：" + i + "--" + j);
+                  }
+
+                  System.out.println("生产者装满，等待与消费者交换...");
+                  try {
+                      exchanger.exchange(buffer);
+                  } catch (InterruptedException e) {
+                      e.printStackTrace();
+                  }
+              }
+          }
+      }
+
+      static class Consumer implements Runnable {
+          private List<String> buffer;
+
+          private final Exchanger<List<String>> exchanger;
+
+          public Consumer(List<String> buffer, Exchanger<List<String>> exchanger) {
+              this.buffer = buffer;
+              this.exchanger = exchanger;
+          }
+
+          @Override
+          public void run() {
+              for (int i = 1; i < 5; i++) {
+                  //调用exchange()与消费者进行数据交换
+                  try {
+                      buffer = exchanger.exchange(buffer);
+                  } catch (InterruptedException e) {
+                      e.printStackTrace();
+                  }
+
+                  System.out.println("消费者第" + i + "次提取");
+                  for (int j = 1; j <= 3 ; j++) {
+                      System.out.println("消费者 : " + buffer.get(0));
+                      buffer.remove(0);
+                  }
+              }
+          }
+      }
+
+      public static void main(String[] args){
+          List<String> buffer1 = new ArrayList<String>();
+          List<String> buffer2 = new ArrayList<String>();
+
+          Exchanger<List<String>> exchanger = new Exchanger<List<String>>();
+
+          Thread producerThread = new Thread(new Producer(buffer1,exchanger));
+          Thread consumerThread = new Thread(new Consumer(buffer2,exchanger));
+
+          producerThread.start();
+          consumerThread.start();
+      }
+  }
+  ```
+  运行结果：
+  <img src="img/2017022100011_thumb.jpg">
+
+  首先生产者Producer、消费者Consumer首先都创建一个缓冲列表，通过Exchanger来同步交换数据。消费中通过调用Exchanger与生产者进行同步来获取数据，而生产者则通过for循环向缓存队列存储数据并使用exchanger对象消费者同步。到消费者从exchanger哪里得到数据后，他的缓冲列表中有3个数据，而生产者得到的则是一个空的列表。上面的例子充分展示了消费者-生产者是如何利用Exchanger来完成数据交换的。
+
+  在Exchanger中，如果一个线程已经到达了exchanger节点时，对于它的伙伴节点的情况有三种：
+
+  如果它的伙伴节点在该线程到达之前已经调用了exchanger方法，则它会唤醒它的伙伴然后进行数据交换，得到各自数据返回。
+  如果它的伙伴节点还没有到达交换点，则该线程将会被挂起，等待它的伙伴节点到达被唤醒，完成数据交换。
+  如果当前线程被中断了则抛出异常，或者等待超时了，则抛出超时异常。
+
+### 实现分析
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/20 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentHashMap.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/20 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentHashMap.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/20 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentHashMap.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/20 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentHashMap.md"
index d3a01943..b9b5a5f8 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/20 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentHashMap.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/20 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentHashMap.md"	
@@ -1,818 +1,818 @@
-HashMap是我们用得非常频繁的一个集合，但是由于它是非线程安全的，在多线程环境下，put操作是有可能产生死循环的，导致CPU利用率接近100%。为了解决该问题，提供了Hashtable和Collections.synchronizedMap(hashMap)两种解决方案，但是这两种方案都是对读写加锁，独占式，一个线程在读时其他线程必须等待，吞吐量较低，性能较为低下。故而Doug Lea大神给我们提供了高性能的线程安全HashMap：ConcurrentHashMap。
-
-ConcurrentHashMap的实现
-ConcurrentHashMap作为Concurrent一族，其有着高效地并发操作，相比Hashtable的笨重，ConcurrentHashMap则更胜一筹了。
-
-在1.8版本以前，ConcurrentHashMap采用分段锁的概念，使锁更加细化，但是1.8已经改变了这种思路，而是利用`CAS+Synchronized`来保证并发更新的安全，当然底层采用`数组`+`链表`+`红黑树`的存储结构。
-
-关于1.7和1.8的区别请参考占小狼博客：谈谈ConcurrentHashMap1.7和1.8的不同实现:http://www.jianshu.com/p/e694f1e868ec
-
-我们从如下几个部分全面了解ConcurrentHashMap在1.8中是如何实现的：
-
-重要概念
-重要内部类
-ConcurrentHashMap的初始化
-put操作
-get操作
-size操作
-扩容
-红黑树转换
-
-重要概念
-ConcurrentHashMap定义了如下几个常量：
-
-// 最大容量：2^30=1073741824
-private static final int MAXIMUM_CAPACITY = 1 << 30;
-
-// 默认初始值，必须是2的幕数
-private static final int DEFAULT_CAPACITY = 16;
-
-//
-static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
-
-//
-private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
-
-//
-private static final float LOAD_FACTOR = 0.75f;
-
-// 链表转红黑树阀值,> 8 链表转换为红黑树
-static final int TREEIFY_THRESHOLD = 8;
-
-//树转链表阀值，小于等于6（tranfer时，lc、hc=0两个计数器分别++记录原bin、新binTreeNode数量，<=UNTREEIFY_THRESHOLD 则untreeify(lo)）
-static final int UNTREEIFY_THRESHOLD = 6;
-
-//
-static final int MIN_TREEIFY_CAPACITY = 64;
-
-//
-private static final int MIN_TRANSFER_STRIDE = 16;
-
-//
-private static int RESIZE_STAMP_BITS = 16;
-
-// 2^15-1，help resize的最大线程数
-private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
-
-// 32-16=16，sizeCtl中记录size大小的偏移量
-private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
-
-// forwarding nodes的hash值
-static final int MOVED     = -1;
-
-// 树根节点的hash值
-static final int TREEBIN   = -2;
-
-// ReservationNode的hash值
-static final int RESERVED  = -3;
-
-// 可用处理器数量
-static final int NCPU = Runtime.getRuntime().availableProcessors();
-上面是ConcurrentHashMap定义的常量，简单易懂，就不多阐述了。下面介绍ConcurrentHashMap几个很重要的概念。
-
-table：用来存放Node节点数据的，默认为null，默认大小为16的数组，每次扩容时大小总是2的幂次方；
-nextTable：扩容时新生成的数据，数组为table的两倍；
-Node：节点，保存key-value的数据结构；
-ForwardingNode：一个特殊的Node节点，hash值为-1，其中存储nextTable的引用。只有table发生扩容的时候，ForwardingNode才会发挥作用，作为一个占位符放在table中表示当前节点为null或则已经被移动
-sizeCtl：控制标识符，用来控制table初始化和扩容操作的，在不同的地方有不同的用途，其值也不同，所代表的含义也不同
-负数代表正在进行初始化或扩容操作
--1代表正在初始化
--N 表示有N-1个线程正在进行扩容操作
-正数或0代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小
-
-重要内部类
-为了实现ConcurrentHashMap，Doug Lea提供了许多内部类来进行辅助实现，如Node，TreeNode,TreeBin等等。下面我们就一起来看看ConcurrentHashMap几个重要的内部类。
-
-Node
-作为ConcurrentHashMap中最核心、最重要的内部类，Node担负着重要角色：key-value键值对。所有插入ConCurrentHashMap的中数据都将会包装在Node中。定义如下：
-
-    static class Node<K,V> implements Map.Entry<K,V> {
-        final int hash;
-        final K key;
-        volatile V val;             //带有volatile，保证可见性
-        volatile Node<K,V> next;    //下一个节点的指针
-
-        Node(int hash, K key, V val, Node<K,V> next) {
-            this.hash = hash;
-            this.key = key;
-            this.val = val;
-            this.next = next;
-        }
-
-        public final K getKey()       { return key; }
-        public final V getValue()     { return val; }
-        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
-        public final String toString(){ return key + "=" + val; }
-        /** 不允许修改value的值 */
-        public final V setValue(V value) {
-            throw new UnsupportedOperationException();
-        }
-
-        public final boolean equals(Object o) {
-            Object k, v, u; Map.Entry<?,?> e;
-            return ((o instanceof Map.Entry) &&
-                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
-                    (v = e.getValue()) != null &&
-                    (k == key || k.equals(key)) &&
-                    (v == (u = val) || v.equals(u)));
-        }
-
-        /**  赋值get()方法 */
-        Node<K,V> find(int h, Object k) {
-            Node<K,V> e = this;
-            if (k != null) {
-                do {
-                    K ek;
-                    if (e.hash == h &&
-                            ((ek = e.key) == k || (ek != null && k.equals(ek))))
-                        return e;
-                } while ((e = e.next) != null);
-            }
-            return null;
-        }
-    }
-在Node内部类中，其属性value、next都是带有volatile的。同时其对value的setter方法进行了特殊处理，不允许直接调用其setter方法来修改value的值。最后Node还提供了find方法来赋值map.get()。
-
-TreeNode
-我们在学习HashMap的时候就知道，HashMap的核心数据结构就是链表。在ConcurrentHashMap中就不一样了，如果链表的数据过长是会转换为红黑树来处理。当它并不是直接转换，而是将这些链表的节点包装成TreeNode放在TreeBin对象中，然后由TreeBin完成红黑树的转换。所以TreeNode也必须是ConcurrentHashMap的一个核心类，其为树节点类，定义如下：
-
-static final class TreeNode<K,V> extends Node<K,V> {
-        TreeNode<K,V> parent;  // red-black tree links
-        TreeNode<K,V> left;
-        TreeNode<K,V> right;
-        TreeNode<K,V> prev;    // needed to unlink next upon deletion
-        boolean red;
-
-        TreeNode(int hash, K key, V val, Node<K,V> next,
-                 TreeNode<K,V> parent) {
-            super(hash, key, val, next);
-            this.parent = parent;
-        }
-
-
-        Node<K,V> find(int h, Object k) {
-            return findTreeNode(h, k, null);
-        }
-
-        //查找hash为h，key为k的节点
-        final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
-            if (k != null) {
-                TreeNode<K,V> p = this;
-                do  {
-                    int ph, dir; K pk; TreeNode<K,V> q;
-                    TreeNode<K,V> pl = p.left, pr = p.right;
-                    if ((ph = p.hash) > h)
-                        p = pl;
-                    else if (ph < h)
-                        p = pr;
-                    else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
-                        return p;
-                    else if (pl == null)
-                        p = pr;
-                    else if (pr == null)
-                        p = pl;
-                    else if ((kc != null ||
-                            (kc = comparableClassFor(k)) != null) &&
-                            (dir = compareComparables(kc, k, pk)) != 0)
-                        p = (dir < 0) ? pl : pr;
-                    else if ((q = pr.findTreeNode(h, k, kc)) != null)
-                        return q;
-                    else
-                        p = pl;
-                } while (p != null);
-            }
-            return null;
-        }
-    }
-源码展示TreeNode继承Node，且提供了findTreeNode用来查找查找hash为h，key为k的节点。
-
-TreeBin
-该类并不负责key-value的键值对包装，它用于在链表转换为红黑树时包装TreeNode节点，也就是说ConcurrentHashMap红黑树存放是TreeBin，不是TreeNode。该类封装了一系列的方法，包括putTreeVal、lookRoot、UNlookRoot、remove、balanceInsetion、balanceDeletion。由于TreeBin的代码太长我们这里只展示构造方法（构造方法就是构造红黑树的过程）：
-
-    static final class TreeBin<K,V> extends Node<K,V> {
-        TreeNode<K, V> root;
-        volatile TreeNode<K, V> first;
-        volatile Thread waiter;
-        volatile int lockState;
-        static final int WRITER = 1; // set while holding write lock
-        static final int WAITER = 2; // set when waiting for write lock
-        static final int READER = 4; // increment value for setting read lock
-
-        TreeBin(TreeNode<K, V> b) {
-            super(TREEBIN, null, null, null);
-            this.first = b;
-            TreeNode<K, V> r = null;
-            for (TreeNode<K, V> x = b, next; x != null; x = next) {
-                next = (TreeNode<K, V>) x.next;
-                x.left = x.right = null;
-                if (r == null) {
-                    x.parent = null;
-                    x.red = false;
-                    r = x;
-                } else {
-                    K k = x.key;
-                    int h = x.hash;
-                    Class<?> kc = null;
-                    for (TreeNode<K, V> p = r; ; ) {
-                        int dir, ph;
-                        K pk = p.key;
-                        if ((ph = p.hash) > h)
-                            dir = -1;
-                        else if (ph < h)
-                            dir = 1;
-                        else if ((kc == null &&
-                                (kc = comparableClassFor(k)) == null) ||
-                                (dir = compareComparables(kc, k, pk)) == 0)
-                            dir = tieBreakOrder(k, pk);
-                        TreeNode<K, V> xp = p;
-                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
-                            x.parent = xp;
-                            if (dir <= 0)
-                                xp.left = x;
-                            else
-                                xp.right = x;
-                            r = balanceInsertion(r, x);
-                            break;
-                        }
-                    }
-                }
-            }
-            this.root = r;
-            assert checkInvariants(root);
-        }
-
-        /** 省略很多代码 */
-    }
-通过构造方法是不是发现了部分端倪，构造方法就是在构造一个红黑树的过程。
-
-ForwardingNode
-这是一个真正的辅助类，该类仅仅只存活在ConcurrentHashMap扩容操作时。只是一个标志节点，并且指向nextTable，它提供find方法而已。该类也是集成Node节点，其hash为-1，key、value、next均为null。如下：
-
- static final class ForwardingNode<K,V> extends Node<K,V> {
-        final Node<K,V>[] nextTable;
-        ForwardingNode(Node<K,V>[] tab) {
-            super(MOVED, null, null, null);
-            this.nextTable = tab;
-        }
-
-        Node<K,V> find(int h, Object k) {
-            // loop to avoid arbitrarily deep recursion on forwarding nodes
-            outer: for (Node<K,V>[] tab = nextTable;;) {
-                Node<K,V> e; int n;
-                if (k == null || tab == null || (n = tab.length) == 0 ||
-                        (e = tabAt(tab, (n - 1) & h)) == null)
-                    return null;
-                for (;;) {
-                    int eh; K ek;
-                    if ((eh = e.hash) == h &&
-                            ((ek = e.key) == k || (ek != null && k.equals(ek))))
-                        return e;
-                    if (eh < 0) {
-                        if (e instanceof ForwardingNode) {
-                            tab = ((ForwardingNode<K,V>)e).nextTable;
-                            continue outer;
-                        }
-                        else
-                            return e.find(h, k);
-                    }
-                    if ((e = e.next) == null)
-                        return null;
-                }
-            }
-        }
-    }
-构造函数
-ConcurrentHashMap提供了一系列的构造函数用于创建ConcurrentHashMap对象：
-
-    public ConcurrentHashMap() {
-    }
-
-    public ConcurrentHashMap(int initialCapacity) {
-        if (initialCapacity < 0)
-            throw new IllegalArgumentException();
-        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
-                   MAXIMUM_CAPACITY :
-                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
-        this.sizeCtl = cap;
-    }
-
-    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
-        this.sizeCtl = DEFAULT_CAPACITY;
-        putAll(m);
-    }
-
-    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
-        this(initialCapacity, loadFactor, 1);
-    }
-
-    public ConcurrentHashMap(int initialCapacity,
-                             float loadFactor, int concurrencyLevel) {
-        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
-            throw new IllegalArgumentException();
-        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
-            initialCapacity = concurrencyLevel;   // as estimated threads
-        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
-        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
-            MAXIMUM_CAPACITY : tableSizeFor((int)size);
-        this.sizeCtl = cap;
-    }
-初始化： initTable()
-ConcurrentHashMap的初始化主要由initTable()方法实现，在上面的构造函数中我们可以看到，其实ConcurrentHashMap在构造函数中并没有做什么事，仅仅只是设置了一些参数而已。其真正的初始化是发生在插入的时候，例如put、merge、compute、computeIfAbsent、computeIfPresent操作时。其方法定义如下：
-
-    private final Node<K,V>[] initTable() {
-        Node<K,V>[] tab; int sc;
-        while ((tab = table) == null || tab.length == 0) {
-            //sizeCtl < 0 表示有其他线程在初始化，该线程必须挂起
-            if ((sc = sizeCtl) < 0)
-                Thread.yield();
-            // 如果该线程获取了初始化的权利，则用CAS将sizeCtl设置为-1，表示本线程正在初始化
-            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
-                    // 进行初始化
-                try {
-                    if ((tab = table) == null || tab.length == 0) {
-                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
-                        @SuppressWarnings("unchecked")
-                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
-                        table = tab = nt;
-                        // 下次扩容的大小
-                        sc = n - (n >>> 2); ///相当于0.75*n 设置一个扩容的阈值  
-                    }
-                } finally {
-                    sizeCtl = sc;
-                }
-                break;
-            }
-        }
-        return tab;
-    }
-初始化方法initTable()的关键就在于sizeCtl，该值默认为0，如果在构造函数时有参数传入该值则为2的幂次方。该值如果 < 0，表示有其他线程正在初始化，则必须暂停该线程。如果线程获得了初始化的权限则先将sizeCtl设置为-1，防止有其他线程进入，最后将sizeCtl设置0.75 * n，表示扩容的阈值。
-
-put操作
-ConcurrentHashMap最常用的put、get操作，ConcurrentHashMap的put操作与HashMap并没有多大区别，其核心思想依然是根据hash值计算节点插入在table的位置，如果该位置为空，则直接插入，否则插入到链表或者树中。但是ConcurrentHashMap会涉及到多线程情况就会复杂很多。我们先看源代码，然后根据源代码一步一步分析：
-
-public V put(K key, V value) {
-        return putVal(key, value, false);
-    }
-
-    final V putVal(K key, V value, boolean onlyIfAbsent) {
-        //key、value均不能为null
-        if (key == null || value == null) throw new NullPointerException();
-        //计算hash值
-        int hash = spread(key.hashCode());
-        int binCount = 0;
-        for (Node<K,V>[] tab = table;;) {
-            Node<K,V> f; int n, i, fh;
-            // table为null，进行初始化工作
-            if (tab == null || (n = tab.length) == 0)
-                tab = initTable();
-            //如果i位置没有节点，则直接插入，不需要加锁
-            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
-                if (casTabAt(tab, i, null,
-                        new Node<K,V>(hash, key, value, null)))
-                    break;                   // no lock when adding to empty bin
-            }
-            // 有线程正在进行扩容操作，则先帮助扩容
-            else if ((fh = f.hash) == MOVED)
-                tab = helpTransfer(tab, f);
-            else {
-                V oldVal = null;
-                //对该节点进行加锁处理（hash值相同的链表的头节点），对性能有点儿影响
-                synchronized (f) {
-                    if (tabAt(tab, i) == f) {
-                        //fh > 0 表示为链表，将该节点插入到链表尾部
-                        if (fh >= 0) {
-                            binCount = 1;
-                            for (Node<K,V> e = f;; ++binCount) {
-                                K ek;
-                                //hash 和 key 都一样，替换value
-                                if (e.hash == hash &&
-                                        ((ek = e.key) == key ||
-                                                (ek != null && key.equals(ek)))) {
-                                    oldVal = e.val;
-                                    //putIfAbsent()
-                                    if (!onlyIfAbsent)
-                                        e.val = value;
-                                    break;
-                                }
-                                Node<K,V> pred = e;
-                                //链表尾部  直接插入
-                                if ((e = e.next) == null) {
-                                    pred.next = new Node<K,V>(hash, key,
-                                            value, null);
-                                    break;
-                                }
-                            }
-                        }
-                        //树节点，按照树的插入操作进行插入
-                        else if (f instanceof TreeBin) {
-                            Node<K,V> p;
-                            binCount = 2;
-                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
-                                    value)) != null) {
-                                oldVal = p.val;
-                                if (!onlyIfAbsent)
-                                    p.val = value;
-                            }
-                        }
-                    }
-                }
-                if (binCount != 0) {
-                    // 如果链表长度已经达到临界值8 就需要把链表转换为树结构
-                    if (binCount >= TREEIFY_THRESHOLD)
-                        treeifyBin(tab, i);
-                    if (oldVal != null)
-                        return oldVal;
-                    break;
-                }
-            }
-        }
-
-        //size + 1  
-        addCount(1L, binCount);
-        return null;
-    }
-按照上面的源码，我们可以确定put整个流程如下：
-
-判空；ConcurrentHashMap的key、value都不允许为null
-计算hash。利用方法计算hash值。
-    static final int spread(int h) {
-        return (h ^ (h >>> 16)) & HASH_BITS;
-    }
-遍历table，进行节点插入操作，过程如下：
-如果table为空，则表示ConcurrentHashMap还没有初始化，则进行初始化操作：initTable()
-根据hash值获取节点的位置i，若该位置为空，则直接插入，这个过程是不需要加锁的。计算f位置：i=(n - 1) & hash
-如果检测到fh = f.hash == -1，则f是ForwardingNode节点，表示有其他线程正在进行扩容操作，则帮助线程一起进行扩容操作
-如果f.hash >= 0 表示是链表结构，则遍历链表，如果存在当前key节点则替换value，否则插入到链表尾部。如果f是TreeBin类型节点，则按照红黑树的方法更新或者增加节点
-若链表长度 > TREEIFY_THRESHOLD(默认是8)，则将链表转换为红黑树结构
-调用addCount方法，ConcurrentHashMap的size + 1
-这里整个put操作已经完成。
-
-get操作
-ConcurrentHashMap的get操作还是挺简单的，无非就是通过hash来找key相同的节点而已，当然需要区分链表和树形两种情况。
-
-    public V get(Object key) {
-        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
-        // 计算hash
-        int h = spread(key.hashCode());
-        if ((tab = table) != null && (n = tab.length) > 0 &&
-                (e = tabAt(tab, (n - 1) & h)) != null) {
-            // 搜索到的节点key与传入的key相同且不为null,直接返回这个节点
-            if ((eh = e.hash) == h) {
-                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
-                    return e.val;
-            }
-            // 树
-            else if (eh < 0)
-                return (p = e.find(h, key)) != null ? p.val : null;
-            // 链表，遍历
-            while ((e = e.next) != null) {
-                if (e.hash == h &&
-                        ((ek = e.key) == key || (ek != null && key.equals(ek))))
-                    return e.val;
-            }
-        }
-        return null;
-    }
-get操作的整个逻辑非常清楚：
-
-计算hash值
-判断table是否为空，如果为空，直接返回null
-根据hash值获取table中的Node节点（tabAt(tab, (n - 1) & h)），然后根据链表或者树形方式找到相对应的节点，返回其value值。
-size 操作
-ConcurrentHashMap的size()方法我们虽然用得不是很多，但是我们还是很有必要去了解的。ConcurrentHashMap的size()方法返回的是一个不精确的值，因为在进行统计的时候有其他线程正在进行插入和删除操作。当然为了这个不精确的值，ConcurrentHashMap也是操碎了心。
-
-为了更好地统计size，ConcurrentHashMap提供了baseCount、counterCells两个辅助变量和一个CounterCell辅助内部类。
-
-    @sun.misc.Contended static final class CounterCell {
-        volatile long value;
-        CounterCell(long x) { value = x; }
-    }
-
-	//ConcurrentHashMap中元素个数,但返回的不一定是当前Map的真实元素个数。基于CAS无锁更新
-    private transient volatile long baseCount;
-
-    private transient volatile CounterCell[] counterCells;
-这里我们需要清楚CounterCell 的定义
-
-size()方法定义如下：
-
-    public int size() {
-        long n = sumCount();
-        return ((n < 0L) ? 0 :
-                (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
-                (int)n);
-    }
-内部调用sunmCount()：
-
-    final long sumCount() {
-        CounterCell[] as = counterCells; CounterCell a;
-        long sum = baseCount;
-        if (as != null) {
-            for (int i = 0; i < as.length; ++i) {
-                //遍历，所有counter求和
-                if ((a = as[i]) != null)
-                    sum += a.value;     
-            }
-        }
-        return sum;
-    }
-sumCount()就是迭代counterCells来统计sum的过程。我们知道put操作时，肯定会影响size()，我们就来看看CouncurrentHashMap是如何为了这个不和谐的size()操碎了心。
-
-在put()方法最后会调用addCount()方法，该方法主要做两件事，一件更新baseCount的值，第二件检测是否进行扩容，我们只看更新baseCount部分：
-
-    private final void addCount(long x, int check) {
-        CounterCell[] as; long b, s;
-        // s = b + x，完成baseCount++操作；
-        if ((as = counterCells) != null ||
-            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
-            CounterCell a; long v; int m;
-            boolean uncontended = true;
-            if (as == null || (m = as.length - 1) < 0 ||
-                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
-                !(uncontended =
-                  U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
-                //  多线程CAS发生失败时执行
-                fullAddCount(x, uncontended);
-                return;
-            }
-            if (check <= 1)
-                return;
-            s = sumCount();
-        }
-
-		// 检查是否进行扩容
-    }
-x == 1，如果counterCells == null，则U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)，如果并发竞争比较大可能会导致改过程失败，如果失败则最终会调用fullAddCount()方法。其实为了提高高并发的时候baseCount可见性的失败问题，又避免一直重试，JDK 8 引入了类Striped64,其中LongAdder和DoubleAdder都是基于该类实现的，而CounterCell也是基于Striped64实现的。如果counterCells ！= null，且uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)也失败了，同样会调用fullAddCount()方法，最后调用sumCount()计算s。
-
-其实在1.8中，它不推荐size()方法，而是推崇mappingCount()方法，该方法的定义和size()方法基本一致：
-
-    public long mappingCount() {
-        long n = sumCount();
-        return (n < 0L) ? 0L : n; // ignore transient negative values
-    }
-扩容操作
-当ConcurrentHashMap中table元素个数达到了容量阈值（sizeCtl）时，则需要进行扩容操作。在put操作时最后一个会调用addCount(long x, int check)，该方法主要做两个工作：1.更新baseCount；2.检测是否需要扩容操作。如下：
-
-    private final void addCount(long x, int check) {
-        CounterCell[] as; long b, s;
-        // 更新baseCount
-
-        //check >= 0 :则需要进行扩容操作
-        if (check >= 0) {
-            Node<K,V>[] tab, nt; int n, sc;
-            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
-                    (n = tab.length) < MAXIMUM_CAPACITY) {
-                int rs = resizeStamp(n);
-                if (sc < 0) {
-                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
-                            sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
-                            transferIndex <= 0)
-                        break;
-                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
-                        transfer(tab, nt);
-                }
-
-                //当前线程是唯一的或是第一个发起扩容的线程  此时nextTable=null
-                else if (U.compareAndSwapInt(this, SIZECTL, sc,
-                        (rs << RESIZE_STAMP_SHIFT) + 2))
-                    transfer(tab, null);
-                s = sumCount();
-            }
-        }
-    }
-transfer()方法为ConcurrentHashMap扩容操作的核心方法。由于ConcurrentHashMap支持多线程扩容，而且也没有进行加锁，所以实现会变得有点儿复杂。整个扩容操作分为两步：
-
-构建一个nextTable，其大小为原来大小的两倍，这个步骤是在单线程环境下完成的
-将原来table里面的内容复制到nextTable中，这个步骤是允许多线程操作的，所以性能得到提升，减少了扩容的时间消耗
-我们先来看看源代码，然后再一步一步分析：
-
-  private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
-        int n = tab.length, stride;
-        // 每核处理的量小于16，则强制赋值16
-        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
-            stride = MIN_TRANSFER_STRIDE; // subdivide range
-        if (nextTab == null) {            // initiating
-            try {
-                @SuppressWarnings("unchecked")
-                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];        //构建一个nextTable对象，其容量为原来容量的两倍
-                nextTab = nt;
-            } catch (Throwable ex) {      // try to cope with OOME
-                sizeCtl = Integer.MAX_VALUE;
-                return;
-            }
-            nextTable = nextTab;
-            transferIndex = n;
-        }
-        int nextn = nextTab.length;
-        // 连接点指针，用于标志位（fwd的hash值为-1，fwd.nextTable=nextTab）
-        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
-        // 当advance == true时，表明该节点已经处理过了
-        boolean advance = true;
-        boolean finishing = false; // to ensure sweep before committing nextTab
-        for (int i = 0, bound = 0;;) {
-            Node<K,V> f; int fh;
-            // 控制 --i ,遍历原hash表中的节点
-            while (advance) {
-                int nextIndex, nextBound;
-                if (--i >= bound || finishing)
-                    advance = false;
-                else if ((nextIndex = transferIndex) <= 0) {
-                    i = -1;
-                    advance = false;
-                }
-                // 用CAS计算得到的transferIndex
-                else if (U.compareAndSwapInt
-                        (this, TRANSFERINDEX, nextIndex,
-                                nextBound = (nextIndex > stride ?
-                                        nextIndex - stride : 0))) {
-                    bound = nextBound;
-                    i = nextIndex - 1;
-                    advance = false;
-                }
-            }
-            if (i < 0 || i >= n || i + n >= nextn) {
-                int sc;
-                // 已经完成所有节点复制了
-                if (finishing) {
-                    nextTable = null;
-                    table = nextTab;        // table 指向nextTable
-                    sizeCtl = (n << 1) - (n >>> 1);     // sizeCtl阈值为原来的1.5倍
-                    return;     // 跳出死循环，
-                }
-                // CAS 更扩容阈值，在这里面sizectl值减一，说明新加入一个线程参与到扩容操作
-                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
-                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
-                        return;
-                    finishing = advance = true;
-                    i = n; // recheck before commit
-                }
-            }
-            // 遍历的节点为null，则放入到ForwardingNode 指针节点
-            else if ((f = tabAt(tab, i)) == null)
-                advance = casTabAt(tab, i, null, fwd);
-            // f.hash == -1 表示遍历到了ForwardingNode节点，意味着该节点已经处理过了
-            // 这里是控制并发扩容的核心
-            else if ((fh = f.hash) == MOVED)
-                advance = true; // already processed
-            else {
-                // 节点加锁
-                synchronized (f) {
-                    // 节点复制工作
-                    if (tabAt(tab, i) == f) {
-                        Node<K,V> ln, hn;
-                        // fh >= 0 ,表示为链表节点
-                        if (fh >= 0) {
-                            // 构造两个链表  一个是原链表  另一个是原链表的反序排列
-                            int runBit = fh & n;
-                            Node<K,V> lastRun = f;
-                            for (Node<K,V> p = f.next; p != null; p = p.next) {
-                                int b = p.hash & n;
-                                if (b != runBit) {
-                                    runBit = b;
-                                    lastRun = p;
-                                }
-                            }
-                            if (runBit == 0) {
-                                ln = lastRun;
-                                hn = null;
-                            }
-                            else {
-                                hn = lastRun;
-                                ln = null;
-                            }
-                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
-                                int ph = p.hash; K pk = p.key; V pv = p.val;
-                                if ((ph & n) == 0)
-                                    ln = new Node<K,V>(ph, pk, pv, ln);
-                                else
-                                    hn = new Node<K,V>(ph, pk, pv, hn);
-                            }
-                            // 在nextTable i 位置处插上链表
-                            setTabAt(nextTab, i, ln);
-                            // 在nextTable i + n 位置处插上链表
-                            setTabAt(nextTab, i + n, hn);
-                            // 在table i 位置处插上ForwardingNode 表示该节点已经处理过了
-                            setTabAt(tab, i, fwd);
-                            // advance = true 可以执行--i动作，遍历节点
-                            advance = true;
-                        }
-                        // 如果是TreeBin，则按照红黑树进行处理，处理逻辑与上面一致
-                        else if (f instanceof TreeBin) {
-                            TreeBin<K,V> t = (TreeBin<K,V>)f;
-                            TreeNode<K,V> lo = null, loTail = null;
-                            TreeNode<K,V> hi = null, hiTail = null;
-                            int lc = 0, hc = 0;
-                            for (Node<K,V> e = t.first; e != null; e = e.next) {
-                                int h = e.hash;
-                                TreeNode<K,V> p = new TreeNode<K,V>
-                                        (h, e.key, e.val, null, null);
-                                if ((h & n) == 0) {
-                                    if ((p.prev = loTail) == null)
-                                        lo = p;
-                                    else
-                                        loTail.next = p;
-                                    loTail = p;
-                                    ++lc;
-                                }
-                                else {
-                                    if ((p.prev = hiTail) == null)
-                                        hi = p;
-                                    else
-                                        hiTail.next = p;
-                                    hiTail = p;
-                                    ++hc;
-                                }
-                            }
-
-                            // 扩容后树节点个数若<=6，将树转链表
-                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
-                                    (hc != 0) ? new TreeBin<K,V>(lo) : t;
-                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
-                                    (lc != 0) ? new TreeBin<K,V>(hi) : t;
-                            setTabAt(nextTab, i, ln);
-                            setTabAt(nextTab, i + n, hn);
-                            setTabAt(tab, i, fwd);
-                            advance = true;
-                        }
-                    }
-                }
-            }
-        }
-    }
-上面的源码有点儿长，稍微复杂了一些，在这里我们抛弃它多线程环境，我们从单线程角度来看：
-
-为每个内核分任务，并保证其不小于16
-检查nextTable是否为null，如果是，则初始化nextTable，使其容量为table的两倍
-死循环遍历节点，知道finished：节点从table复制到nextTable中，支持并发，请思路如下：
-如果节点 f 为null，则插入ForwardingNode（采用Unsafe.compareAndSwapObjectf方法实现），这个是触发并发扩容的关键
-如果f为链表的头节点（fh >= 0）,则先构造一个反序链表，然后把他们分别放在nextTable的i和i + n位置，并将ForwardingNode 插入原节点位置，代表已经处理过了
-如果f为TreeBin节点，同样也是构造一个反序 ，同时需要判断是否需要进行unTreeify()操作，并把处理的结果分别插入到nextTable的i 和i+nw位置，并插入ForwardingNode 节点
-所有节点复制完成后，则将table指向nextTable，同时更新sizeCtl = nextTable的0.75倍，完成扩容过程
-在多线程环境下，ConcurrentHashMap用两点来保证正确性：ForwardingNode和synchronized。当一个线程遍历到的节点如果是ForwardingNode，则继续往后遍历，如果不是，则将该节点加锁，防止其他线程进入，完成后设置ForwardingNode节点，以便要其他线程可以看到该节点已经处理过了，如此交叉进行，高效而又安全。
-
-下图是扩容的过程（来自：http://blog.csdn.net/u010723709/article/details/48007881）：
-<img src="img/201703050001_24.jpg">
-在put操作时如果发现fh.hash = -1，则表示正在进行扩容操作，则当前线程会协助进行扩容操作。
-
-            else if ((fh = f.hash) == MOVED)
-                tab = helpTransfer(tab, f);
-helpTransfer()方法为协助扩容方法，当调用该方法的时候，nextTable一定已经创建了，所以该方法主要则是进行复制工作。如下：
-
-    final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
-        Node<K,V>[] nextTab; int sc;
-        if (tab != null && (f instanceof ForwardingNode) &&
-                (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
-            int rs = resizeStamp(tab.length);
-            while (nextTab == nextTable && table == tab &&
-                    (sc = sizeCtl) < 0) {
-                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
-                        sc == rs + MAX_RESIZERS || transferIndex <= 0)
-                    break;
-                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
-                    transfer(tab, nextTab);
-                    break;
-                }
-            }
-            return nextTab;
-        }
-        return table;
-    }
-转换红黑树
-在put操作是，如果发现链表结构中的元素超过了TREEIFY_THRESHOLD（默认为8），则会把链表转换为红黑树，已便于提高查询效率。如下：
-
-if (binCount >= TREEIFY_THRESHOLD)
-    treeifyBin(tab, i);
-调用treeifyBin方法用与将链表转换为红黑树。
-
-private final void treeifyBin(Node<K,V>[] tab, int index) {
-        Node<K,V> b; int n, sc;
-        if (tab != null) {
-            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)//如果table.length<64 就扩大一倍 返回
-                tryPresize(n << 1);
-            else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
-                synchronized (b) {
-                    if (tabAt(tab, index) == b) {
-                        TreeNode<K,V> hd = null, tl = null;
-                        //构造了一个TreeBin对象 把所有Node节点包装成TreeNode放进去
-                        for (Node<K,V> e = b; e != null; e = e.next) {
-                            TreeNode<K,V> p =
-                                new TreeNode<K,V>(e.hash, e.key, e.val,
-                                                  null, null);//这里只是利用了TreeNode封装 而没有利用TreeNode的next域和parent域
-                            if ((p.prev = tl) == null)
-                                hd = p;
-                            else
-                                tl.next = p;
-                            tl = p;
-                        }
-                        //在原来index的位置 用TreeBin替换掉原来的Node对象
-                        setTabAt(tab, index, new TreeBin<K,V>(hd));
-                    }
-                }
-            }
-        }
-    }
-从上面源码可以看出，构建红黑树的过程是同步的，进入同步后过程如下：
-
-根据table中index位置Node链表，重新生成一个hd为头结点的TreeNode
-根据hd头结点，生成TreeBin树结构，并用TreeBin替换掉原来的Node对象。
-整个红黑树的构建过程有点儿复杂，关于ConcurrentHashMap 红黑树的构建过程，我们后续分析。
+HashMap是我们用得非常频繁的一个集合，但是由于它是非线程安全的，在多线程环境下，put操作是有可能产生死循环的，导致CPU利用率接近100%。为了解决该问题，提供了Hashtable和Collections.synchronizedMap(hashMap)两种解决方案，但是这两种方案都是对读写加锁，独占式，一个线程在读时其他线程必须等待，吞吐量较低，性能较为低下。故而Doug Lea大神给我们提供了高性能的线程安全HashMap：ConcurrentHashMap。
+
+ConcurrentHashMap的实现
+ConcurrentHashMap作为Concurrent一族，其有着高效地并发操作，相比Hashtable的笨重，ConcurrentHashMap则更胜一筹了。
+
+在1.8版本以前，ConcurrentHashMap采用分段锁的概念，使锁更加细化，但是1.8已经改变了这种思路，而是利用`CAS+Synchronized`来保证并发更新的安全，当然底层采用`数组`+`链表`+`红黑树`的存储结构。
+
+关于1.7和1.8的区别请参考占小狼博客：谈谈ConcurrentHashMap1.7和1.8的不同实现:http://www.jianshu.com/p/e694f1e868ec
+
+我们从如下几个部分全面了解ConcurrentHashMap在1.8中是如何实现的：
+
+重要概念
+重要内部类
+ConcurrentHashMap的初始化
+put操作
+get操作
+size操作
+扩容
+红黑树转换
+
+重要概念
+ConcurrentHashMap定义了如下几个常量：
+
+// 最大容量：2^30=1073741824
+private static final int MAXIMUM_CAPACITY = 1 << 30;
+
+// 默认初始值，必须是2的幕数
+private static final int DEFAULT_CAPACITY = 16;
+
+//
+static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+//
+private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+
+//
+private static final float LOAD_FACTOR = 0.75f;
+
+// 链表转红黑树阀值,> 8 链表转换为红黑树
+static final int TREEIFY_THRESHOLD = 8;
+
+//树转链表阀值，小于等于6（tranfer时，lc、hc=0两个计数器分别++记录原bin、新binTreeNode数量，<=UNTREEIFY_THRESHOLD 则untreeify(lo)）
+static final int UNTREEIFY_THRESHOLD = 6;
+
+//
+static final int MIN_TREEIFY_CAPACITY = 64;
+
+//
+private static final int MIN_TRANSFER_STRIDE = 16;
+
+//
+private static int RESIZE_STAMP_BITS = 16;
+
+// 2^15-1，help resize的最大线程数
+private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
+
+// 32-16=16，sizeCtl中记录size大小的偏移量
+private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
+
+// forwarding nodes的hash值
+static final int MOVED     = -1;
+
+// 树根节点的hash值
+static final int TREEBIN   = -2;
+
+// ReservationNode的hash值
+static final int RESERVED  = -3;
+
+// 可用处理器数量
+static final int NCPU = Runtime.getRuntime().availableProcessors();
+上面是ConcurrentHashMap定义的常量，简单易懂，就不多阐述了。下面介绍ConcurrentHashMap几个很重要的概念。
+
+table：用来存放Node节点数据的，默认为null，默认大小为16的数组，每次扩容时大小总是2的幂次方；
+nextTable：扩容时新生成的数据，数组为table的两倍；
+Node：节点，保存key-value的数据结构；
+ForwardingNode：一个特殊的Node节点，hash值为-1，其中存储nextTable的引用。只有table发生扩容的时候，ForwardingNode才会发挥作用，作为一个占位符放在table中表示当前节点为null或则已经被移动
+sizeCtl：控制标识符，用来控制table初始化和扩容操作的，在不同的地方有不同的用途，其值也不同，所代表的含义也不同
+负数代表正在进行初始化或扩容操作
+-1代表正在初始化
+-N 表示有N-1个线程正在进行扩容操作
+正数或0代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小
+
+重要内部类
+为了实现ConcurrentHashMap，Doug Lea提供了许多内部类来进行辅助实现，如Node，TreeNode,TreeBin等等。下面我们就一起来看看ConcurrentHashMap几个重要的内部类。
+
+Node
+作为ConcurrentHashMap中最核心、最重要的内部类，Node担负着重要角色：key-value键值对。所有插入ConCurrentHashMap的中数据都将会包装在Node中。定义如下：
+
+    static class Node<K,V> implements Map.Entry<K,V> {
+        final int hash;
+        final K key;
+        volatile V val;             //带有volatile，保证可见性
+        volatile Node<K,V> next;    //下一个节点的指针
+
+        Node(int hash, K key, V val, Node<K,V> next) {
+            this.hash = hash;
+            this.key = key;
+            this.val = val;
+            this.next = next;
+        }
+
+        public final K getKey()       { return key; }
+        public final V getValue()     { return val; }
+        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
+        public final String toString(){ return key + "=" + val; }
+        /** 不允许修改value的值 */
+        public final V setValue(V value) {
+            throw new UnsupportedOperationException();
+        }
+
+        public final boolean equals(Object o) {
+            Object k, v, u; Map.Entry<?,?> e;
+            return ((o instanceof Map.Entry) &&
+                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
+                    (v = e.getValue()) != null &&
+                    (k == key || k.equals(key)) &&
+                    (v == (u = val) || v.equals(u)));
+        }
+
+        /**  赋值get()方法 */
+        Node<K,V> find(int h, Object k) {
+            Node<K,V> e = this;
+            if (k != null) {
+                do {
+                    K ek;
+                    if (e.hash == h &&
+                            ((ek = e.key) == k || (ek != null && k.equals(ek))))
+                        return e;
+                } while ((e = e.next) != null);
+            }
+            return null;
+        }
+    }
+在Node内部类中，其属性value、next都是带有volatile的。同时其对value的setter方法进行了特殊处理，不允许直接调用其setter方法来修改value的值。最后Node还提供了find方法来赋值map.get()。
+
+TreeNode
+我们在学习HashMap的时候就知道，HashMap的核心数据结构就是链表。在ConcurrentHashMap中就不一样了，如果链表的数据过长是会转换为红黑树来处理。当它并不是直接转换，而是将这些链表的节点包装成TreeNode放在TreeBin对象中，然后由TreeBin完成红黑树的转换。所以TreeNode也必须是ConcurrentHashMap的一个核心类，其为树节点类，定义如下：
+
+static final class TreeNode<K,V> extends Node<K,V> {
+        TreeNode<K,V> parent;  // red-black tree links
+        TreeNode<K,V> left;
+        TreeNode<K,V> right;
+        TreeNode<K,V> prev;    // needed to unlink next upon deletion
+        boolean red;
+
+        TreeNode(int hash, K key, V val, Node<K,V> next,
+                 TreeNode<K,V> parent) {
+            super(hash, key, val, next);
+            this.parent = parent;
+        }
+
+
+        Node<K,V> find(int h, Object k) {
+            return findTreeNode(h, k, null);
+        }
+
+        //查找hash为h，key为k的节点
+        final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
+            if (k != null) {
+                TreeNode<K,V> p = this;
+                do  {
+                    int ph, dir; K pk; TreeNode<K,V> q;
+                    TreeNode<K,V> pl = p.left, pr = p.right;
+                    if ((ph = p.hash) > h)
+                        p = pl;
+                    else if (ph < h)
+                        p = pr;
+                    else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
+                        return p;
+                    else if (pl == null)
+                        p = pr;
+                    else if (pr == null)
+                        p = pl;
+                    else if ((kc != null ||
+                            (kc = comparableClassFor(k)) != null) &&
+                            (dir = compareComparables(kc, k, pk)) != 0)
+                        p = (dir < 0) ? pl : pr;
+                    else if ((q = pr.findTreeNode(h, k, kc)) != null)
+                        return q;
+                    else
+                        p = pl;
+                } while (p != null);
+            }
+            return null;
+        }
+    }
+源码展示TreeNode继承Node，且提供了findTreeNode用来查找查找hash为h，key为k的节点。
+
+TreeBin
+该类并不负责key-value的键值对包装，它用于在链表转换为红黑树时包装TreeNode节点，也就是说ConcurrentHashMap红黑树存放是TreeBin，不是TreeNode。该类封装了一系列的方法，包括putTreeVal、lookRoot、UNlookRoot、remove、balanceInsetion、balanceDeletion。由于TreeBin的代码太长我们这里只展示构造方法（构造方法就是构造红黑树的过程）：
+
+    static final class TreeBin<K,V> extends Node<K,V> {
+        TreeNode<K, V> root;
+        volatile TreeNode<K, V> first;
+        volatile Thread waiter;
+        volatile int lockState;
+        static final int WRITER = 1; // set while holding write lock
+        static final int WAITER = 2; // set when waiting for write lock
+        static final int READER = 4; // increment value for setting read lock
+
+        TreeBin(TreeNode<K, V> b) {
+            super(TREEBIN, null, null, null);
+            this.first = b;
+            TreeNode<K, V> r = null;
+            for (TreeNode<K, V> x = b, next; x != null; x = next) {
+                next = (TreeNode<K, V>) x.next;
+                x.left = x.right = null;
+                if (r == null) {
+                    x.parent = null;
+                    x.red = false;
+                    r = x;
+                } else {
+                    K k = x.key;
+                    int h = x.hash;
+                    Class<?> kc = null;
+                    for (TreeNode<K, V> p = r; ; ) {
+                        int dir, ph;
+                        K pk = p.key;
+                        if ((ph = p.hash) > h)
+                            dir = -1;
+                        else if (ph < h)
+                            dir = 1;
+                        else if ((kc == null &&
+                                (kc = comparableClassFor(k)) == null) ||
+                                (dir = compareComparables(kc, k, pk)) == 0)
+                            dir = tieBreakOrder(k, pk);
+                        TreeNode<K, V> xp = p;
+                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
+                            x.parent = xp;
+                            if (dir <= 0)
+                                xp.left = x;
+                            else
+                                xp.right = x;
+                            r = balanceInsertion(r, x);
+                            break;
+                        }
+                    }
+                }
+            }
+            this.root = r;
+            assert checkInvariants(root);
+        }
+
+        /** 省略很多代码 */
+    }
+通过构造方法是不是发现了部分端倪，构造方法就是在构造一个红黑树的过程。
+
+ForwardingNode
+这是一个真正的辅助类，该类仅仅只存活在ConcurrentHashMap扩容操作时。只是一个标志节点，并且指向nextTable，它提供find方法而已。该类也是集成Node节点，其hash为-1，key、value、next均为null。如下：
+
+ static final class ForwardingNode<K,V> extends Node<K,V> {
+        final Node<K,V>[] nextTable;
+        ForwardingNode(Node<K,V>[] tab) {
+            super(MOVED, null, null, null);
+            this.nextTable = tab;
+        }
+
+        Node<K,V> find(int h, Object k) {
+            // loop to avoid arbitrarily deep recursion on forwarding nodes
+            outer: for (Node<K,V>[] tab = nextTable;;) {
+                Node<K,V> e; int n;
+                if (k == null || tab == null || (n = tab.length) == 0 ||
+                        (e = tabAt(tab, (n - 1) & h)) == null)
+                    return null;
+                for (;;) {
+                    int eh; K ek;
+                    if ((eh = e.hash) == h &&
+                            ((ek = e.key) == k || (ek != null && k.equals(ek))))
+                        return e;
+                    if (eh < 0) {
+                        if (e instanceof ForwardingNode) {
+                            tab = ((ForwardingNode<K,V>)e).nextTable;
+                            continue outer;
+                        }
+                        else
+                            return e.find(h, k);
+                    }
+                    if ((e = e.next) == null)
+                        return null;
+                }
+            }
+        }
+    }
+构造函数
+ConcurrentHashMap提供了一系列的构造函数用于创建ConcurrentHashMap对象：
+
+    public ConcurrentHashMap() {
+    }
+
+    public ConcurrentHashMap(int initialCapacity) {
+        if (initialCapacity < 0)
+            throw new IllegalArgumentException();
+        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
+                   MAXIMUM_CAPACITY :
+                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
+        this.sizeCtl = cap;
+    }
+
+    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
+        this.sizeCtl = DEFAULT_CAPACITY;
+        putAll(m);
+    }
+
+    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
+        this(initialCapacity, loadFactor, 1);
+    }
+
+    public ConcurrentHashMap(int initialCapacity,
+                             float loadFactor, int concurrencyLevel) {
+        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
+            throw new IllegalArgumentException();
+        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
+            initialCapacity = concurrencyLevel;   // as estimated threads
+        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
+        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
+            MAXIMUM_CAPACITY : tableSizeFor((int)size);
+        this.sizeCtl = cap;
+    }
+初始化： initTable()
+ConcurrentHashMap的初始化主要由initTable()方法实现，在上面的构造函数中我们可以看到，其实ConcurrentHashMap在构造函数中并没有做什么事，仅仅只是设置了一些参数而已。其真正的初始化是发生在插入的时候，例如put、merge、compute、computeIfAbsent、computeIfPresent操作时。其方法定义如下：
+
+    private final Node<K,V>[] initTable() {
+        Node<K,V>[] tab; int sc;
+        while ((tab = table) == null || tab.length == 0) {
+            //sizeCtl < 0 表示有其他线程在初始化，该线程必须挂起
+            if ((sc = sizeCtl) < 0)
+                Thread.yield();
+            // 如果该线程获取了初始化的权利，则用CAS将sizeCtl设置为-1，表示本线程正在初始化
+            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
+                    // 进行初始化
+                try {
+                    if ((tab = table) == null || tab.length == 0) {
+                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
+                        @SuppressWarnings("unchecked")
+                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
+                        table = tab = nt;
+                        // 下次扩容的大小
+                        sc = n - (n >>> 2); ///相当于0.75*n 设置一个扩容的阈值  
+                    }
+                } finally {
+                    sizeCtl = sc;
+                }
+                break;
+            }
+        }
+        return tab;
+    }
+初始化方法initTable()的关键就在于sizeCtl，该值默认为0，如果在构造函数时有参数传入该值则为2的幂次方。该值如果 < 0，表示有其他线程正在初始化，则必须暂停该线程。如果线程获得了初始化的权限则先将sizeCtl设置为-1，防止有其他线程进入，最后将sizeCtl设置0.75 * n，表示扩容的阈值。
+
+put操作
+ConcurrentHashMap最常用的put、get操作，ConcurrentHashMap的put操作与HashMap并没有多大区别，其核心思想依然是根据hash值计算节点插入在table的位置，如果该位置为空，则直接插入，否则插入到链表或者树中。但是ConcurrentHashMap会涉及到多线程情况就会复杂很多。我们先看源代码，然后根据源代码一步一步分析：
+
+public V put(K key, V value) {
+        return putVal(key, value, false);
+    }
+
+    final V putVal(K key, V value, boolean onlyIfAbsent) {
+        //key、value均不能为null
+        if (key == null || value == null) throw new NullPointerException();
+        //计算hash值
+        int hash = spread(key.hashCode());
+        int binCount = 0;
+        for (Node<K,V>[] tab = table;;) {
+            Node<K,V> f; int n, i, fh;
+            // table为null，进行初始化工作
+            if (tab == null || (n = tab.length) == 0)
+                tab = initTable();
+            //如果i位置没有节点，则直接插入，不需要加锁
+            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
+                if (casTabAt(tab, i, null,
+                        new Node<K,V>(hash, key, value, null)))
+                    break;                   // no lock when adding to empty bin
+            }
+            // 有线程正在进行扩容操作，则先帮助扩容
+            else if ((fh = f.hash) == MOVED)
+                tab = helpTransfer(tab, f);
+            else {
+                V oldVal = null;
+                //对该节点进行加锁处理（hash值相同的链表的头节点），对性能有点儿影响
+                synchronized (f) {
+                    if (tabAt(tab, i) == f) {
+                        //fh > 0 表示为链表，将该节点插入到链表尾部
+                        if (fh >= 0) {
+                            binCount = 1;
+                            for (Node<K,V> e = f;; ++binCount) {
+                                K ek;
+                                //hash 和 key 都一样，替换value
+                                if (e.hash == hash &&
+                                        ((ek = e.key) == key ||
+                                                (ek != null && key.equals(ek)))) {
+                                    oldVal = e.val;
+                                    //putIfAbsent()
+                                    if (!onlyIfAbsent)
+                                        e.val = value;
+                                    break;
+                                }
+                                Node<K,V> pred = e;
+                                //链表尾部  直接插入
+                                if ((e = e.next) == null) {
+                                    pred.next = new Node<K,V>(hash, key,
+                                            value, null);
+                                    break;
+                                }
+                            }
+                        }
+                        //树节点，按照树的插入操作进行插入
+                        else if (f instanceof TreeBin) {
+                            Node<K,V> p;
+                            binCount = 2;
+                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
+                                    value)) != null) {
+                                oldVal = p.val;
+                                if (!onlyIfAbsent)
+                                    p.val = value;
+                            }
+                        }
+                    }
+                }
+                if (binCount != 0) {
+                    // 如果链表长度已经达到临界值8 就需要把链表转换为树结构
+                    if (binCount >= TREEIFY_THRESHOLD)
+                        treeifyBin(tab, i);
+                    if (oldVal != null)
+                        return oldVal;
+                    break;
+                }
+            }
+        }
+
+        //size + 1  
+        addCount(1L, binCount);
+        return null;
+    }
+按照上面的源码，我们可以确定put整个流程如下：
+
+判空；ConcurrentHashMap的key、value都不允许为null
+计算hash。利用方法计算hash值。
+    static final int spread(int h) {
+        return (h ^ (h >>> 16)) & HASH_BITS;
+    }
+遍历table，进行节点插入操作，过程如下：
+如果table为空，则表示ConcurrentHashMap还没有初始化，则进行初始化操作：initTable()
+根据hash值获取节点的位置i，若该位置为空，则直接插入，这个过程是不需要加锁的。计算f位置：i=(n - 1) & hash
+如果检测到fh = f.hash == -1，则f是ForwardingNode节点，表示有其他线程正在进行扩容操作，则帮助线程一起进行扩容操作
+如果f.hash >= 0 表示是链表结构，则遍历链表，如果存在当前key节点则替换value，否则插入到链表尾部。如果f是TreeBin类型节点，则按照红黑树的方法更新或者增加节点
+若链表长度 > TREEIFY_THRESHOLD(默认是8)，则将链表转换为红黑树结构
+调用addCount方法，ConcurrentHashMap的size + 1
+这里整个put操作已经完成。
+
+get操作
+ConcurrentHashMap的get操作还是挺简单的，无非就是通过hash来找key相同的节点而已，当然需要区分链表和树形两种情况。
+
+    public V get(Object key) {
+        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
+        // 计算hash
+        int h = spread(key.hashCode());
+        if ((tab = table) != null && (n = tab.length) > 0 &&
+                (e = tabAt(tab, (n - 1) & h)) != null) {
+            // 搜索到的节点key与传入的key相同且不为null,直接返回这个节点
+            if ((eh = e.hash) == h) {
+                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
+                    return e.val;
+            }
+            // 树
+            else if (eh < 0)
+                return (p = e.find(h, key)) != null ? p.val : null;
+            // 链表，遍历
+            while ((e = e.next) != null) {
+                if (e.hash == h &&
+                        ((ek = e.key) == key || (ek != null && key.equals(ek))))
+                    return e.val;
+            }
+        }
+        return null;
+    }
+get操作的整个逻辑非常清楚：
+
+计算hash值
+判断table是否为空，如果为空，直接返回null
+根据hash值获取table中的Node节点（tabAt(tab, (n - 1) & h)），然后根据链表或者树形方式找到相对应的节点，返回其value值。
+size 操作
+ConcurrentHashMap的size()方法我们虽然用得不是很多，但是我们还是很有必要去了解的。ConcurrentHashMap的size()方法返回的是一个不精确的值，因为在进行统计的时候有其他线程正在进行插入和删除操作。当然为了这个不精确的值，ConcurrentHashMap也是操碎了心。
+
+为了更好地统计size，ConcurrentHashMap提供了baseCount、counterCells两个辅助变量和一个CounterCell辅助内部类。
+
+    @sun.misc.Contended static final class CounterCell {
+        volatile long value;
+        CounterCell(long x) { value = x; }
+    }
+
+	//ConcurrentHashMap中元素个数,但返回的不一定是当前Map的真实元素个数。基于CAS无锁更新
+    private transient volatile long baseCount;
+
+    private transient volatile CounterCell[] counterCells;
+这里我们需要清楚CounterCell 的定义
+
+size()方法定义如下：
+
+    public int size() {
+        long n = sumCount();
+        return ((n < 0L) ? 0 :
+                (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
+                (int)n);
+    }
+内部调用sunmCount()：
+
+    final long sumCount() {
+        CounterCell[] as = counterCells; CounterCell a;
+        long sum = baseCount;
+        if (as != null) {
+            for (int i = 0; i < as.length; ++i) {
+                //遍历，所有counter求和
+                if ((a = as[i]) != null)
+                    sum += a.value;     
+            }
+        }
+        return sum;
+    }
+sumCount()就是迭代counterCells来统计sum的过程。我们知道put操作时，肯定会影响size()，我们就来看看CouncurrentHashMap是如何为了这个不和谐的size()操碎了心。
+
+在put()方法最后会调用addCount()方法，该方法主要做两件事，一件更新baseCount的值，第二件检测是否进行扩容，我们只看更新baseCount部分：
+
+    private final void addCount(long x, int check) {
+        CounterCell[] as; long b, s;
+        // s = b + x，完成baseCount++操作；
+        if ((as = counterCells) != null ||
+            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
+            CounterCell a; long v; int m;
+            boolean uncontended = true;
+            if (as == null || (m = as.length - 1) < 0 ||
+                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
+                !(uncontended =
+                  U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
+                //  多线程CAS发生失败时执行
+                fullAddCount(x, uncontended);
+                return;
+            }
+            if (check <= 1)
+                return;
+            s = sumCount();
+        }
+
+		// 检查是否进行扩容
+    }
+x == 1，如果counterCells == null，则U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)，如果并发竞争比较大可能会导致改过程失败，如果失败则最终会调用fullAddCount()方法。其实为了提高高并发的时候baseCount可见性的失败问题，又避免一直重试，JDK 8 引入了类Striped64,其中LongAdder和DoubleAdder都是基于该类实现的，而CounterCell也是基于Striped64实现的。如果counterCells ！= null，且uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)也失败了，同样会调用fullAddCount()方法，最后调用sumCount()计算s。
+
+其实在1.8中，它不推荐size()方法，而是推崇mappingCount()方法，该方法的定义和size()方法基本一致：
+
+    public long mappingCount() {
+        long n = sumCount();
+        return (n < 0L) ? 0L : n; // ignore transient negative values
+    }
+扩容操作
+当ConcurrentHashMap中table元素个数达到了容量阈值（sizeCtl）时，则需要进行扩容操作。在put操作时最后一个会调用addCount(long x, int check)，该方法主要做两个工作：1.更新baseCount；2.检测是否需要扩容操作。如下：
+
+    private final void addCount(long x, int check) {
+        CounterCell[] as; long b, s;
+        // 更新baseCount
+
+        //check >= 0 :则需要进行扩容操作
+        if (check >= 0) {
+            Node<K,V>[] tab, nt; int n, sc;
+            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
+                    (n = tab.length) < MAXIMUM_CAPACITY) {
+                int rs = resizeStamp(n);
+                if (sc < 0) {
+                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
+                            sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
+                            transferIndex <= 0)
+                        break;
+                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
+                        transfer(tab, nt);
+                }
+
+                //当前线程是唯一的或是第一个发起扩容的线程  此时nextTable=null
+                else if (U.compareAndSwapInt(this, SIZECTL, sc,
+                        (rs << RESIZE_STAMP_SHIFT) + 2))
+                    transfer(tab, null);
+                s = sumCount();
+            }
+        }
+    }
+transfer()方法为ConcurrentHashMap扩容操作的核心方法。由于ConcurrentHashMap支持多线程扩容，而且也没有进行加锁，所以实现会变得有点儿复杂。整个扩容操作分为两步：
+
+构建一个nextTable，其大小为原来大小的两倍，这个步骤是在单线程环境下完成的
+将原来table里面的内容复制到nextTable中，这个步骤是允许多线程操作的，所以性能得到提升，减少了扩容的时间消耗
+我们先来看看源代码，然后再一步一步分析：
+
+  private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
+        int n = tab.length, stride;
+        // 每核处理的量小于16，则强制赋值16
+        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
+            stride = MIN_TRANSFER_STRIDE; // subdivide range
+        if (nextTab == null) {            // initiating
+            try {
+                @SuppressWarnings("unchecked")
+                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];        //构建一个nextTable对象，其容量为原来容量的两倍
+                nextTab = nt;
+            } catch (Throwable ex) {      // try to cope with OOME
+                sizeCtl = Integer.MAX_VALUE;
+                return;
+            }
+            nextTable = nextTab;
+            transferIndex = n;
+        }
+        int nextn = nextTab.length;
+        // 连接点指针，用于标志位（fwd的hash值为-1，fwd.nextTable=nextTab）
+        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
+        // 当advance == true时，表明该节点已经处理过了
+        boolean advance = true;
+        boolean finishing = false; // to ensure sweep before committing nextTab
+        for (int i = 0, bound = 0;;) {
+            Node<K,V> f; int fh;
+            // 控制 --i ,遍历原hash表中的节点
+            while (advance) {
+                int nextIndex, nextBound;
+                if (--i >= bound || finishing)
+                    advance = false;
+                else if ((nextIndex = transferIndex) <= 0) {
+                    i = -1;
+                    advance = false;
+                }
+                // 用CAS计算得到的transferIndex
+                else if (U.compareAndSwapInt
+                        (this, TRANSFERINDEX, nextIndex,
+                                nextBound = (nextIndex > stride ?
+                                        nextIndex - stride : 0))) {
+                    bound = nextBound;
+                    i = nextIndex - 1;
+                    advance = false;
+                }
+            }
+            if (i < 0 || i >= n || i + n >= nextn) {
+                int sc;
+                // 已经完成所有节点复制了
+                if (finishing) {
+                    nextTable = null;
+                    table = nextTab;        // table 指向nextTable
+                    sizeCtl = (n << 1) - (n >>> 1);     // sizeCtl阈值为原来的1.5倍
+                    return;     // 跳出死循环，
+                }
+                // CAS 更扩容阈值，在这里面sizectl值减一，说明新加入一个线程参与到扩容操作
+                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
+                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
+                        return;
+                    finishing = advance = true;
+                    i = n; // recheck before commit
+                }
+            }
+            // 遍历的节点为null，则放入到ForwardingNode 指针节点
+            else if ((f = tabAt(tab, i)) == null)
+                advance = casTabAt(tab, i, null, fwd);
+            // f.hash == -1 表示遍历到了ForwardingNode节点，意味着该节点已经处理过了
+            // 这里是控制并发扩容的核心
+            else if ((fh = f.hash) == MOVED)
+                advance = true; // already processed
+            else {
+                // 节点加锁
+                synchronized (f) {
+                    // 节点复制工作
+                    if (tabAt(tab, i) == f) {
+                        Node<K,V> ln, hn;
+                        // fh >= 0 ,表示为链表节点
+                        if (fh >= 0) {
+                            // 构造两个链表  一个是原链表  另一个是原链表的反序排列
+                            int runBit = fh & n;
+                            Node<K,V> lastRun = f;
+                            for (Node<K,V> p = f.next; p != null; p = p.next) {
+                                int b = p.hash & n;
+                                if (b != runBit) {
+                                    runBit = b;
+                                    lastRun = p;
+                                }
+                            }
+                            if (runBit == 0) {
+                                ln = lastRun;
+                                hn = null;
+                            }
+                            else {
+                                hn = lastRun;
+                                ln = null;
+                            }
+                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
+                                int ph = p.hash; K pk = p.key; V pv = p.val;
+                                if ((ph & n) == 0)
+                                    ln = new Node<K,V>(ph, pk, pv, ln);
+                                else
+                                    hn = new Node<K,V>(ph, pk, pv, hn);
+                            }
+                            // 在nextTable i 位置处插上链表
+                            setTabAt(nextTab, i, ln);
+                            // 在nextTable i + n 位置处插上链表
+                            setTabAt(nextTab, i + n, hn);
+                            // 在table i 位置处插上ForwardingNode 表示该节点已经处理过了
+                            setTabAt(tab, i, fwd);
+                            // advance = true 可以执行--i动作，遍历节点
+                            advance = true;
+                        }
+                        // 如果是TreeBin，则按照红黑树进行处理，处理逻辑与上面一致
+                        else if (f instanceof TreeBin) {
+                            TreeBin<K,V> t = (TreeBin<K,V>)f;
+                            TreeNode<K,V> lo = null, loTail = null;
+                            TreeNode<K,V> hi = null, hiTail = null;
+                            int lc = 0, hc = 0;
+                            for (Node<K,V> e = t.first; e != null; e = e.next) {
+                                int h = e.hash;
+                                TreeNode<K,V> p = new TreeNode<K,V>
+                                        (h, e.key, e.val, null, null);
+                                if ((h & n) == 0) {
+                                    if ((p.prev = loTail) == null)
+                                        lo = p;
+                                    else
+                                        loTail.next = p;
+                                    loTail = p;
+                                    ++lc;
+                                }
+                                else {
+                                    if ((p.prev = hiTail) == null)
+                                        hi = p;
+                                    else
+                                        hiTail.next = p;
+                                    hiTail = p;
+                                    ++hc;
+                                }
+                            }
+
+                            // 扩容后树节点个数若<=6，将树转链表
+                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
+                                    (hc != 0) ? new TreeBin<K,V>(lo) : t;
+                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
+                                    (lc != 0) ? new TreeBin<K,V>(hi) : t;
+                            setTabAt(nextTab, i, ln);
+                            setTabAt(nextTab, i + n, hn);
+                            setTabAt(tab, i, fwd);
+                            advance = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+上面的源码有点儿长，稍微复杂了一些，在这里我们抛弃它多线程环境，我们从单线程角度来看：
+
+为每个内核分任务，并保证其不小于16
+检查nextTable是否为null，如果是，则初始化nextTable，使其容量为table的两倍
+死循环遍历节点，知道finished：节点从table复制到nextTable中，支持并发，请思路如下：
+如果节点 f 为null，则插入ForwardingNode（采用Unsafe.compareAndSwapObjectf方法实现），这个是触发并发扩容的关键
+如果f为链表的头节点（fh >= 0）,则先构造一个反序链表，然后把他们分别放在nextTable的i和i + n位置，并将ForwardingNode 插入原节点位置，代表已经处理过了
+如果f为TreeBin节点，同样也是构造一个反序 ，同时需要判断是否需要进行unTreeify()操作，并把处理的结果分别插入到nextTable的i 和i+nw位置，并插入ForwardingNode 节点
+所有节点复制完成后，则将table指向nextTable，同时更新sizeCtl = nextTable的0.75倍，完成扩容过程
+在多线程环境下，ConcurrentHashMap用两点来保证正确性：ForwardingNode和synchronized。当一个线程遍历到的节点如果是ForwardingNode，则继续往后遍历，如果不是，则将该节点加锁，防止其他线程进入，完成后设置ForwardingNode节点，以便要其他线程可以看到该节点已经处理过了，如此交叉进行，高效而又安全。
+
+下图是扩容的过程（来自：http://blog.csdn.net/u010723709/article/details/48007881）：
+<img src="img/201703050001_24.jpg">
+在put操作时如果发现fh.hash = -1，则表示正在进行扩容操作，则当前线程会协助进行扩容操作。
+
+            else if ((fh = f.hash) == MOVED)
+                tab = helpTransfer(tab, f);
+helpTransfer()方法为协助扩容方法，当调用该方法的时候，nextTable一定已经创建了，所以该方法主要则是进行复制工作。如下：
+
+    final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
+        Node<K,V>[] nextTab; int sc;
+        if (tab != null && (f instanceof ForwardingNode) &&
+                (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
+            int rs = resizeStamp(tab.length);
+            while (nextTab == nextTable && table == tab &&
+                    (sc = sizeCtl) < 0) {
+                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
+                        sc == rs + MAX_RESIZERS || transferIndex <= 0)
+                    break;
+                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
+                    transfer(tab, nextTab);
+                    break;
+                }
+            }
+            return nextTab;
+        }
+        return table;
+    }
+转换红黑树
+在put操作是，如果发现链表结构中的元素超过了TREEIFY_THRESHOLD（默认为8），则会把链表转换为红黑树，已便于提高查询效率。如下：
+
+if (binCount >= TREEIFY_THRESHOLD)
+    treeifyBin(tab, i);
+调用treeifyBin方法用与将链表转换为红黑树。
+
+private final void treeifyBin(Node<K,V>[] tab, int index) {
+        Node<K,V> b; int n, sc;
+        if (tab != null) {
+            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)//如果table.length<64 就扩大一倍 返回
+                tryPresize(n << 1);
+            else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
+                synchronized (b) {
+                    if (tabAt(tab, index) == b) {
+                        TreeNode<K,V> hd = null, tl = null;
+                        //构造了一个TreeBin对象 把所有Node节点包装成TreeNode放进去
+                        for (Node<K,V> e = b; e != null; e = e.next) {
+                            TreeNode<K,V> p =
+                                new TreeNode<K,V>(e.hash, e.key, e.val,
+                                                  null, null);//这里只是利用了TreeNode封装 而没有利用TreeNode的next域和parent域
+                            if ((p.prev = tl) == null)
+                                hd = p;
+                            else
+                                tl.next = p;
+                            tl = p;
+                        }
+                        //在原来index的位置 用TreeBin替换掉原来的Node对象
+                        setTabAt(tab, index, new TreeBin<K,V>(hd));
+                    }
+                }
+            }
+        }
+    }
+从上面源码可以看出，构建红黑树的过程是同步的，进入同步后过程如下：
+
+根据table中index位置Node链表，重新生成一个hd为头结点的TreeNode
+根据hd头结点，生成TreeBin树结构，并用TreeBin替换掉原来的Node对象。
+整个红黑树的构建过程有点儿复杂，关于ConcurrentHashMap 红黑树的构建过程，我们后续分析。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/21 - J.U.C\344\271\213ConcurrentHashMap\347\272\242\351\273\221\346\240\221\350\275\254\346\215\242\345\210\206\346\236\220.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/21 - J.U.C\344\271\213ConcurrentHashMap\347\272\242\351\273\221\346\240\221\350\275\254\346\215\242\345\210\206\346\236\220.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/21 - J.U.C\344\271\213ConcurrentHashMap\347\272\242\351\273\221\346\240\221\350\275\254\346\215\242\345\210\206\346\236\220.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/21 - J.U.C\344\271\213ConcurrentHashMap\347\272\242\351\273\221\346\240\221\350\275\254\346\215\242\345\210\206\346\236\220.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentLinkedQueue.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentLinkedQueue.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentLinkedQueue.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentLinkedQueue.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentSkipListMap.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentSkipListMap.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentSkipListMap.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/22 - J.U.C\344\271\213Java\345\271\266\345\217\221\345\256\271\345\231\250\357\274\232ConcurrentSkipListMap.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/23 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232ArrayBlockingQueue.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/23 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232ArrayBlockingQueue.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/23 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232ArrayBlockingQueue.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/23 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232ArrayBlockingQueue.md"
index bd44363e..9e3f6c14 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/23 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232ArrayBlockingQueue.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/23 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232ArrayBlockingQueue.md"	
@@ -1,141 +1,141 @@
-ArrayBlockingQueue，一个由 **数组实现的有界阻塞队列**。该队列采用FIFO的原则对元素进行排序添加的。
-
-ArrayBlockingQueue为 **有界且固定，其大小在构造时由构造函数来决定，确认之后就不能再改变了**。ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略，但是在 **默认情况下不保证线程公平的访问**，在构造时可以选择公平策略（fair = true）。公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。
-
-先看ArrayBlockingQueue的定义：
-```java
-public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable {
-    private static final long serialVersionUID = -817911632652898426L;
-    final Object[] items;
-    int takeIndex;
-    int putIndex;
-    int count;
-    // 重入锁
-    final ReentrantLock lock;
-    // notEmpty condition
-    private final Condition notEmpty;
-    // notFull condition
-    private final Condition notFull;
-    transient ArrayBlockingQueue.Itrs itrs;
-}
-```
-可以清楚地看到ArrayBlockingQueue继承`AbstractQueue`，实现`BlockingQueue`接口。看过java.util包源码的同学应该都认识AbstractQueue，该类在Queue接口中扮演着非常重要的作用，该类提供了对queue操作的骨干实现（具体内容移驾其源码）。BlockingQueue继承java.util.Queue为阻塞队列的核心接口，提供了在多线程环境下的出列、入列操作，作为使用者，则不需要关心队列在什么时候阻塞线程，什么时候唤醒线程，所有一切均由BlockingQueue来完成。
-
-ArrayBlockingQueue **内部使用可重入锁 `ReentrantLock` + `Condition`来完成多线程环境的并发操作**。
-
-* `items`，一个定长数组，维护ArrayBlockingQueue的元素
-* `takeIndex`，int，为ArrayBlockingQueue队首位置
-* `putIndex`，int，ArrayBlockingQueue队尾位置
-* `count`，元素个数
-* `lock`，锁，ArrayBlockingQueue出列入列都必须获取该锁，两个步骤公用一个锁
-* `notEmpty`，出列条件
-* `notFull`，入列条件
-
-### 入队
-ArrayBlockingQueue提供了诸多方法，可以将元素加入队列尾部。
-
-* add(E e) ：将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则抛出 IllegalStateException
-* offer(E e) :将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回 false
-* offer(E e, long timeout, TimeUnit unit) :将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间
-* put(E e) :将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间
-
-
-方法较多，我们就分析一个方法：add(E e)：
-```java
-    public boolean add(E e) {
-        return super.add(e);
-    }
-
-    AbstractQueue.java
-    public boolean add(E e) {
-        if (offer(e))
-            return true;
-        else
-            throw new IllegalStateException("Queue full");
-    }
-```
-add方法调用offer(E e)，如果返回false，则直接抛出`IllegalStateException`异常。offer(E e)为`ArrayBlockingQueue实现`：
-```java
-    public boolean offer(E e) {
-        checkNotNull(e);
-        final ReentrantLock lock = this.lock;
-        lock.lock();
-        try {
-            if (count == items.length)
-                return false;
-            else {
-                enqueue(e);
-                return true;
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-```
-方法首先检查是否为null，然后获取lock锁。获取锁成功后，如果队列已满则直接返回false，否则调用enqueue(E e)，enqueue(E e)为入列的核心方法，所有入列的方法最终都将调用该方法在队列尾部插入元素：
-```java
-    private void enqueue(E x) {
-        // assert lock.getHoldCount() == 1;
-        // assert items[putIndex] == null;
-        final Object[] items = this.items;
-        items[putIndex] = x;
-        if (++putIndex == items.length)
-            putIndex = 0;
-        count++;
-        notEmpty.signal();
-    }
-```
-该方法就是在putIndex（队尾）为知处添加元素，最后使用notEmpty的signal()方法通知阻塞在出列的线程（如果队列为空，则进行出列操作是会阻塞）。
-
-### 出队
-ArrayBlockingQueue提供的出队方法如下：
-
-* poll() :获取并移除此队列的头，如果此队列为空，则返回 null
-* poll(long timeout, TimeUnit unit) :获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）
-* remove(Object o) :从此队列中移除指定元素的单个实例（如果存在）
-* take() :获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）
-
-**poll()**
-```java
-public E poll() {
-   final ReentrantLock lock = this.lock;
-   lock.lock();
-   try {
-       return (count == 0) ? null : dequeue();
-   } finally {
-       lock.unlock();
-   }
-}
-```
-如果队列为空返回null，否则调用dequeue()获取列头元素：
-```java
-private E dequeue() {
-   final Object[] items = this.items;
-   E x = (E) items[takeIndex];
-   items[takeIndex] = null;
-   if (++takeIndex == items.length)
-       takeIndex = 0;
-   count--;
-   if (itrs != null)
-       itrs.elementDequeued();
-   notFull.signal();
-   return x;
-}
-```
-该方法主要是从列头（takeIndex 位置）取出元素，同时如果迭代器itrs不为null，则需要维护下该迭代器。最后调用notFull.signal()唤醒入列线程。
-
-**take()**
-```java
-public E take() throws InterruptedException {
-   final ReentrantLock lock = this.lock;
-   lock.lockInterruptibly();
-   try {
-       while (count == 0)
-           notEmpty.await();
-       return dequeue();
-   } finally {
-       lock.unlock();
-   }
-}
-```
-take()与poll()存在一个区别就是count == 0 时的处理，poll()直接返回null，而take()则是在notEmpty上面等待直到被入列的线程唤醒。
+ArrayBlockingQueue，一个由 **数组实现的有界阻塞队列**。该队列采用FIFO的原则对元素进行排序添加的。
+
+ArrayBlockingQueue为 **有界且固定，其大小在构造时由构造函数来决定，确认之后就不能再改变了**。ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略，但是在 **默认情况下不保证线程公平的访问**，在构造时可以选择公平策略（fair = true）。公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。
+
+先看ArrayBlockingQueue的定义：
+```java
+public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable {
+    private static final long serialVersionUID = -817911632652898426L;
+    final Object[] items;
+    int takeIndex;
+    int putIndex;
+    int count;
+    // 重入锁
+    final ReentrantLock lock;
+    // notEmpty condition
+    private final Condition notEmpty;
+    // notFull condition
+    private final Condition notFull;
+    transient ArrayBlockingQueue.Itrs itrs;
+}
+```
+可以清楚地看到ArrayBlockingQueue继承`AbstractQueue`，实现`BlockingQueue`接口。看过java.util包源码的同学应该都认识AbstractQueue，该类在Queue接口中扮演着非常重要的作用，该类提供了对queue操作的骨干实现（具体内容移驾其源码）。BlockingQueue继承java.util.Queue为阻塞队列的核心接口，提供了在多线程环境下的出列、入列操作，作为使用者，则不需要关心队列在什么时候阻塞线程，什么时候唤醒线程，所有一切均由BlockingQueue来完成。
+
+ArrayBlockingQueue **内部使用可重入锁 `ReentrantLock` + `Condition`来完成多线程环境的并发操作**。
+
+* `items`，一个定长数组，维护ArrayBlockingQueue的元素
+* `takeIndex`，int，为ArrayBlockingQueue队首位置
+* `putIndex`，int，ArrayBlockingQueue队尾位置
+* `count`，元素个数
+* `lock`，锁，ArrayBlockingQueue出列入列都必须获取该锁，两个步骤公用一个锁
+* `notEmpty`，出列条件
+* `notFull`，入列条件
+
+### 入队
+ArrayBlockingQueue提供了诸多方法，可以将元素加入队列尾部。
+
+* add(E e) ：将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则抛出 IllegalStateException
+* offer(E e) :将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回 false
+* offer(E e, long timeout, TimeUnit unit) :将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间
+* put(E e) :将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间
+
+
+方法较多，我们就分析一个方法：add(E e)：
+```java
+    public boolean add(E e) {
+        return super.add(e);
+    }
+
+    AbstractQueue.java
+    public boolean add(E e) {
+        if (offer(e))
+            return true;
+        else
+            throw new IllegalStateException("Queue full");
+    }
+```
+add方法调用offer(E e)，如果返回false，则直接抛出`IllegalStateException`异常。offer(E e)为`ArrayBlockingQueue实现`：
+```java
+    public boolean offer(E e) {
+        checkNotNull(e);
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (count == items.length)
+                return false;
+            else {
+                enqueue(e);
+                return true;
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+```
+方法首先检查是否为null，然后获取lock锁。获取锁成功后，如果队列已满则直接返回false，否则调用enqueue(E e)，enqueue(E e)为入列的核心方法，所有入列的方法最终都将调用该方法在队列尾部插入元素：
+```java
+    private void enqueue(E x) {
+        // assert lock.getHoldCount() == 1;
+        // assert items[putIndex] == null;
+        final Object[] items = this.items;
+        items[putIndex] = x;
+        if (++putIndex == items.length)
+            putIndex = 0;
+        count++;
+        notEmpty.signal();
+    }
+```
+该方法就是在putIndex（队尾）为知处添加元素，最后使用notEmpty的signal()方法通知阻塞在出列的线程（如果队列为空，则进行出列操作是会阻塞）。
+
+### 出队
+ArrayBlockingQueue提供的出队方法如下：
+
+* poll() :获取并移除此队列的头，如果此队列为空，则返回 null
+* poll(long timeout, TimeUnit unit) :获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）
+* remove(Object o) :从此队列中移除指定元素的单个实例（如果存在）
+* take() :获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）
+
+**poll()**
+```java
+public E poll() {
+   final ReentrantLock lock = this.lock;
+   lock.lock();
+   try {
+       return (count == 0) ? null : dequeue();
+   } finally {
+       lock.unlock();
+   }
+}
+```
+如果队列为空返回null，否则调用dequeue()获取列头元素：
+```java
+private E dequeue() {
+   final Object[] items = this.items;
+   E x = (E) items[takeIndex];
+   items[takeIndex] = null;
+   if (++takeIndex == items.length)
+       takeIndex = 0;
+   count--;
+   if (itrs != null)
+       itrs.elementDequeued();
+   notFull.signal();
+   return x;
+}
+```
+该方法主要是从列头（takeIndex 位置）取出元素，同时如果迭代器itrs不为null，则需要维护下该迭代器。最后调用notFull.signal()唤醒入列线程。
+
+**take()**
+```java
+public E take() throws InterruptedException {
+   final ReentrantLock lock = this.lock;
+   lock.lockInterruptibly();
+   try {
+       while (count == 0)
+           notEmpty.await();
+       return dequeue();
+   } finally {
+       lock.unlock();
+   }
+}
+```
+take()与poll()存在一个区别就是count == 0 时的处理，poll()直接返回null，而take()则是在notEmpty上面等待直到被入列的线程唤醒。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/24 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232PriorityBlockingQueue.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/24 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232PriorityBlockingQueue.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/24 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232PriorityBlockingQueue.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/24 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232PriorityBlockingQueue.md"
index 9d688820..9fe7e4b4 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/24 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232PriorityBlockingQueue.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/24 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232PriorityBlockingQueue.md"	
@@ -1,317 +1,317 @@
-我们知道线程Thread可以调用setPriority(int newPriority)来设置优先级的，线程优先级高的线程先执行，优先级低的后执行。而前面介绍的ArrayBlockingQueue、LinkedBlockingQueue都是采用FIFO原则来确定线程执行的先后顺序，那么有没有一个队列可以支持优先级呢？ PriorityBlockingQueue 。
-
-PriorityBlockingQueue是一个 **支持优先级的无界阻塞队列**。 **默认情况下元素采用自然顺序升序排序，当然我们也可以通过构造函数来指定Comparator来对元素进行排序。** 需要注意的是PriorityBlockingQueue不能保证同优先级元素的顺序。
-
-### 二叉堆
-
-由于PriorityBlockingQueue底层采用二叉堆来实现的，所以有必要先介绍下二叉堆。
-
-二叉堆是一种特殊的堆，就结构性而言就是完全二叉树或者是近似完全二叉树，满足树结构性和堆序性。树机构特性就是完全二叉树应该有的结构，
-
-堆序性则是：
-
-  **父节点的键值总是保持固定的序关系于任何一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆。它有两种表现形式：最大堆、最小堆。**
-
-最小堆：父节点的键值总是小于或等于任何一个子节点的键值（下左图）
-
-最大堆：父节点的键值总是大于或等于任何一个子节点的键值（下右图）
-
-<div align="center"><img src="img/201703270001_thumb.jpg"/></div>
-
-二叉堆一般用数组表示，如果父节点的节点位置在n处，那么其左孩子节点为：2 * n + 1 ，其右孩子节点为2 * (n + 1)，其父节点为（n - 1） / 2 处。上左图的数组表现形式为：
-
-<div align="center"><img src="img/201703270002_2_thumb.png"/></div>
-
-二叉堆的基本结构了解了，下面来看看二叉堆的添加和删除节点。二叉堆的添加和删除相对于二叉树来说会简单很多。
-
-### 添加元素 **不断上冒**
-首先将要添加的元素N插添加到堆的末尾位置（在二叉堆中我们称之为空穴）。如果元素N放入空穴中而不破坏堆的序（其值大于跟父节点值（最大堆是小于父节点）），那么插入完成。否则，我们则将该元素N的节点与其父节点进行交换，然后与其新父节点进行比较直到它的父节点不在比它小（最大堆是大）或者到达根节点。
-
-假如有如下一个二叉堆
-
-<div align="center"><img src="img/201703270003_3_thumb.png"/></div>
-
-这是一个最小堆，其父节点总是小于等于任一一个子节点。现在我们添加一个元素2。
-
-第一步：在末尾添加一个元素2，如下：
-
-第二步：元素2比其父节点6小，进行替换，如下：
-
-<div align="center"><img src="img/201703270005_3_thumb.png"/></div>
-
-第三步：继续与其父节点5比较，小于，替换：
-
-<div align="center"><img src="img/201703270006_3_thumb.png"/></div>
-
-第四步：继续比较其跟节点1，发现跟节点比自己小，则完成，到这里元素2插入完毕。所以整个添加元素过程可以概括为：在元素末尾插入元素，然后不断比较替换直到不能移动为止。
-
-复杂度：Ο(logn)
-
-### 删除元素 **不断下掉**
-删除元素与增加元素一样，需要维护整个二叉堆的序。删除位置1的元素（数组下标0），则把最后一个元素空出来移到最前边，然后和它的两个子节点比较，如果两个子节点中较小的节点小于该节点，就将他们交换，知道两个子节点都比该元素大为止。
-
-就上面二叉堆而言，删除的元素为元素1。
-
-第一步：删掉元素1，元素6空出来，如下：
-<div align="center"><img src="img/201703270008_thumb.png"/></div>
-
-第二步：与其两个子节点（元素2、元素3）比较，都小，将其中较小的元素（元素2）放入到该空穴中：
-
-<div align="center"><img src="img/201703270004_4_thumb.png"/></div>
-
-第三步：继续比较两个子节点（元素5、元素7），还是都小，则将较小的元素（元素5）放入到该空穴中：
-
-
-<div align="center"><img src="img/201703270007_4_thumb.png"/></div>
-
-第四步：比较其子节点（元素8），比该节点小，则元素6放入该空穴位置不会影响二叉堆的树结构，放入：
-
-<div align="center"><img src="img/201703270010_3_thumb.png"/></div>
-
-
-到这里整个删除操作就已经完成了。
-
-二叉堆的添加、删除操作还是比较简单的，很容易就理解了。下面我们就参考该内容来开启PriorityBlockingQueue的源代码研究。
-
-PriorityBlockingQueue
-PriorityBlockingQueue继承AbstractQueue，实现BlockingQueue接口。
-```
-public class PriorityBlockingQueue<E> extends AbstractQueue<E>
-    implements BlockingQueue<E>, java.io.Serializable
-```
-定义了一些属性
-``` java
-// 默认容量
-private static final int DEFAULT_INITIAL_CAPACITY = 11;
-// 最大容量
-private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
-// 二叉堆数组
-private transient Object[] queue;
-// 队列元素的个数
-private transient int size;
-// 比较器，如果为空，则为自然顺序
-private transient Comparator<? super E> comparator;
-// 内部锁
-private final ReentrantLock lock;
-private final Condition notEmpty;
-//
-private transient volatile int allocationSpinLock;
-// 优先队列：主要用于序列化，这是为了兼容之前的版本。只有在序列化和反序列化才非空
-private PriorityQueue<E> q;
-```
-
-内部仍然采用可重入锁ReentrantLock来实现同步机制，但是这里只有一个notEmpty的Condition，了解了ArrayBlockingQueue我们知道它定义了两个Condition，之类为何只有一个呢？原因就在于PriorityBlockingQueue是一个无界队列，插入总是会成功，除非消耗尽了资源导致服务器挂。
-
-### 入列
-PriorityBlockingQueue提供put()、add()、offer()方法向队列中加入元素。我们这里从put()入手：put(E e) ：将指定元素插入此优先级队列。
-``` java
-    public void put(E e) {
-        offer(e); // never need to block
-    }
-```
-PriorityBlockingQueue是无界的，所以不可能会阻塞。内部调用offer(E e)：
-``` java
-public boolean offer(E e) {
-    // 不能为null
-    if (e == null)
-        throw new NullPointerException();
-    // 获取锁
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    int n, cap;
-    Object[] array;
-    // 扩容
-    while ((n = size) >= (cap = (array = queue).length))
-        tryGrow(array, cap);
-    try {
-        Comparator<? super E> cmp = comparator;
-        // 根据比较器是否为null，做不同的处理
-        if (cmp == null)
-            siftUpComparable(n, e, array);
-        else
-            siftUpUsingComparator(n, e, array, cmp);
-        size = n + 1;
-        // 唤醒正在等待的消费者线程
-        notEmpty.signal();
-    } finally {
-        lock.unlock();
-    }
-    return true;
-}
-```
-siftUpComparable
-当比较器comparator为null时，采用自然排序，调用siftUpComparable方法：
-``` java
-private static <T> void siftUpComparable(int k, T x, Object[] array) {
-        Comparable<? super T> key = (Comparable<? super T>) x;
-    // “上冒”过程
-    while (k > 0) {
-        // 父级节点 （n - ） / 2
-        int parent = (k - 1) >>> 1;
-        Object e = array[parent];
-
-        // key >= parent 完成（最大堆）
-        if (key.compareTo((T) e) >= 0)
-            break;
-        // key < parant 替换
-        array[k] = e;
-        k = parent;
-    }
-    array[k] = key;
-}
-```
-这段代码所表示的意思：将元素X插入到数组中，然后进行调整以保持二叉堆的特性。
-
-siftUpUsingComparator
-当比较器不为null时，采用所指定的比较器，调用siftUpUsingComparator方法：
-``` java
-private static <T> void siftUpUsingComparator(int k, T x, Object[] array,
-                                       Comparator<? super T> cmp) {
-    while (k > 0) {
-        int parent = (k - 1) >>> 1;
-        Object e = array[parent];
-        if (cmp.compare(x, (T) e) >= 0)
-            break;
-        array[k] = e;
-        k = parent;
-    }
-    array[k] = x;
-}
-```
-扩容：tryGrow
-``` java
-private void tryGrow(Object[] array, int oldCap) {
-    lock.unlock();      // 扩容操作使用自旋，不需要锁主锁，释放
-    Object[] newArray = null;
-    // CAS 占用
-    if (allocationSpinLock == 0 && UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset, 0, 1)) {
-        try {
-
-            // 新容量  最小翻倍
-            int newCap = oldCap + ((oldCap < 64) ? (oldCap + 2) :  (oldCap >> 1));
-
-            // 超过
-            if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
-                int minCap = oldCap + 1;
-                if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
-                    throw new OutOfMemoryError();
-                newCap = MAX_ARRAY_SIZE;        // 最大容量
-            }
-            if (newCap > oldCap && queue == array)
-                newArray = new Object[newCap];
-        } finally {
-            allocationSpinLock = 0;     // 扩容后allocationSpinLock = 0 代表释放了自旋锁
-        }
-    }
-    // 到这里如果是本线程扩容newArray肯定是不为null，为null就是其他线程在处理扩容，那就让给别的线程处理
-    if (newArray == null)
-        Thread.yield();
-    // 主锁获取锁
-    lock.lock();
-    // 数组复制
-    if (newArray != null && queue == array) {
-        queue = newArray;
-        System.arraycopy(array, 0, newArray, 0, oldCap);
-    }
-}
-```
-整个添加元素的过程和上面二叉堆一模一样：先将元素添加到数组末尾，然后采用“上冒”的方式将该元素尽量往上冒。
-
-### 出列
-PriorityBlockingQueue提供poll()、remove()方法来执行出对操作。出对的永远都是第一个元素：array[0]。
-``` java
-public E poll() {
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        return dequeue();
-    } finally {
-        lock.unlock();
-    }
-}
-```
-先获取锁，然后调用dequeue()方法：
-``` java
-private E dequeue() {
-    // 没有元素 返回null
-    int n = size - 1;
-    if (n < 0)
-        return null;
-    else {
-        Object[] array = queue;
-        // 出对元素
-        E result = (E) array[0];
-        // 最后一个元素（也就是插入到空穴中的元素）
-        E x = (E) array[n];
-        array[n] = null;
-        // 根据比较器释放为null，来执行不同的处理
-        Comparator<? super E> cmp = comparator;
-        if (cmp == null)
-            siftDownComparable(0, x, array, n);
-        else
-            siftDownUsingComparator(0, x, array, n, cmp);
-        size = n;
-        return result;
-    }
-}
-```
-siftDownComparable
-
-如果比较器为null，则调用siftDownComparable来进行自然排序处理：
-``` java
-private static <T> void siftDownComparable(int k, T x, Object[] array,
-                                             int n) {
-    if (n > 0) {
-        Comparable<? super T> key = (Comparable<? super T>)x;
-        // 最后一个叶子节点的父节点位置
-        int half = n >>> 1;
-        while (k < half) {
-            int child = (k << 1) + 1;       // 待调整位置左节点位置
-            Object c = array[child];        //左节点
-            int right = child + 1;          //右节点
-
-            //左右节点比较，取较小的
-            if (right < n &&
-                    ((Comparable<? super T>) c).compareTo((T) array[right]) > 0)
-                c = array[child = right];
-
-            //如果待调整key最小，那就退出，直接赋值
-            if (key.compareTo((T) c) <= 0)
-                break;
-            //如果key不是最小，那就取左右节点小的那个放到调整位置，然后小的那个节点位置开始再继续调整
-            array[k] = c;
-            k = child;
-        }
-        array[k] = key;
-    }
-}
-```
-处理思路和二叉堆删除节点的逻辑一样：就第一个元素定义为空穴，然后把最后一个元素取出来，尝试插入到空穴位置，并与两个子节点值进行比较，如果不符合，则与其中较小的子节点进行替换，然后继续比较调整。
-
-siftDownUsingComparator
-
-如果指定了比较器，则采用比较器来进行调整：
-``` java
-private static <T> void siftDownUsingComparator(int k, T x, Object[] array,
-                                                int n,
-                                                Comparator<? super T> cmp) {
-    if (n > 0) {
-        int half = n >>> 1;
-        while (k < half) {
-            int child = (k << 1) + 1;
-            Object c = array[child];
-            int right = child + 1;
-            if (right < n && cmp.compare((T) c, (T) array[right]) > 0)
-                c = array[child = right];
-            if (cmp.compare(x, (T) c) <= 0)
-                break;
-            array[k] = c;
-            k = child;
-        }
-        array[k] = x;
-    }
-}
-```
-PriorityBlockingQueue采用二叉堆来维护，所以整个处理过程不是很复杂，添加操作则是不断“上冒”，而删除操作则是不断“下掉”。掌握二叉堆就掌握了PriorityBlockingQueue，无论怎么变还是不离其宗。对于PriorityBlockingQueue需要注意的是他是一个无界队列，所以添加操作是不会失败的，除非资源耗尽。
-
-<div align="center"><img src="img/201703270009_thumb.png"></div>
+我们知道线程Thread可以调用setPriority(int newPriority)来设置优先级的，线程优先级高的线程先执行，优先级低的后执行。而前面介绍的ArrayBlockingQueue、LinkedBlockingQueue都是采用FIFO原则来确定线程执行的先后顺序，那么有没有一个队列可以支持优先级呢？ PriorityBlockingQueue 。
+
+PriorityBlockingQueue是一个 **支持优先级的无界阻塞队列**。 **默认情况下元素采用自然顺序升序排序，当然我们也可以通过构造函数来指定Comparator来对元素进行排序。** 需要注意的是PriorityBlockingQueue不能保证同优先级元素的顺序。
+
+### 二叉堆
+
+由于PriorityBlockingQueue底层采用二叉堆来实现的，所以有必要先介绍下二叉堆。
+
+二叉堆是一种特殊的堆，就结构性而言就是完全二叉树或者是近似完全二叉树，满足树结构性和堆序性。树机构特性就是完全二叉树应该有的结构，
+
+堆序性则是：
+
+  **父节点的键值总是保持固定的序关系于任何一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆。它有两种表现形式：最大堆、最小堆。**
+
+最小堆：父节点的键值总是小于或等于任何一个子节点的键值（下左图）
+
+最大堆：父节点的键值总是大于或等于任何一个子节点的键值（下右图）
+
+<div align="center"><img src="img/201703270001_thumb.jpg"/></div>
+
+二叉堆一般用数组表示，如果父节点的节点位置在n处，那么其左孩子节点为：2 * n + 1 ，其右孩子节点为2 * (n + 1)，其父节点为（n - 1） / 2 处。上左图的数组表现形式为：
+
+<div align="center"><img src="img/201703270002_2_thumb.png"/></div>
+
+二叉堆的基本结构了解了，下面来看看二叉堆的添加和删除节点。二叉堆的添加和删除相对于二叉树来说会简单很多。
+
+### 添加元素 **不断上冒**
+首先将要添加的元素N插添加到堆的末尾位置（在二叉堆中我们称之为空穴）。如果元素N放入空穴中而不破坏堆的序（其值大于跟父节点值（最大堆是小于父节点）），那么插入完成。否则，我们则将该元素N的节点与其父节点进行交换，然后与其新父节点进行比较直到它的父节点不在比它小（最大堆是大）或者到达根节点。
+
+假如有如下一个二叉堆
+
+<div align="center"><img src="img/201703270003_3_thumb.png"/></div>
+
+这是一个最小堆，其父节点总是小于等于任一一个子节点。现在我们添加一个元素2。
+
+第一步：在末尾添加一个元素2，如下：
+
+第二步：元素2比其父节点6小，进行替换，如下：
+
+<div align="center"><img src="img/201703270005_3_thumb.png"/></div>
+
+第三步：继续与其父节点5比较，小于，替换：
+
+<div align="center"><img src="img/201703270006_3_thumb.png"/></div>
+
+第四步：继续比较其跟节点1，发现跟节点比自己小，则完成，到这里元素2插入完毕。所以整个添加元素过程可以概括为：在元素末尾插入元素，然后不断比较替换直到不能移动为止。
+
+复杂度：Ο(logn)
+
+### 删除元素 **不断下掉**
+删除元素与增加元素一样，需要维护整个二叉堆的序。删除位置1的元素（数组下标0），则把最后一个元素空出来移到最前边，然后和它的两个子节点比较，如果两个子节点中较小的节点小于该节点，就将他们交换，知道两个子节点都比该元素大为止。
+
+就上面二叉堆而言，删除的元素为元素1。
+
+第一步：删掉元素1，元素6空出来，如下：
+<div align="center"><img src="img/201703270008_thumb.png"/></div>
+
+第二步：与其两个子节点（元素2、元素3）比较，都小，将其中较小的元素（元素2）放入到该空穴中：
+
+<div align="center"><img src="img/201703270004_4_thumb.png"/></div>
+
+第三步：继续比较两个子节点（元素5、元素7），还是都小，则将较小的元素（元素5）放入到该空穴中：
+
+
+<div align="center"><img src="img/201703270007_4_thumb.png"/></div>
+
+第四步：比较其子节点（元素8），比该节点小，则元素6放入该空穴位置不会影响二叉堆的树结构，放入：
+
+<div align="center"><img src="img/201703270010_3_thumb.png"/></div>
+
+
+到这里整个删除操作就已经完成了。
+
+二叉堆的添加、删除操作还是比较简单的，很容易就理解了。下面我们就参考该内容来开启PriorityBlockingQueue的源代码研究。
+
+PriorityBlockingQueue
+PriorityBlockingQueue继承AbstractQueue，实现BlockingQueue接口。
+```
+public class PriorityBlockingQueue<E> extends AbstractQueue<E>
+    implements BlockingQueue<E>, java.io.Serializable
+```
+定义了一些属性
+``` java
+// 默认容量
+private static final int DEFAULT_INITIAL_CAPACITY = 11;
+// 最大容量
+private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+// 二叉堆数组
+private transient Object[] queue;
+// 队列元素的个数
+private transient int size;
+// 比较器，如果为空，则为自然顺序
+private transient Comparator<? super E> comparator;
+// 内部锁
+private final ReentrantLock lock;
+private final Condition notEmpty;
+//
+private transient volatile int allocationSpinLock;
+// 优先队列：主要用于序列化，这是为了兼容之前的版本。只有在序列化和反序列化才非空
+private PriorityQueue<E> q;
+```
+
+内部仍然采用可重入锁ReentrantLock来实现同步机制，但是这里只有一个notEmpty的Condition，了解了ArrayBlockingQueue我们知道它定义了两个Condition，之类为何只有一个呢？原因就在于PriorityBlockingQueue是一个无界队列，插入总是会成功，除非消耗尽了资源导致服务器挂。
+
+### 入列
+PriorityBlockingQueue提供put()、add()、offer()方法向队列中加入元素。我们这里从put()入手：put(E e) ：将指定元素插入此优先级队列。
+``` java
+    public void put(E e) {
+        offer(e); // never need to block
+    }
+```
+PriorityBlockingQueue是无界的，所以不可能会阻塞。内部调用offer(E e)：
+``` java
+public boolean offer(E e) {
+    // 不能为null
+    if (e == null)
+        throw new NullPointerException();
+    // 获取锁
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    int n, cap;
+    Object[] array;
+    // 扩容
+    while ((n = size) >= (cap = (array = queue).length))
+        tryGrow(array, cap);
+    try {
+        Comparator<? super E> cmp = comparator;
+        // 根据比较器是否为null，做不同的处理
+        if (cmp == null)
+            siftUpComparable(n, e, array);
+        else
+            siftUpUsingComparator(n, e, array, cmp);
+        size = n + 1;
+        // 唤醒正在等待的消费者线程
+        notEmpty.signal();
+    } finally {
+        lock.unlock();
+    }
+    return true;
+}
+```
+siftUpComparable
+当比较器comparator为null时，采用自然排序，调用siftUpComparable方法：
+``` java
+private static <T> void siftUpComparable(int k, T x, Object[] array) {
+        Comparable<? super T> key = (Comparable<? super T>) x;
+    // “上冒”过程
+    while (k > 0) {
+        // 父级节点 （n - ） / 2
+        int parent = (k - 1) >>> 1;
+        Object e = array[parent];
+
+        // key >= parent 完成（最大堆）
+        if (key.compareTo((T) e) >= 0)
+            break;
+        // key < parant 替换
+        array[k] = e;
+        k = parent;
+    }
+    array[k] = key;
+}
+```
+这段代码所表示的意思：将元素X插入到数组中，然后进行调整以保持二叉堆的特性。
+
+siftUpUsingComparator
+当比较器不为null时，采用所指定的比较器，调用siftUpUsingComparator方法：
+``` java
+private static <T> void siftUpUsingComparator(int k, T x, Object[] array,
+                                       Comparator<? super T> cmp) {
+    while (k > 0) {
+        int parent = (k - 1) >>> 1;
+        Object e = array[parent];
+        if (cmp.compare(x, (T) e) >= 0)
+            break;
+        array[k] = e;
+        k = parent;
+    }
+    array[k] = x;
+}
+```
+扩容：tryGrow
+``` java
+private void tryGrow(Object[] array, int oldCap) {
+    lock.unlock();      // 扩容操作使用自旋，不需要锁主锁，释放
+    Object[] newArray = null;
+    // CAS 占用
+    if (allocationSpinLock == 0 && UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset, 0, 1)) {
+        try {
+
+            // 新容量  最小翻倍
+            int newCap = oldCap + ((oldCap < 64) ? (oldCap + 2) :  (oldCap >> 1));
+
+            // 超过
+            if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
+                int minCap = oldCap + 1;
+                if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
+                    throw new OutOfMemoryError();
+                newCap = MAX_ARRAY_SIZE;        // 最大容量
+            }
+            if (newCap > oldCap && queue == array)
+                newArray = new Object[newCap];
+        } finally {
+            allocationSpinLock = 0;     // 扩容后allocationSpinLock = 0 代表释放了自旋锁
+        }
+    }
+    // 到这里如果是本线程扩容newArray肯定是不为null，为null就是其他线程在处理扩容，那就让给别的线程处理
+    if (newArray == null)
+        Thread.yield();
+    // 主锁获取锁
+    lock.lock();
+    // 数组复制
+    if (newArray != null && queue == array) {
+        queue = newArray;
+        System.arraycopy(array, 0, newArray, 0, oldCap);
+    }
+}
+```
+整个添加元素的过程和上面二叉堆一模一样：先将元素添加到数组末尾，然后采用“上冒”的方式将该元素尽量往上冒。
+
+### 出列
+PriorityBlockingQueue提供poll()、remove()方法来执行出对操作。出对的永远都是第一个元素：array[0]。
+``` java
+public E poll() {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        return dequeue();
+    } finally {
+        lock.unlock();
+    }
+}
+```
+先获取锁，然后调用dequeue()方法：
+``` java
+private E dequeue() {
+    // 没有元素 返回null
+    int n = size - 1;
+    if (n < 0)
+        return null;
+    else {
+        Object[] array = queue;
+        // 出对元素
+        E result = (E) array[0];
+        // 最后一个元素（也就是插入到空穴中的元素）
+        E x = (E) array[n];
+        array[n] = null;
+        // 根据比较器释放为null，来执行不同的处理
+        Comparator<? super E> cmp = comparator;
+        if (cmp == null)
+            siftDownComparable(0, x, array, n);
+        else
+            siftDownUsingComparator(0, x, array, n, cmp);
+        size = n;
+        return result;
+    }
+}
+```
+siftDownComparable
+
+如果比较器为null，则调用siftDownComparable来进行自然排序处理：
+``` java
+private static <T> void siftDownComparable(int k, T x, Object[] array,
+                                             int n) {
+    if (n > 0) {
+        Comparable<? super T> key = (Comparable<? super T>)x;
+        // 最后一个叶子节点的父节点位置
+        int half = n >>> 1;
+        while (k < half) {
+            int child = (k << 1) + 1;       // 待调整位置左节点位置
+            Object c = array[child];        //左节点
+            int right = child + 1;          //右节点
+
+            //左右节点比较，取较小的
+            if (right < n &&
+                    ((Comparable<? super T>) c).compareTo((T) array[right]) > 0)
+                c = array[child = right];
+
+            //如果待调整key最小，那就退出，直接赋值
+            if (key.compareTo((T) c) <= 0)
+                break;
+            //如果key不是最小，那就取左右节点小的那个放到调整位置，然后小的那个节点位置开始再继续调整
+            array[k] = c;
+            k = child;
+        }
+        array[k] = key;
+    }
+}
+```
+处理思路和二叉堆删除节点的逻辑一样：就第一个元素定义为空穴，然后把最后一个元素取出来，尝试插入到空穴位置，并与两个子节点值进行比较，如果不符合，则与其中较小的子节点进行替换，然后继续比较调整。
+
+siftDownUsingComparator
+
+如果指定了比较器，则采用比较器来进行调整：
+``` java
+private static <T> void siftDownUsingComparator(int k, T x, Object[] array,
+                                                int n,
+                                                Comparator<? super T> cmp) {
+    if (n > 0) {
+        int half = n >>> 1;
+        while (k < half) {
+            int child = (k << 1) + 1;
+            Object c = array[child];
+            int right = child + 1;
+            if (right < n && cmp.compare((T) c, (T) array[right]) > 0)
+                c = array[child = right];
+            if (cmp.compare(x, (T) c) <= 0)
+                break;
+            array[k] = c;
+            k = child;
+        }
+        array[k] = x;
+    }
+}
+```
+PriorityBlockingQueue采用二叉堆来维护，所以整个处理过程不是很复杂，添加操作则是不断“上冒”，而删除操作则是不断“下掉”。掌握二叉堆就掌握了PriorityBlockingQueue，无论怎么变还是不离其宗。对于PriorityBlockingQueue需要注意的是他是一个无界队列，所以添加操作是不会失败的，除非资源耗尽。
+
+<div align="center"><img src="img/201703270009_thumb.png"></div>
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/25 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232DelayQueue.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/25 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232DelayQueue.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/25 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232DelayQueue.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/25 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232DelayQueue.md"
index e25fb89c..47e49183 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/25 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232DelayQueue.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/25 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232DelayQueue.md"	
@@ -1,122 +1,122 @@
-DelayQueue是一个 **支持延时获取元素的无界阻塞队列**。里面的元素全部都是“可延期”的元素，列头的元素是最先“到期”的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。也就是说只有在延迟期到时才能够从队列中取元素。
-
-DelayQueue主要用于两个方面：
-- **缓存：清掉缓存中超时的缓存数据**
-- **任务超时处理**
-
-DelayQueue
-DelayQueue实现的关键主要有如下几个：
-
-1. 可重入锁ReentrantLock
-2. 用于阻塞和通知的Condition对象
-3. 根据Delay时间排序的优先级队列：PriorityQueue
-4. 用于优化阻塞通知的线程元素leader
-
-ReentrantLock、Condition这两个对象就不需要阐述了，他是实现整个BlockingQueue的核心。PriorityQueue是一个支持优先级线程排序的队列（参考【死磕Java并发】-----J.U.C之阻塞队列：PriorityBlockingQueue），leader后面阐述。这里我们先来了解Delay，他是实现延时操作的关键。
-
-### Delayed
-Delayed接口是 **用来标记那些应该在给定延迟时间之后执行的对象**，它定义了一个long getDelay(TimeUnit unit)方法，该方法返回与此对象相关的的剩余时间。
-**同时实现该接口的对象必须定义一个compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。**
-```java
-public interface Delayed extends Comparable<Delayed> {
-    long getDelay(TimeUnit unit);
-}
-```
-如何使用该接口呢？上面说的非常清楚了，实现该接口的getDelay()方法，同时定义compareTo()方法即可。
-
-内部结构
-先看DelayQueue的定义：
-```java
-public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
-        implements BlockingQueue<E> {
-    /** 可重入锁 */
-    private final transient ReentrantLock lock = new ReentrantLock();
-    /** 支持优先级的BlockingQueue */
-    private final PriorityQueue<E> q = new PriorityQueue<E>();
-    /** 用于优化阻塞 */
-    private Thread leader = null;
-    /** Condition */
-    private final Condition available = lock.newCondition();
-
-    /**
-     * 省略很多代码
-     */
-}
-```
-看了DelayQueue的内部结构就对上面几个关键点一目了然了，但是这里有一点需要注意，DelayQueue的元素都必须继承Delayed接口。
-同时也可以从这里初步理清楚DelayQueue内部实现的机制了：以 **支持优先级无界队列的PriorityQueue作为一个容器**，容器里面的元素都应该实现Delayed接口，在每次往优先级队列中添加元素时以元素的过期时间作为排序条件，最先过期的元素放在优先级最高。
-
-offer()
-```java
-public boolean offer(E e) {
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        // 向 PriorityQueue中插入元素
-        q.offer(e);
-        // 如果当前元素的对首元素（优先级最高），leader设置为空，唤醒所有等待线程
-        if (q.peek() == e) {
-            leader = null;
-            available.signal();
-        }
-        // 无界队列，永远返回true
-        return true;
-    } finally {
-        lock.unlock();
-    }
-}
-```
-offer(E e)就是往PriorityQueue中添加元素，具体可以参考（【死磕Java并发】-----J.U.C之阻塞队列：PriorityBlockingQueue）。整个过程还是比较简单，但是在判断当前元素是否为对首元素，如果是的话则设置leader=null，这是非常关键的一个步骤，后面阐述。
-
-take()
-```java
-public E take() throws InterruptedException {
-    final ReentrantLock lock = this.lock;
-    lock.lockInterruptibly();
-    try {
-        for (;;) {
-            // 对首元素
-            E first = q.peek();
-            // 对首为空，阻塞，等待off()操作唤醒
-            if (first == null)
-                available.await();
-            else {
-                // 获取对首元素的超时时间
-                long delay = first.getDelay(NANOSECONDS);
-                // <=0 表示已过期，出对，return
-                if (delay <= 0)
-                    return q.poll();
-                first = null; // don't retain ref while waiting
-                // leader != null 证明有其他线程在操作，阻塞
-                if (leader != null)
-                    available.await();
-                else {
-                    // 否则将leader 设置为当前线程，独占
-                    Thread thisThread = Thread.currentThread();
-                    leader = thisThread;
-                    try {
-                        // 超时阻塞
-                        available.awaitNanos(delay);
-                    } finally {
-                        // 释放leader
-                        if (leader == thisThread)
-                            leader = null;
-                    }
-                }
-            }
-        }
-    } finally {
-        // 唤醒阻塞线程
-        if (leader == null && q.peek() != null)
-            available.signal();
-        lock.unlock();
-    }
-}
-```
-首先是获取对首元素，如果对首元素的延时时间 delay <= 0 ，则可以出对了，直接return即可。否则设置first = null，这里设置为null的主要目的是为了避免内存泄漏。如果 leader != null 则表示当前有线程占用，则阻塞，否则设置leader为当前线程，然后调用awaitNanos()方法超时等待。
-
-first = null
-
-这里为什么如果不设置first = null，则会引起内存泄漏呢？线程A到达，列首元素没有到期，设置leader = 线程A，这是线程B来了因为leader != null，则会阻塞，线程C一样。假如线程阻塞完毕了，获取列首元素成功，出列。这个时候列首元素应该会被回收掉，但是问题是它还被线程B、线程C持有着，所以不会回收，这里只有两个线程，如果有线程D、线程E...呢？这样会无限期的不能回收，就会造成内存泄漏。
-
-这个入队、出对过程和其他的阻塞队列没有很大区别，无非是在出对的时候增加了一个到期时间的判断。同时通过leader来减少不必要阻塞。
+DelayQueue是一个 **支持延时获取元素的无界阻塞队列**。里面的元素全部都是“可延期”的元素，列头的元素是最先“到期”的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。也就是说只有在延迟期到时才能够从队列中取元素。
+
+DelayQueue主要用于两个方面：
+- **缓存：清掉缓存中超时的缓存数据**
+- **任务超时处理**
+
+DelayQueue
+DelayQueue实现的关键主要有如下几个：
+
+1. 可重入锁ReentrantLock
+2. 用于阻塞和通知的Condition对象
+3. 根据Delay时间排序的优先级队列：PriorityQueue
+4. 用于优化阻塞通知的线程元素leader
+
+ReentrantLock、Condition这两个对象就不需要阐述了，他是实现整个BlockingQueue的核心。PriorityQueue是一个支持优先级线程排序的队列（参考【死磕Java并发】-----J.U.C之阻塞队列：PriorityBlockingQueue），leader后面阐述。这里我们先来了解Delay，他是实现延时操作的关键。
+
+### Delayed
+Delayed接口是 **用来标记那些应该在给定延迟时间之后执行的对象**，它定义了一个long getDelay(TimeUnit unit)方法，该方法返回与此对象相关的的剩余时间。
+**同时实现该接口的对象必须定义一个compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。**
+```java
+public interface Delayed extends Comparable<Delayed> {
+    long getDelay(TimeUnit unit);
+}
+```
+如何使用该接口呢？上面说的非常清楚了，实现该接口的getDelay()方法，同时定义compareTo()方法即可。
+
+内部结构
+先看DelayQueue的定义：
+```java
+public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
+        implements BlockingQueue<E> {
+    /** 可重入锁 */
+    private final transient ReentrantLock lock = new ReentrantLock();
+    /** 支持优先级的BlockingQueue */
+    private final PriorityQueue<E> q = new PriorityQueue<E>();
+    /** 用于优化阻塞 */
+    private Thread leader = null;
+    /** Condition */
+    private final Condition available = lock.newCondition();
+
+    /**
+     * 省略很多代码
+     */
+}
+```
+看了DelayQueue的内部结构就对上面几个关键点一目了然了，但是这里有一点需要注意，DelayQueue的元素都必须继承Delayed接口。
+同时也可以从这里初步理清楚DelayQueue内部实现的机制了：以 **支持优先级无界队列的PriorityQueue作为一个容器**，容器里面的元素都应该实现Delayed接口，在每次往优先级队列中添加元素时以元素的过期时间作为排序条件，最先过期的元素放在优先级最高。
+
+offer()
+```java
+public boolean offer(E e) {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        // 向 PriorityQueue中插入元素
+        q.offer(e);
+        // 如果当前元素的对首元素（优先级最高），leader设置为空，唤醒所有等待线程
+        if (q.peek() == e) {
+            leader = null;
+            available.signal();
+        }
+        // 无界队列，永远返回true
+        return true;
+    } finally {
+        lock.unlock();
+    }
+}
+```
+offer(E e)就是往PriorityQueue中添加元素，具体可以参考（【死磕Java并发】-----J.U.C之阻塞队列：PriorityBlockingQueue）。整个过程还是比较简单，但是在判断当前元素是否为对首元素，如果是的话则设置leader=null，这是非常关键的一个步骤，后面阐述。
+
+take()
+```java
+public E take() throws InterruptedException {
+    final ReentrantLock lock = this.lock;
+    lock.lockInterruptibly();
+    try {
+        for (;;) {
+            // 对首元素
+            E first = q.peek();
+            // 对首为空，阻塞，等待off()操作唤醒
+            if (first == null)
+                available.await();
+            else {
+                // 获取对首元素的超时时间
+                long delay = first.getDelay(NANOSECONDS);
+                // <=0 表示已过期，出对，return
+                if (delay <= 0)
+                    return q.poll();
+                first = null; // don't retain ref while waiting
+                // leader != null 证明有其他线程在操作，阻塞
+                if (leader != null)
+                    available.await();
+                else {
+                    // 否则将leader 设置为当前线程，独占
+                    Thread thisThread = Thread.currentThread();
+                    leader = thisThread;
+                    try {
+                        // 超时阻塞
+                        available.awaitNanos(delay);
+                    } finally {
+                        // 释放leader
+                        if (leader == thisThread)
+                            leader = null;
+                    }
+                }
+            }
+        }
+    } finally {
+        // 唤醒阻塞线程
+        if (leader == null && q.peek() != null)
+            available.signal();
+        lock.unlock();
+    }
+}
+```
+首先是获取对首元素，如果对首元素的延时时间 delay <= 0 ，则可以出对了，直接return即可。否则设置first = null，这里设置为null的主要目的是为了避免内存泄漏。如果 leader != null 则表示当前有线程占用，则阻塞，否则设置leader为当前线程，然后调用awaitNanos()方法超时等待。
+
+first = null
+
+这里为什么如果不设置first = null，则会引起内存泄漏呢？线程A到达，列首元素没有到期，设置leader = 线程A，这是线程B来了因为leader != null，则会阻塞，线程C一样。假如线程阻塞完毕了，获取列首元素成功，出列。这个时候列首元素应该会被回收掉，但是问题是它还被线程B、线程C持有着，所以不会回收，这里只有两个线程，如果有线程D、线程E...呢？这样会无限期的不能回收，就会造成内存泄漏。
+
+这个入队、出对过程和其他的阻塞队列没有很大区别，无非是在出对的时候增加了一个到期时间的判断。同时通过leader来减少不必要阻塞。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/26 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232SynchronousQueue.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/26 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232SynchronousQueue.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/26 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232SynchronousQueue.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/26 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232SynchronousQueue.md"
index 16b57788..c1509100 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/26 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232SynchronousQueue.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/26 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232SynchronousQueue.md"	
@@ -1,694 +1,694 @@
-
-作为BlockingQueue中的一员，SynchronousQueue与其他BlockingQueue有着不同特性：
-
-1. SynchronousQueue没有容量。与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue。每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
-2. 因为没有容量，所以对应 peek, contains, clear, isEmpty ... 等方法其实是无效的。例如clear是不执行任何操作的，contains始终返回false,peek始终返回null。
-3. SynchronousQueue分为公平和非公平，默认情况下采用`非公平性`访问策略，当然也可以通过构造函数来设置为公平性访问策略（为true即可）。
-若使用 TransferQueue, 则队列中永远会存在一个 dummy node（这点后面详细阐述）。
-4. SynchronousQueue非常适合做交换工作，生产者的线程和消费者的线程同步以传递某些信息、事件或者任务。
-
-
-SynchronousQueue
-与其他BlockingQueue一样，SynchronousQueue同样继承AbstractQueue和实现BlockingQueue接口：
-```
-public class SynchronousQueue<E> extends AbstractQueue<E>
-    implements BlockingQueue<E>, java.io.Serializable
-```
-SynchronousQueue提供了两个构造函数：
-```java
-public SynchronousQueue() {
-    this(false);
-}
-
-public SynchronousQueue(boolean fair) {
-    // 通过 fair 值来决定公平性和非公平性
-    // 公平性使用TransferQueue，非公平性采用TransferStack
-    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
-}
-```
-TransferQueue、TransferStack继承Transferer，Transferer为SynchronousQueue的内部类，它提供了一个方法transfer()，该方法定义了转移数据的规范，如下：
-```java
-abstract static class Transferer<E> {
-    abstract E transfer(E e, boolean timed, long nanos);
-}
-```
-transfer()方法主要用来完成转移数据的，如果e != null，相当于将一个数据交给消费者，如果e == null，则相当于从一个生产者接收一个消费者交出的数据。
-
-SynchronousQueue采用队列TransferQueue来实现公平性策略，采用堆栈TransferStack来实现非公平性策略，他们两种都是通过链表实现的，其节点分别为QNode，SNode。TransferQueue和TransferStack在SynchronousQueue中扮演着非常重要的作用，SynchronousQueue的put、take操作都是委托这两个类来实现的。
-
-### 1. TransferQueue
-TransferQueue是实现公平性策略的核心类，其节点为QNode，其定义如下：
-```java
-static final class TransferQueue<E> extends Transferer<E> {
-    /** 头节点 */
-    transient volatile QNode head;
-    /** 尾节点 */
-    transient volatile QNode tail;
-    // 指向一个取消的结点
-    //当一个节点中最后一个插入时，它被取消了但是可能还没有离开队列
-    transient volatile QNode cleanMe;
-
-    /**
-     * 省略很多代码O(∩_∩)O
-     */
-}
-```
-在TransferQueue中除了头、尾节点外还存在一个cleanMe节点。该节点主要用于标记，当删除的节点是尾节点时则需要使用该节点。
-
-同时，对于TransferQueue需要注意的是，其队列永远都存在一个dummy node，在构造时创建：
-```java
-TransferQueue() {
-    QNode h = new QNode(null, false); // initialize to dummy node.
-    head = h;
-    tail = h;
-}
-```
-在TransferQueue中定义了QNode类来表示队列中的节点，QNode节点定义如下：
-```java
-static final class QNode {
-    // next 域
-    volatile QNode next;
-    // item数据项
-    volatile Object item;
-    //  等待线程，用于park/unpark
-    volatile Thread waiter;       // to control park/unpark
-    //模式，表示当前是数据还是请求，只有当匹配的模式相匹配时才会交换
-    final boolean isData;
-
-    QNode(Object item, boolean isData) {
-        this.item = item;
-        this.isData = isData;
-    }
-
-    /**
-     * CAS next域，在TransferQueue中用于向next推进
-     */
-    boolean casNext(QNode cmp, QNode val) {
-        return next == cmp &&
-                UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
-    }
-
-    /**
-     * CAS itme数据项
-     */
-    boolean casItem(Object cmp, Object val) {
-        return item == cmp &&
-                UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
-    }
-
-    /**
-     *  取消本结点，将item域设置为自身
-     */
-    void tryCancel(Object cmp) {
-        UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);
-    }
-
-    /**
-     * 是否被取消
-     * 与tryCancel相照应只需要判断item释放等于自身即可
-     */
-    boolean isCancelled() {
-        return item == this;
-    }
-
-
-    boolean isOffList() {
-        return next == this;
-    }
-
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long itemOffset;
-    private static final long nextOffset;
-
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class<?> k = QNode.class;
-            itemOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("item"));
-            nextOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("next"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
-}
-```
-上面代码没啥好看的，需要注意的一点就是isData，该属性在进行数据交换起到关键性作用，两个线程进行数据交换的时候，必须要两者的模式保持一致。
-
-### 2. TransferStack
-TransferStack用于实现非公平性，定义如下：
-```java
-static final class TransferStack<E> extends Transferer<E> {
-
-    static final int REQUEST    = 0;
-
-    static final int DATA       = 1;
-
-    static final int FULFILLING = 2;
-
-    volatile SNode head;
-
-    /**
-     * 省略一堆代码  O(∩_∩)O~
-     */
-
-}
-```
-TransferStack中定义了三个状态：REQUEST表示消费数据的消费者，DATA表示生产数据的生产者，FULFILLING，表示匹配另一个生产者或消费者。任何线程对TransferStack的操作都属于上述3种状态中的一种（对应着SNode节点的mode）。同时还包含一个head域，表示头结点。
-
-内部节点SNode定义如下：
-```java
-static final class SNode {
-    // next 域
-    volatile SNode next;
-    // 相匹配的节点
-    volatile SNode match;
-    // 等待的线程
-    volatile Thread waiter;
-    // item 域
-    Object item;                // data; or null for REQUESTs
-
-    // 模型
-    int mode;
-
-    /**
-     * item域和mode域不需要使用volatile修饰，因为它们在volatile/atomic操作之前写，之后读
-     */
-
-    SNode(Object item) {
-        this.item = item;
-    }
-
-    boolean casNext(SNode cmp, SNode val) {
-        return cmp == next &&
-                UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
-    }
-
-    /**
-     * 将s结点与本结点进行匹配，匹配成功，则unpark等待线程
-     */
-    boolean tryMatch(SNode s) {
-        if (match == null &&
-                UNSAFE.compareAndSwapObject(this, matchOffset, null, s)) {
-            Thread w = waiter;
-            if (w != null) {    // waiters need at most one unpark
-                waiter = null;
-                LockSupport.unpark(w);
-            }
-            return true;
-        }
-        return match == s;
-    }
-
-    void tryCancel() {
-        UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
-    }
-
-    boolean isCancelled() {
-        return match == this;
-    }
-
-    // Unsafe mechanics
-    private static final sun.misc.Unsafe UNSAFE;
-    private static final long matchOffset;
-    private static final long nextOffset;
-
-    static {
-        try {
-            UNSAFE = sun.misc.Unsafe.getUnsafe();
-            Class<?> k = SNode.class;
-            matchOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("match"));
-            nextOffset = UNSAFE.objectFieldOffset
-                    (k.getDeclaredField("next"));
-        } catch (Exception e) {
-            throw new Error(e);
-        }
-    }
-}
-```
-上面简单介绍了TransferQueue、TransferStack，由于SynchronousQueue的put、take操作都是调用Transfer的transfer()方法，只不过是传递的参数不同而已，put传递的是e参数，所以模式为数据（公平isData = true，非公平mode= DATA），而take操作传递的是null，所以模式为请求（公平isData = false，非公平mode = REQUEST），如下：
-
-```java
-// put操作
-public void put(E e) throws InterruptedException {
-    if (e == null) throw new NullPointerException();
-    if (transferer.transfer(e, false, 0) == null) {
-        Thread.interrupted();
-        throw new InterruptedException();
-    }
-}
-```
-
-```java
-// take操作
-public E take() throws InterruptedException {
-    E e = transferer.transfer(null, false, 0);
-    if (e != null)
-        return e;
-    Thread.interrupted();
-    throw new InterruptedException();
-}
-```
-### 3. 公平模式
-公平性调用TransferQueue的transfer方法：
-```java
-    E transfer(E e, boolean timed, long nanos) {
-        QNode s = null;
-        // 当前节点模式
-        boolean isData = (e != null);
-
-        for (;;) {
-            QNode t = tail;
-            QNode h = head;
-            // 头、尾节点 为null，没有初始化
-            if (t == null || h == null)
-                continue;
-
-            // 头尾节点相等（队列为null） 或者当前节点和队列节点模式一样
-            if (h == t || t.isData == isData) {
-                // tn = t.next
-                QNode tn = t.next;
-                // t != tail表示已有其他线程操作了，修改了tail，重新再来
-                if (t != tail)
-                    continue;
-                // tn != null，表示已经有其他线程添加了节点，tn 推进，重新处理
-                if (tn != null) {
-                    // 当前线程帮忙推进尾节点，就是尝试将tn设置为尾节点
-                    advanceTail(t, tn);
-                    continue;
-                }
-                //  调用的方法的 wait 类型的, 并且 超时了, 直接返回 null
-                // timed 在take操作阐述
-                if (timed && nanos <= 0)
-                    return null;
-
-                // s == null，构建一个新节点Node
-                if (s == null)
-                    s = new QNode(e, isData);
-
-                // 将新建的节点加入到队列中，如果不成功，继续处理
-                if (!t.casNext(null, s))
-                    continue;
-
-                // 替换尾节点
-                advanceTail(t, s);
-
-                // 调用awaitFulfill, 若节点是 head.next, 则进行自旋
-                // 若不是的话, 直接 block, 直到有其他线程 与之匹配, 或它自己进行线程的中断
-                Object x = awaitFulfill(s, e, timed, nanos);
-
-                // 若返回的x == s表示，当前线程已经超时或者中断，不然的话s == null或者是匹配的节点
-                if (x == s) {
-                    // 清理节点S
-                    clean(t, s);
-                    return null;
-                }
-
-                // isOffList：用于判断节点是否已经从队列中离开了
-                if (!s.isOffList()) {
-                    // 尝试将S节点设置为head，移出t
-                    advanceHead(t, s);
-                    if (x != null)
-                        s.item = s;
-                    // 释放线程 ref
-                    s.waiter = null;
-                }
-
-                // 返回
-                return (x != null) ? (E)x : e;
-
-            }
-
-            // 这里是从head.next开始，因为TransferQueue总是会存在一个dummy node节点
-            else {
-                // 节点
-                QNode m = h.next;
-
-                // 不一致读，重新开始
-                // 有其他线程更改了线程结构
-                if (t != tail || m == null || h != head)
-                    continue;
-
-                /**
-                 * 生产者producer和消费者consumer匹配操作
-                 */
-                Object x = m.item;
-                // isData == (x != null)：判断isData与x的模式是否相同，相同表示已经匹配了
-                // x == m ：m节点被取消了
-                // !m.casItem(x, e)：如果尝试将数据e设置到m上失败
-                if (isData == (x != null) ||  x  == m || !m.casItem(x, e)) {
-                    // 将m设置为头结点，h出列，然后重试
-                    advanceHead(h, m);
-                    continue;
-                }
-
-                // 成功匹配了，m设置为头结点h出列，向前推进
-                advanceHead(h, m);
-                // 唤醒m上的等待线程
-                LockSupport.unpark(m.waiter);
-                return (x != null) ? (E)x : e;
-            }
-        }
-    }
-```
-整个transfer的算法如下：
-1. 如果队列为null或者尾节点模式与当前节点模式一致，则尝试将节点加入到等待队列中（采用自旋的方式），直到被匹配或、超时或者取消。匹配成功的话要么返回null（producer返回的）要么返回真正传递的值（consumer返回的），如果返回的是node节点本身则表示当前线程超时或者取消了。
-2. 如果队列不为null，且队列的节点是当前节点匹配的节点，则进行数据的传递匹配并返回匹配节点的数据
-3. 在整个过程中都会检测并帮助其他线程推进
-
-当队列为空时，节点入列然后通过调用awaitFulfill()方法自旋，该方法主要用于自旋/阻塞节点，直到节点被匹配返回或者取消、中断。
-```java
-    Object awaitFulfill(QNode s, E e, boolean timed, long nanos) {
-
-        // 超时控制
-        final long deadline = timed ? System.nanoTime() + nanos : 0L;
-        Thread w = Thread.currentThread();
-        // 自旋次数
-        // 如果节点Node恰好是head节点，则自旋一段时间，这里主要是为了效率问题，如果里面阻塞，会存在唤醒、线程上下文切换的问题
-        // 如果生产者、消费者者里面到来的话，就避免了这个阻塞的过程
-        int spins = ((head.next == s) ?
-                (timed ? maxTimedSpins : maxUntimedSpins) : 0);
-        // 自旋
-        for (;;) {
-            // 线程中断了，剔除当前节点
-            if (w.isInterrupted())
-                s.tryCancel(e);
-
-            // 如果线程进行了阻塞 -> 唤醒或者中断了，那么x != e 肯定成立，直接返回当前节点即可
-            Object x = s.item;
-            if (x != e)
-                return x;
-            // 超时判断
-            if (timed) {
-                nanos = deadline - System.nanoTime();
-                // 如果超时了，取消节点,continue，在if(x != e)肯定会成立，直接返回x
-                if (nanos <= 0L) {
-                    s.tryCancel(e);
-                    continue;
-                }
-            }
-
-            // 自旋- 1
-            if (spins > 0)
-                --spins;
-
-            // 等待线程
-            else if (s.waiter == null)
-                s.waiter = w;
-
-            // 进行没有超时的 park
-            else if (!timed)
-                LockSupport.park(this);
-
-            // 自旋次数过了, 直接 + timeout 方式 park
-            else if (nanos > spinForTimeoutThreshold)
-                LockSupport.parkNanos(this, nanos);
-        }
-    }
-```
-在自旋/阻塞过程中做了一点优化，就是判断当前节点是否为对头元素，如果是的则先自旋，如果自旋次数过了，则才阻塞，这样做的主要目的就在如果生产者、消费者立马来匹配了则不需要阻塞，因为阻塞、唤醒会消耗资源。在整个自旋的过程中会不断判断是否超时或者中断了，如果中断或者超时了则调用tryCancel()取消该节点。
-
-tryCancel
-```java
-            void tryCancel(Object cmp) {
-                UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);
-            }
-```
-取消过程就是将节点的item设置为自身（itemOffset是item的偏移量）。所以在调用awaitFulfill()方法时，如果当前线程被取消、中断、超时了那么返回的值肯定时S，否则返回的则是匹配的节点。如果返回值是节点S，那么if(x == s)必定成立，如下：
-```java
-                    Object x = awaitFulfill(s, e, timed, nanos);
-                    if (x == s) {                   // wait was cancelled
-                        clean(t, s);
-                        return null;
-                    }
-```                    
-如果返回的x == s成立，则调用clean()方法清理节点S：
-```java
-    void clean(QNode pred, QNode s) {
-        //
-        s.waiter = null;
-
-        while (pred.next == s) {
-            QNode h = head;
-            QNode hn = h.next;
-            // hn节点被取消了，向前推进
-            if (hn != null && hn.isCancelled()) {
-                advanceHead(h, hn);
-                continue;
-            }
-
-            // 队列为空，直接return null
-            QNode t = tail;
-            if (t == h)
-                return;
-
-            QNode tn = t.next;
-            // 不一致，说明有其他线程改变了tail节点，重新开始
-            if (t != tail)
-                continue;
-
-            // tn != null 推进tail节点，重新开始
-            if (tn != null) {
-                advanceTail(t, tn);
-                continue;
-            }
-
-            // s 不是尾节点 移出
-            if (s != t) {
-                QNode sn = s.next;
-                // 如果s已经被移除退出循环，否则尝试断开s
-                if (sn == s || pred.casNext(s, sn))
-                    return;
-            }
-
-            // s是尾节点，则有可能会有其他线程在添加新节点，则cleanMe出场
-            QNode dp = cleanMe;
-            // 如果dp不为null，说明是前一个被取消节点，将其移除
-            if (dp != null) {
-                QNode d = dp.next;
-                QNode dn;
-                if (d == null ||               // 节点d已经删除
-                        d == dp ||                 // 原来的节点 cleanMe 已经通过 advanceHead 进行删除
-                        !d.isCancelled() ||        // 原来的节点 s已经删除
-                        (d != t &&                 // d 不是tail节点
-                                (dn = d.next) != null &&  //
-                                dn != d &&                //   that is on list
-                                dp.casNext(d, dn)))       // d unspliced
-                    // 清除 cleanMe 节点, 这里的 dp == pred 若成立, 说明清除节点s，成功, 直接return, 不然的话要再次循环
-                    casCleanMe(dp, null);
-                if (dp == pred)
-                    return;
-            } else if (casCleanMe(null, pred))  // 原来的 cleanMe 是 null, 则将 pred 标记为 cleamMe 为下次 清除 s 节点做标识
-                return;
-        }
-    }
-```    
-这里是引用 http://www.jianshu.com/p/95cb570c8187
-
-1. 删除的节点不是queue尾节点, 这时 直接 pred.casNext(s, s.next) 方式来进行删除(和ConcurrentLikedQueue中差不多)
-2. 删除的节点是队尾节点
-  * 此时 cleanMe == null, 则 前继节点pred标记为 cleanMe, 为下次删除做准备
-  * 此时 cleanMe != null, 先删除上次需要删除的节点, 然后将 cleanMe至null, 让后再将 pred 赋值给 cleanMe
-
-### 4. 非公平模式
-非公平模式transfer方法如下：
-```java
-E transfer(E e, boolean timed, long nanos) {
-    SNode s = null; // constructed/reused as needed
-    int mode = (e == null) ? REQUEST : DATA;
-
-    for (;;) {
-        SNode h = head;
-        // 栈为空或者当前节点模式与头节点模式一样，将节点压入栈内，等待匹配
-        if (h == null || h.mode == mode) {
-            // 超时
-            if (timed && nanos <= 0) {
-                // 节点被取消了，向前推进
-                if (h != null && h.isCancelled())
-                    //  重新设置头结点（弹出之前的头结点）
-                    casHead(h, h.next);
-                else
-                    return null;
-            }
-            // 不超时
-            // 生成一个SNode节点，并尝试替换掉头节点head (head -> s)
-            else if (casHead(h, s = snode(s, e, h, mode))) {
-                // 自旋，等待线程匹配
-                SNode m = awaitFulfill(s, timed, nanos);
-                // 返回的m == s 表示该节点被取消了或者超时、中断了
-                if (m == s) {
-                    // 清理节点S，return null
-                    clean(s);
-                    return null;
-                }
-
-                // 因为通过前面一步将S替换成了head，如果h.next == s ，则表示有其他节点插入到S前面了,变成了head
-                // 且该节点就是与节点S匹配的节点
-                if ((h = head) != null && h.next == s)
-                    // 将s.next节点设置为head，相当于取消节点h、s
-                    casHead(h, s.next);
-
-                // 如果是请求则返回匹配的域，否则返回节点S的域
-                return (E) ((mode == REQUEST) ? m.item : s.item);
-            }
-        }
-
-        // 如果栈不为null，且两者模式不匹配（h != null && h.mode != mode）
-        // 说明他们是一队对等匹配的节点，尝试用当前节点s来满足h节点
-        else if (!isFulfilling(h.mode)) {
-            // head 节点已经取消了，向前推进
-            if (h.isCancelled())
-                casHead(h, h.next);
-
-            // 尝试将当前节点打上"正在匹配"的标记，并设置为head
-            else if (casHead(h, s=snode(s, e, h, FULFILLING|mode))) {
-                // 循环loop
-                for (;;) {
-                    // s为当前节点，m是s的next节点，
-                    // m节点是s节点的匹配节点
-                    SNode m = s.next;
-                    // m == null，其他节点把m节点匹配走了
-                    if (m == null) {
-                        // 将s弹出
-                        casHead(s, null);
-                        // 将s置空，下轮循环的时候还会新建
-                        s = null;
-                        // 退出该循环，继续主循环
-                        break;
-                    }
-                    // 获取m的next节点
-                    SNode mn = m.next;
-                    // 尝试匹配
-                    if (m.tryMatch(s)) {
-                        // 匹配成功，将s 、 m弹出
-                        casHead(s, mn);     // pop both s and m
-                        return (E) ((mode == REQUEST) ? m.item : s.item);
-                    } else
-                        // 如果没有匹配成功，说明有其他线程已经匹配了，把m移出
-                        s.casNext(m, mn);
-                }
-            }
-        }
-        // 到这最后一步说明节点正在匹配阶段
-        else {
-            // head 的next的节点，是正在匹配的节点，m 和 h配对
-            SNode m = h.next;
-
-            // m == null 其他线程把m节点抢走了，弹出h节点
-            if (m == null)
-                casHead(h, null);
-            else {
-                SNode mn = m.next;
-                if (m.tryMatch(h))
-                    casHead(h, mn);
-                else
-                    h.casNext(m, mn);
-            }
-        }
-    }
-}
-```    
-整个处理过程分为三种情况，具体如下：
-1. 如果当前栈为空获取节点模式与栈顶模式一样，则尝试将节点加入栈内，同时通过自旋方式等待节点匹配，最后返回匹配的节点或者null（被取消）
-2. 如果栈不为空且节点的模式与首节点模式匹配，则尝试将该节点打上FULFILLING标记，然后加入栈中，与相应的节点匹配，成功后将这两个节点弹出栈并返回匹配节点的数据
-3. 如果有节点在匹配，那么帮助这个节点完成匹配和出栈操作，然后在主循环中继续执行
-
-当节点加入栈内后，通过调用awaitFulfill()方法自旋等待节点匹配：
-```java
-SNode awaitFulfill(SNode s, boolean timed, long nanos) {
-    // 超时
-    final long deadline = timed ? System.nanoTime() + nanos : 0L;
-    // 当前线程
-    Thread w = Thread.currentThread();
-
-    // 自旋次数
-    // shouldSpin 用于检测当前节点是否需要自旋
-    // 如果栈为空、该节点是首节点或者该节点是匹配节点，则先采用自旋，否则阻塞
-    int spins = (shouldSpin(s) ?
-            (timed ? maxTimedSpins : maxUntimedSpins) : 0);
-    for (;;) {
-        // 线程中断了，取消该节点
-        if (w.isInterrupted())
-            s.tryCancel();
-
-        // 匹配节点
-        SNode m = s.match;
-
-        // 如果匹配节点m不为空，则表示匹配成功，直接返回
-        if (m != null)
-            return m;
-        // 超时
-        if (timed) {
-            nanos = deadline - System.nanoTime();
-            // 节点超时，取消
-            if (nanos <= 0L) {
-                s.tryCancel();
-                continue;
-            }
-        }
-
-        // 自旋;每次自旋的时候都需要检查自身是否满足自旋条件，满足就 - 1，否则为0
-        if (spins > 0)
-            spins = shouldSpin(s) ? (spins-1) : 0;
-
-        // 第一次阻塞时，会将当前线程设置到s上
-        else if (s.waiter == null)
-            s.waiter = w;
-
-        // 阻塞 当前线程
-        else if (!timed)
-            LockSupport.park(this);
-        // 超时
-        else if (nanos > spinForTimeoutThreshold)
-            LockSupport.parkNanos(this, nanos);
-    }
-}
-```    
-awaitFulfill()方法会一直自旋/阻塞直到匹配节点。在S节点阻塞之前会先调用shouldSpin()方法判断是否采用自旋方式，为的就是如果有生产者或者消费者马上到来，就不需要阻塞了，在多核条件下这种优化是有必要的。同时在调用park()阻塞之前会将当前线程设置到S节点的waiter上。匹配成功，返回匹配节点m。
-
-shouldSpin()方法如下：
-```java
-boolean shouldSpin(SNode s) {
-    SNode h = head;
-    return (h == s || h == null || isFulfilling(h.mode));
-}
-```        
-同时在阻塞过程中会一直检测当前线程是否中断了，如果中断了，则调用tryCancel()方法取消该节点，取消过程就是将当前节点的math设置为当前节点。所以如果线程中断了，那么在返回m时一定是S节点自身。
-```java
-            void tryCancel() {
-                UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
-            }
-```            
-awaitFullfill()方法如果返回的m == s，则表示当前节点已经中断取消了，则需要调用clean()方法，清理节点S：
-```java
-void clean(SNode s) {
-
-    // 清理item域
-    s.item = null;
-    // 清理waiter域
-    s.waiter = null;
-
-    // past节点
-    SNode past = s.next;
-    if (past != null && past.isCancelled())
-        past = past.next;
-
-    // 从栈顶head节点，取消从栈顶head到past节点之间所有已经取消的节点
-    // 注意：这里如果遇到一个节点没有取消，则会退出while
-    SNode p;
-    while ((p = head) != null && p != past && p.isCancelled())
-        casHead(p, p.next);     // 如果p节点已经取消了，则剔除该节点
-
-    // 如果经历上面while p节点还没有取消，则再次循环取消掉所有p 到past之间的取消节点
-    while (p != null && p != past) {
-        SNode n = p.next;
-        if (n != null && n.isCancelled())
-            p.casNext(n, n.next);
-        else
-            p = n;
-    }
-}
-```
-clean()方法就是将head节点到S节点之间所有已经取消的节点全部移出。【不清楚为何要用两个while，一个不行么】
+
+作为BlockingQueue中的一员，SynchronousQueue与其他BlockingQueue有着不同特性：
+
+1. SynchronousQueue没有容量。与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue。每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
+2. 因为没有容量，所以对应 peek, contains, clear, isEmpty ... 等方法其实是无效的。例如clear是不执行任何操作的，contains始终返回false,peek始终返回null。
+3. SynchronousQueue分为公平和非公平，默认情况下采用`非公平性`访问策略，当然也可以通过构造函数来设置为公平性访问策略（为true即可）。
+若使用 TransferQueue, 则队列中永远会存在一个 dummy node（这点后面详细阐述）。
+4. SynchronousQueue非常适合做交换工作，生产者的线程和消费者的线程同步以传递某些信息、事件或者任务。
+
+
+SynchronousQueue
+与其他BlockingQueue一样，SynchronousQueue同样继承AbstractQueue和实现BlockingQueue接口：
+```
+public class SynchronousQueue<E> extends AbstractQueue<E>
+    implements BlockingQueue<E>, java.io.Serializable
+```
+SynchronousQueue提供了两个构造函数：
+```java
+public SynchronousQueue() {
+    this(false);
+}
+
+public SynchronousQueue(boolean fair) {
+    // 通过 fair 值来决定公平性和非公平性
+    // 公平性使用TransferQueue，非公平性采用TransferStack
+    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
+}
+```
+TransferQueue、TransferStack继承Transferer，Transferer为SynchronousQueue的内部类，它提供了一个方法transfer()，该方法定义了转移数据的规范，如下：
+```java
+abstract static class Transferer<E> {
+    abstract E transfer(E e, boolean timed, long nanos);
+}
+```
+transfer()方法主要用来完成转移数据的，如果e != null，相当于将一个数据交给消费者，如果e == null，则相当于从一个生产者接收一个消费者交出的数据。
+
+SynchronousQueue采用队列TransferQueue来实现公平性策略，采用堆栈TransferStack来实现非公平性策略，他们两种都是通过链表实现的，其节点分别为QNode，SNode。TransferQueue和TransferStack在SynchronousQueue中扮演着非常重要的作用，SynchronousQueue的put、take操作都是委托这两个类来实现的。
+
+### 1. TransferQueue
+TransferQueue是实现公平性策略的核心类，其节点为QNode，其定义如下：
+```java
+static final class TransferQueue<E> extends Transferer<E> {
+    /** 头节点 */
+    transient volatile QNode head;
+    /** 尾节点 */
+    transient volatile QNode tail;
+    // 指向一个取消的结点
+    //当一个节点中最后一个插入时，它被取消了但是可能还没有离开队列
+    transient volatile QNode cleanMe;
+
+    /**
+     * 省略很多代码O(∩_∩)O
+     */
+}
+```
+在TransferQueue中除了头、尾节点外还存在一个cleanMe节点。该节点主要用于标记，当删除的节点是尾节点时则需要使用该节点。
+
+同时，对于TransferQueue需要注意的是，其队列永远都存在一个dummy node，在构造时创建：
+```java
+TransferQueue() {
+    QNode h = new QNode(null, false); // initialize to dummy node.
+    head = h;
+    tail = h;
+}
+```
+在TransferQueue中定义了QNode类来表示队列中的节点，QNode节点定义如下：
+```java
+static final class QNode {
+    // next 域
+    volatile QNode next;
+    // item数据项
+    volatile Object item;
+    //  等待线程，用于park/unpark
+    volatile Thread waiter;       // to control park/unpark
+    //模式，表示当前是数据还是请求，只有当匹配的模式相匹配时才会交换
+    final boolean isData;
+
+    QNode(Object item, boolean isData) {
+        this.item = item;
+        this.isData = isData;
+    }
+
+    /**
+     * CAS next域，在TransferQueue中用于向next推进
+     */
+    boolean casNext(QNode cmp, QNode val) {
+        return next == cmp &&
+                UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+    }
+
+    /**
+     * CAS itme数据项
+     */
+    boolean casItem(Object cmp, Object val) {
+        return item == cmp &&
+                UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
+    }
+
+    /**
+     *  取消本结点，将item域设置为自身
+     */
+    void tryCancel(Object cmp) {
+        UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);
+    }
+
+    /**
+     * 是否被取消
+     * 与tryCancel相照应只需要判断item释放等于自身即可
+     */
+    boolean isCancelled() {
+        return item == this;
+    }
+
+
+    boolean isOffList() {
+        return next == this;
+    }
+
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long itemOffset;
+    private static final long nextOffset;
+
+    static {
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = QNode.class;
+            itemOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("item"));
+            nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+}
+```
+上面代码没啥好看的，需要注意的一点就是isData，该属性在进行数据交换起到关键性作用，两个线程进行数据交换的时候，必须要两者的模式保持一致。
+
+### 2. TransferStack
+TransferStack用于实现非公平性，定义如下：
+```java
+static final class TransferStack<E> extends Transferer<E> {
+
+    static final int REQUEST    = 0;
+
+    static final int DATA       = 1;
+
+    static final int FULFILLING = 2;
+
+    volatile SNode head;
+
+    /**
+     * 省略一堆代码  O(∩_∩)O~
+     */
+
+}
+```
+TransferStack中定义了三个状态：REQUEST表示消费数据的消费者，DATA表示生产数据的生产者，FULFILLING，表示匹配另一个生产者或消费者。任何线程对TransferStack的操作都属于上述3种状态中的一种（对应着SNode节点的mode）。同时还包含一个head域，表示头结点。
+
+内部节点SNode定义如下：
+```java
+static final class SNode {
+    // next 域
+    volatile SNode next;
+    // 相匹配的节点
+    volatile SNode match;
+    // 等待的线程
+    volatile Thread waiter;
+    // item 域
+    Object item;                // data; or null for REQUESTs
+
+    // 模型
+    int mode;
+
+    /**
+     * item域和mode域不需要使用volatile修饰，因为它们在volatile/atomic操作之前写，之后读
+     */
+
+    SNode(Object item) {
+        this.item = item;
+    }
+
+    boolean casNext(SNode cmp, SNode val) {
+        return cmp == next &&
+                UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+    }
+
+    /**
+     * 将s结点与本结点进行匹配，匹配成功，则unpark等待线程
+     */
+    boolean tryMatch(SNode s) {
+        if (match == null &&
+                UNSAFE.compareAndSwapObject(this, matchOffset, null, s)) {
+            Thread w = waiter;
+            if (w != null) {    // waiters need at most one unpark
+                waiter = null;
+                LockSupport.unpark(w);
+            }
+            return true;
+        }
+        return match == s;
+    }
+
+    void tryCancel() {
+        UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
+    }
+
+    boolean isCancelled() {
+        return match == this;
+    }
+
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long matchOffset;
+    private static final long nextOffset;
+
+    static {
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = SNode.class;
+            matchOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("match"));
+            nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+}
+```
+上面简单介绍了TransferQueue、TransferStack，由于SynchronousQueue的put、take操作都是调用Transfer的transfer()方法，只不过是传递的参数不同而已，put传递的是e参数，所以模式为数据（公平isData = true，非公平mode= DATA），而take操作传递的是null，所以模式为请求（公平isData = false，非公平mode = REQUEST），如下：
+
+```java
+// put操作
+public void put(E e) throws InterruptedException {
+    if (e == null) throw new NullPointerException();
+    if (transferer.transfer(e, false, 0) == null) {
+        Thread.interrupted();
+        throw new InterruptedException();
+    }
+}
+```
+
+```java
+// take操作
+public E take() throws InterruptedException {
+    E e = transferer.transfer(null, false, 0);
+    if (e != null)
+        return e;
+    Thread.interrupted();
+    throw new InterruptedException();
+}
+```
+### 3. 公平模式
+公平性调用TransferQueue的transfer方法：
+```java
+    E transfer(E e, boolean timed, long nanos) {
+        QNode s = null;
+        // 当前节点模式
+        boolean isData = (e != null);
+
+        for (;;) {
+            QNode t = tail;
+            QNode h = head;
+            // 头、尾节点 为null，没有初始化
+            if (t == null || h == null)
+                continue;
+
+            // 头尾节点相等（队列为null） 或者当前节点和队列节点模式一样
+            if (h == t || t.isData == isData) {
+                // tn = t.next
+                QNode tn = t.next;
+                // t != tail表示已有其他线程操作了，修改了tail，重新再来
+                if (t != tail)
+                    continue;
+                // tn != null，表示已经有其他线程添加了节点，tn 推进，重新处理
+                if (tn != null) {
+                    // 当前线程帮忙推进尾节点，就是尝试将tn设置为尾节点
+                    advanceTail(t, tn);
+                    continue;
+                }
+                //  调用的方法的 wait 类型的, 并且 超时了, 直接返回 null
+                // timed 在take操作阐述
+                if (timed && nanos <= 0)
+                    return null;
+
+                // s == null，构建一个新节点Node
+                if (s == null)
+                    s = new QNode(e, isData);
+
+                // 将新建的节点加入到队列中，如果不成功，继续处理
+                if (!t.casNext(null, s))
+                    continue;
+
+                // 替换尾节点
+                advanceTail(t, s);
+
+                // 调用awaitFulfill, 若节点是 head.next, 则进行自旋
+                // 若不是的话, 直接 block, 直到有其他线程 与之匹配, 或它自己进行线程的中断
+                Object x = awaitFulfill(s, e, timed, nanos);
+
+                // 若返回的x == s表示，当前线程已经超时或者中断，不然的话s == null或者是匹配的节点
+                if (x == s) {
+                    // 清理节点S
+                    clean(t, s);
+                    return null;
+                }
+
+                // isOffList：用于判断节点是否已经从队列中离开了
+                if (!s.isOffList()) {
+                    // 尝试将S节点设置为head，移出t
+                    advanceHead(t, s);
+                    if (x != null)
+                        s.item = s;
+                    // 释放线程 ref
+                    s.waiter = null;
+                }
+
+                // 返回
+                return (x != null) ? (E)x : e;
+
+            }
+
+            // 这里是从head.next开始，因为TransferQueue总是会存在一个dummy node节点
+            else {
+                // 节点
+                QNode m = h.next;
+
+                // 不一致读，重新开始
+                // 有其他线程更改了线程结构
+                if (t != tail || m == null || h != head)
+                    continue;
+
+                /**
+                 * 生产者producer和消费者consumer匹配操作
+                 */
+                Object x = m.item;
+                // isData == (x != null)：判断isData与x的模式是否相同，相同表示已经匹配了
+                // x == m ：m节点被取消了
+                // !m.casItem(x, e)：如果尝试将数据e设置到m上失败
+                if (isData == (x != null) ||  x  == m || !m.casItem(x, e)) {
+                    // 将m设置为头结点，h出列，然后重试
+                    advanceHead(h, m);
+                    continue;
+                }
+
+                // 成功匹配了，m设置为头结点h出列，向前推进
+                advanceHead(h, m);
+                // 唤醒m上的等待线程
+                LockSupport.unpark(m.waiter);
+                return (x != null) ? (E)x : e;
+            }
+        }
+    }
+```
+整个transfer的算法如下：
+1. 如果队列为null或者尾节点模式与当前节点模式一致，则尝试将节点加入到等待队列中（采用自旋的方式），直到被匹配或、超时或者取消。匹配成功的话要么返回null（producer返回的）要么返回真正传递的值（consumer返回的），如果返回的是node节点本身则表示当前线程超时或者取消了。
+2. 如果队列不为null，且队列的节点是当前节点匹配的节点，则进行数据的传递匹配并返回匹配节点的数据
+3. 在整个过程中都会检测并帮助其他线程推进
+
+当队列为空时，节点入列然后通过调用awaitFulfill()方法自旋，该方法主要用于自旋/阻塞节点，直到节点被匹配返回或者取消、中断。
+```java
+    Object awaitFulfill(QNode s, E e, boolean timed, long nanos) {
+
+        // 超时控制
+        final long deadline = timed ? System.nanoTime() + nanos : 0L;
+        Thread w = Thread.currentThread();
+        // 自旋次数
+        // 如果节点Node恰好是head节点，则自旋一段时间，这里主要是为了效率问题，如果里面阻塞，会存在唤醒、线程上下文切换的问题
+        // 如果生产者、消费者者里面到来的话，就避免了这个阻塞的过程
+        int spins = ((head.next == s) ?
+                (timed ? maxTimedSpins : maxUntimedSpins) : 0);
+        // 自旋
+        for (;;) {
+            // 线程中断了，剔除当前节点
+            if (w.isInterrupted())
+                s.tryCancel(e);
+
+            // 如果线程进行了阻塞 -> 唤醒或者中断了，那么x != e 肯定成立，直接返回当前节点即可
+            Object x = s.item;
+            if (x != e)
+                return x;
+            // 超时判断
+            if (timed) {
+                nanos = deadline - System.nanoTime();
+                // 如果超时了，取消节点,continue，在if(x != e)肯定会成立，直接返回x
+                if (nanos <= 0L) {
+                    s.tryCancel(e);
+                    continue;
+                }
+            }
+
+            // 自旋- 1
+            if (spins > 0)
+                --spins;
+
+            // 等待线程
+            else if (s.waiter == null)
+                s.waiter = w;
+
+            // 进行没有超时的 park
+            else if (!timed)
+                LockSupport.park(this);
+
+            // 自旋次数过了, 直接 + timeout 方式 park
+            else if (nanos > spinForTimeoutThreshold)
+                LockSupport.parkNanos(this, nanos);
+        }
+    }
+```
+在自旋/阻塞过程中做了一点优化，就是判断当前节点是否为对头元素，如果是的则先自旋，如果自旋次数过了，则才阻塞，这样做的主要目的就在如果生产者、消费者立马来匹配了则不需要阻塞，因为阻塞、唤醒会消耗资源。在整个自旋的过程中会不断判断是否超时或者中断了，如果中断或者超时了则调用tryCancel()取消该节点。
+
+tryCancel
+```java
+            void tryCancel(Object cmp) {
+                UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);
+            }
+```
+取消过程就是将节点的item设置为自身（itemOffset是item的偏移量）。所以在调用awaitFulfill()方法时，如果当前线程被取消、中断、超时了那么返回的值肯定时S，否则返回的则是匹配的节点。如果返回值是节点S，那么if(x == s)必定成立，如下：
+```java
+                    Object x = awaitFulfill(s, e, timed, nanos);
+                    if (x == s) {                   // wait was cancelled
+                        clean(t, s);
+                        return null;
+                    }
+```                    
+如果返回的x == s成立，则调用clean()方法清理节点S：
+```java
+    void clean(QNode pred, QNode s) {
+        //
+        s.waiter = null;
+
+        while (pred.next == s) {
+            QNode h = head;
+            QNode hn = h.next;
+            // hn节点被取消了，向前推进
+            if (hn != null && hn.isCancelled()) {
+                advanceHead(h, hn);
+                continue;
+            }
+
+            // 队列为空，直接return null
+            QNode t = tail;
+            if (t == h)
+                return;
+
+            QNode tn = t.next;
+            // 不一致，说明有其他线程改变了tail节点，重新开始
+            if (t != tail)
+                continue;
+
+            // tn != null 推进tail节点，重新开始
+            if (tn != null) {
+                advanceTail(t, tn);
+                continue;
+            }
+
+            // s 不是尾节点 移出
+            if (s != t) {
+                QNode sn = s.next;
+                // 如果s已经被移除退出循环，否则尝试断开s
+                if (sn == s || pred.casNext(s, sn))
+                    return;
+            }
+
+            // s是尾节点，则有可能会有其他线程在添加新节点，则cleanMe出场
+            QNode dp = cleanMe;
+            // 如果dp不为null，说明是前一个被取消节点，将其移除
+            if (dp != null) {
+                QNode d = dp.next;
+                QNode dn;
+                if (d == null ||               // 节点d已经删除
+                        d == dp ||                 // 原来的节点 cleanMe 已经通过 advanceHead 进行删除
+                        !d.isCancelled() ||        // 原来的节点 s已经删除
+                        (d != t &&                 // d 不是tail节点
+                                (dn = d.next) != null &&  //
+                                dn != d &&                //   that is on list
+                                dp.casNext(d, dn)))       // d unspliced
+                    // 清除 cleanMe 节点, 这里的 dp == pred 若成立, 说明清除节点s，成功, 直接return, 不然的话要再次循环
+                    casCleanMe(dp, null);
+                if (dp == pred)
+                    return;
+            } else if (casCleanMe(null, pred))  // 原来的 cleanMe 是 null, 则将 pred 标记为 cleamMe 为下次 清除 s 节点做标识
+                return;
+        }
+    }
+```    
+这里是引用 http://www.jianshu.com/p/95cb570c8187
+
+1. 删除的节点不是queue尾节点, 这时 直接 pred.casNext(s, s.next) 方式来进行删除(和ConcurrentLikedQueue中差不多)
+2. 删除的节点是队尾节点
+  * 此时 cleanMe == null, 则 前继节点pred标记为 cleanMe, 为下次删除做准备
+  * 此时 cleanMe != null, 先删除上次需要删除的节点, 然后将 cleanMe至null, 让后再将 pred 赋值给 cleanMe
+
+### 4. 非公平模式
+非公平模式transfer方法如下：
+```java
+E transfer(E e, boolean timed, long nanos) {
+    SNode s = null; // constructed/reused as needed
+    int mode = (e == null) ? REQUEST : DATA;
+
+    for (;;) {
+        SNode h = head;
+        // 栈为空或者当前节点模式与头节点模式一样，将节点压入栈内，等待匹配
+        if (h == null || h.mode == mode) {
+            // 超时
+            if (timed && nanos <= 0) {
+                // 节点被取消了，向前推进
+                if (h != null && h.isCancelled())
+                    //  重新设置头结点（弹出之前的头结点）
+                    casHead(h, h.next);
+                else
+                    return null;
+            }
+            // 不超时
+            // 生成一个SNode节点，并尝试替换掉头节点head (head -> s)
+            else if (casHead(h, s = snode(s, e, h, mode))) {
+                // 自旋，等待线程匹配
+                SNode m = awaitFulfill(s, timed, nanos);
+                // 返回的m == s 表示该节点被取消了或者超时、中断了
+                if (m == s) {
+                    // 清理节点S，return null
+                    clean(s);
+                    return null;
+                }
+
+                // 因为通过前面一步将S替换成了head，如果h.next == s ，则表示有其他节点插入到S前面了,变成了head
+                // 且该节点就是与节点S匹配的节点
+                if ((h = head) != null && h.next == s)
+                    // 将s.next节点设置为head，相当于取消节点h、s
+                    casHead(h, s.next);
+
+                // 如果是请求则返回匹配的域，否则返回节点S的域
+                return (E) ((mode == REQUEST) ? m.item : s.item);
+            }
+        }
+
+        // 如果栈不为null，且两者模式不匹配（h != null && h.mode != mode）
+        // 说明他们是一队对等匹配的节点，尝试用当前节点s来满足h节点
+        else if (!isFulfilling(h.mode)) {
+            // head 节点已经取消了，向前推进
+            if (h.isCancelled())
+                casHead(h, h.next);
+
+            // 尝试将当前节点打上"正在匹配"的标记，并设置为head
+            else if (casHead(h, s=snode(s, e, h, FULFILLING|mode))) {
+                // 循环loop
+                for (;;) {
+                    // s为当前节点，m是s的next节点，
+                    // m节点是s节点的匹配节点
+                    SNode m = s.next;
+                    // m == null，其他节点把m节点匹配走了
+                    if (m == null) {
+                        // 将s弹出
+                        casHead(s, null);
+                        // 将s置空，下轮循环的时候还会新建
+                        s = null;
+                        // 退出该循环，继续主循环
+                        break;
+                    }
+                    // 获取m的next节点
+                    SNode mn = m.next;
+                    // 尝试匹配
+                    if (m.tryMatch(s)) {
+                        // 匹配成功，将s 、 m弹出
+                        casHead(s, mn);     // pop both s and m
+                        return (E) ((mode == REQUEST) ? m.item : s.item);
+                    } else
+                        // 如果没有匹配成功，说明有其他线程已经匹配了，把m移出
+                        s.casNext(m, mn);
+                }
+            }
+        }
+        // 到这最后一步说明节点正在匹配阶段
+        else {
+            // head 的next的节点，是正在匹配的节点，m 和 h配对
+            SNode m = h.next;
+
+            // m == null 其他线程把m节点抢走了，弹出h节点
+            if (m == null)
+                casHead(h, null);
+            else {
+                SNode mn = m.next;
+                if (m.tryMatch(h))
+                    casHead(h, mn);
+                else
+                    h.casNext(m, mn);
+            }
+        }
+    }
+}
+```    
+整个处理过程分为三种情况，具体如下：
+1. 如果当前栈为空获取节点模式与栈顶模式一样，则尝试将节点加入栈内，同时通过自旋方式等待节点匹配，最后返回匹配的节点或者null（被取消）
+2. 如果栈不为空且节点的模式与首节点模式匹配，则尝试将该节点打上FULFILLING标记，然后加入栈中，与相应的节点匹配，成功后将这两个节点弹出栈并返回匹配节点的数据
+3. 如果有节点在匹配，那么帮助这个节点完成匹配和出栈操作，然后在主循环中继续执行
+
+当节点加入栈内后，通过调用awaitFulfill()方法自旋等待节点匹配：
+```java
+SNode awaitFulfill(SNode s, boolean timed, long nanos) {
+    // 超时
+    final long deadline = timed ? System.nanoTime() + nanos : 0L;
+    // 当前线程
+    Thread w = Thread.currentThread();
+
+    // 自旋次数
+    // shouldSpin 用于检测当前节点是否需要自旋
+    // 如果栈为空、该节点是首节点或者该节点是匹配节点，则先采用自旋，否则阻塞
+    int spins = (shouldSpin(s) ?
+            (timed ? maxTimedSpins : maxUntimedSpins) : 0);
+    for (;;) {
+        // 线程中断了，取消该节点
+        if (w.isInterrupted())
+            s.tryCancel();
+
+        // 匹配节点
+        SNode m = s.match;
+
+        // 如果匹配节点m不为空，则表示匹配成功，直接返回
+        if (m != null)
+            return m;
+        // 超时
+        if (timed) {
+            nanos = deadline - System.nanoTime();
+            // 节点超时，取消
+            if (nanos <= 0L) {
+                s.tryCancel();
+                continue;
+            }
+        }
+
+        // 自旋;每次自旋的时候都需要检查自身是否满足自旋条件，满足就 - 1，否则为0
+        if (spins > 0)
+            spins = shouldSpin(s) ? (spins-1) : 0;
+
+        // 第一次阻塞时，会将当前线程设置到s上
+        else if (s.waiter == null)
+            s.waiter = w;
+
+        // 阻塞 当前线程
+        else if (!timed)
+            LockSupport.park(this);
+        // 超时
+        else if (nanos > spinForTimeoutThreshold)
+            LockSupport.parkNanos(this, nanos);
+    }
+}
+```    
+awaitFulfill()方法会一直自旋/阻塞直到匹配节点。在S节点阻塞之前会先调用shouldSpin()方法判断是否采用自旋方式，为的就是如果有生产者或者消费者马上到来，就不需要阻塞了，在多核条件下这种优化是有必要的。同时在调用park()阻塞之前会将当前线程设置到S节点的waiter上。匹配成功，返回匹配节点m。
+
+shouldSpin()方法如下：
+```java
+boolean shouldSpin(SNode s) {
+    SNode h = head;
+    return (h == s || h == null || isFulfilling(h.mode));
+}
+```        
+同时在阻塞过程中会一直检测当前线程是否中断了，如果中断了，则调用tryCancel()方法取消该节点，取消过程就是将当前节点的math设置为当前节点。所以如果线程中断了，那么在返回m时一定是S节点自身。
+```java
+            void tryCancel() {
+                UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
+            }
+```            
+awaitFullfill()方法如果返回的m == s，则表示当前节点已经中断取消了，则需要调用clean()方法，清理节点S：
+```java
+void clean(SNode s) {
+
+    // 清理item域
+    s.item = null;
+    // 清理waiter域
+    s.waiter = null;
+
+    // past节点
+    SNode past = s.next;
+    if (past != null && past.isCancelled())
+        past = past.next;
+
+    // 从栈顶head节点，取消从栈顶head到past节点之间所有已经取消的节点
+    // 注意：这里如果遇到一个节点没有取消，则会退出while
+    SNode p;
+    while ((p = head) != null && p != past && p.isCancelled())
+        casHead(p, p.next);     // 如果p节点已经取消了，则剔除该节点
+
+    // 如果经历上面while p节点还没有取消，则再次循环取消掉所有p 到past之间的取消节点
+    while (p != null && p != past) {
+        SNode n = p.next;
+        if (n != null && n.isCancelled())
+            p.casNext(n, n.next);
+        else
+            p = n;
+    }
+}
+```
+clean()方法就是将head节点到S节点之间所有已经取消的节点全部移出。【不清楚为何要用两个while，一个不行么】
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/27 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedTransferQueue.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/27 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedTransferQueue.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/27 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedTransferQueue.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/27 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedTransferQueue.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/28 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedBlockingDeque.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/28 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedBlockingDeque.md"
similarity index 96%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/28 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedBlockingDeque.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/28 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedBlockingDeque.md"
index 6fdd4b88..faa70bdc 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/28 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedBlockingDeque.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/28 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232LinkedBlockingDeque.md"	
@@ -1,226 +1,226 @@
-前面的BlockingQueue都是单向的FIFO队列，而LinkedBlockingDeque则是一个由链表组成的双向阻塞队列，双向队列就意味着可以从对头、对尾两端插入和移除元素，同样意味着LinkedBlockingDeque支持 **FIFO、FILO两种操作方式**。
-
-LinkedBlockingDeque是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为Integer.MAX_VALUE。
-
-### LinkedBlockingDeque
-LinkedBlockingDeque 继承`AbstractQueue`，实现接口`BlockingDeque`，而BlockingDeque又继承接口BlockingQueue，BlockingDeque是支持两个附加操作的 Queue，
-这两个操作是：
-  获取元素时等待双端队列变为非空；
-  存储元素时等待双端队列中的空间变得可用。
-这两类操作就为LinkedBlockingDeque 的双向操作Queue提供了可能。
-BlockingDeque接口提供了一系列的以First和Last结尾的方法，如addFirst、addLast、peekFirst、peekLast。
-
-```java
-public class LinkedBlockingDeque<E>
-    extends AbstractQueue<E>
-    implements BlockingDeque<E>, java.io.Serializable {
-
-    // 双向链表的表头
-    transient Node<E> first;
-    // 双向链表的表尾
-    transient Node<E> last;
-    // 大小，双向链表中当前节点个数
-    private transient int count;
-    // 容量，在创建LinkedBlockingDeque时指定的
-    private final int capacity;
-    final ReentrantLock lock = new ReentrantLock();
-    private final Condition notEmpty = lock.newCondition();
-    private final Condition notFull = lock.newCondition();
-
-}
-```
-通过上面的Lock可以看出，LinkedBlockingDeque底层实现机制与LinkedBlockingQueue一样，依然是通过互斥锁ReentrantLock 来实现，notEmpty 、notFull 两个Condition做协调生产者、消费者问题。
-
-与其他BlockingQueue一样，节点还是使用内部类Node：
-```java
-static final class Node<E> {
-    E item;
-
-    Node<E> prev;
-
-    Node<E> next;
-
-    Node(E x) {
-        item = x;
-    }
-}
-```
-双向嘛，节点肯定得要有前驱prev、后继next咯。
-
-基础方法
-LinkedBlockingDeque 的add、put、offer、take、peek、poll系列方法都是通过调用XXXFirst，XXXLast方法。所以这里就仅以putFirst、putLast、pollFirst、pollLast分析下。
-
-putFirst
-
-putFirst(E e) :将指定的元素插入此双端队列的开头，必要时将一直等待可用空间。
-```java
-public void putFirst(E e) throws InterruptedException {
-    // check null
-    if (e == null) throw new NullPointerException();
-    Node<E> node = new Node<E>(e);
-    // 获取锁
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        while (!linkFirst(node))
-            // 在notFull条件上等待，直到被唤醒或中断
-            notFull.await();
-    } finally {
-        // 释放锁
-        lock.unlock();
-    }
-}
-```
-先获取锁，然后调用linkFirst方法入列，最后释放锁。如果队列是满的则在notFull上面等待。linkFirst设置Node为对头：
-```java
-private boolean linkFirst(Node<E> node) {
-    // 超出容量
-    if (count >= capacity)
-        return false;
-
-    // 首节点
-    Node<E> f = first;
-    // 新节点的next指向原first
-    node.next = f;
-    // 设置node为新的first
-    first = node;
-
-    // 没有尾节点，设置node为尾节点
-    if (last == null)
-        last = node;
-    // 有尾节点，那就将之前first的pre指向新增node
-    else
-        f.prev = node;
-    ++count;
-    // 唤醒notEmpty
-    notEmpty.signal();
-    return true;
-}
-```
-linkFirst主要是设置node节点队列的列头节点，成功返回true，如果队列满了返回false。整个过程还是比较简单的。
-
-putLast
-
-putLast(E e) :将指定的元素插入此双端队列的末尾，必要时将一直等待可用空间。
-```java
-public void putLast(E e) throws InterruptedException {
-    if (e == null) throw new NullPointerException();
-    Node<E> node = new Node<E>(e);
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        while (!linkLast(node))
-            notFull.await();
-    } finally {
-        lock.unlock();
-    }
-}
-```
-调用linkLast将节点Node链接到队列尾部：
-```java
-private boolean linkLast(Node<E> node) {
-    if (count >= capacity)
-        return false;
-    // 尾节点
-    Node<E> l = last;
-
-    // 将Node的前驱指向原本的last
-    node.prev = l;
-
-    // 将node设置为last
-    last = node;
-    // 首节点为null，则设置node为first
-    if (first == null)
-        first = node;
-    else
-    //非null，说明之前的last有值，就将之前的last的next指向node
-        l.next = node;
-    ++count;
-    notEmpty.signal();
-    return true;
-}
-```
-pollFirst
-
-pollFirst()：获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
-```java
-public E pollFirst() {
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        return unlinkFirst();
-    } finally {
-        lock.unlock();
-    }
-}
-```
-调用unlinkFirst移除队列首元素：
-```java
-private E unlinkFirst() {
-    // 首节点
-    Node<E> f = first;
-
-    // 空队列，直接返回null
-    if (f == null)
-        return null;
-
-    // first.next
-    Node<E> n = f.next;
-
-    // 节点item
-    E item = f.item;
-
-    // 移除掉first ==> first = first.next
-    f.item = null;
-    f.next = f; // help GC
-    first = n;
-
-    // 移除后为空队列，仅有一个节点
-    if (n == null)
-        last = null;
-    else
-    // n的pre原来指向之前的first，现在n变为first了，pre指向null
-        n.prev = null;
-    --count;
-    notFull.signal();
-    return item;
-}
-```
-pollLast
-
-pollLast():获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
-```java
-public E pollLast() {
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        return unlinkLast();
-    } finally {
-        lock.unlock();
-    }
-}
-```
-调用unlinkLast移除尾结点，链表空返回null ：
-```java
-private E unlinkLast() {
-    // assert lock.isHeldByCurrentThread();
-    Node<E> l = last;
-    if (l == null)
-        return null;
-    Node<E> p = l.prev;
-    E item = l.item;
-    l.item = null;
-    l.prev = l; // help GC
-    last = p;
-    if (p == null)
-        first = null;
-    else
-        p.next = null;
-    --count;
-    notFull.signal();
-    return item;
-}
-```
-LinkedBlockingDeque大部分方法都是通过linkFirst、linkLast、unlinkFirst、unlinkLast这四个方法来实现的，因为是双向队列，所以他们都是针对first、last的操作，看懂这个整个LinkedBlockingDeque就不难了。
-
-掌握了双向队列的插入、删除操作，LinkedBlockingDeque就没有任何难度可言了，数据结构的重要性啊！！！！
+前面的BlockingQueue都是单向的FIFO队列，而LinkedBlockingDeque则是一个由链表组成的双向阻塞队列，双向队列就意味着可以从对头、对尾两端插入和移除元素，同样意味着LinkedBlockingDeque支持 **FIFO、FILO两种操作方式**。
+
+LinkedBlockingDeque是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为Integer.MAX_VALUE。
+
+### LinkedBlockingDeque
+LinkedBlockingDeque 继承`AbstractQueue`，实现接口`BlockingDeque`，而BlockingDeque又继承接口BlockingQueue，BlockingDeque是支持两个附加操作的 Queue，
+这两个操作是：
+  获取元素时等待双端队列变为非空；
+  存储元素时等待双端队列中的空间变得可用。
+这两类操作就为LinkedBlockingDeque 的双向操作Queue提供了可能。
+BlockingDeque接口提供了一系列的以First和Last结尾的方法，如addFirst、addLast、peekFirst、peekLast。
+
+```java
+public class LinkedBlockingDeque<E>
+    extends AbstractQueue<E>
+    implements BlockingDeque<E>, java.io.Serializable {
+
+    // 双向链表的表头
+    transient Node<E> first;
+    // 双向链表的表尾
+    transient Node<E> last;
+    // 大小，双向链表中当前节点个数
+    private transient int count;
+    // 容量，在创建LinkedBlockingDeque时指定的
+    private final int capacity;
+    final ReentrantLock lock = new ReentrantLock();
+    private final Condition notEmpty = lock.newCondition();
+    private final Condition notFull = lock.newCondition();
+
+}
+```
+通过上面的Lock可以看出，LinkedBlockingDeque底层实现机制与LinkedBlockingQueue一样，依然是通过互斥锁ReentrantLock 来实现，notEmpty 、notFull 两个Condition做协调生产者、消费者问题。
+
+与其他BlockingQueue一样，节点还是使用内部类Node：
+```java
+static final class Node<E> {
+    E item;
+
+    Node<E> prev;
+
+    Node<E> next;
+
+    Node(E x) {
+        item = x;
+    }
+}
+```
+双向嘛，节点肯定得要有前驱prev、后继next咯。
+
+基础方法
+LinkedBlockingDeque 的add、put、offer、take、peek、poll系列方法都是通过调用XXXFirst，XXXLast方法。所以这里就仅以putFirst、putLast、pollFirst、pollLast分析下。
+
+putFirst
+
+putFirst(E e) :将指定的元素插入此双端队列的开头，必要时将一直等待可用空间。
+```java
+public void putFirst(E e) throws InterruptedException {
+    // check null
+    if (e == null) throw new NullPointerException();
+    Node<E> node = new Node<E>(e);
+    // 获取锁
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        while (!linkFirst(node))
+            // 在notFull条件上等待，直到被唤醒或中断
+            notFull.await();
+    } finally {
+        // 释放锁
+        lock.unlock();
+    }
+}
+```
+先获取锁，然后调用linkFirst方法入列，最后释放锁。如果队列是满的则在notFull上面等待。linkFirst设置Node为对头：
+```java
+private boolean linkFirst(Node<E> node) {
+    // 超出容量
+    if (count >= capacity)
+        return false;
+
+    // 首节点
+    Node<E> f = first;
+    // 新节点的next指向原first
+    node.next = f;
+    // 设置node为新的first
+    first = node;
+
+    // 没有尾节点，设置node为尾节点
+    if (last == null)
+        last = node;
+    // 有尾节点，那就将之前first的pre指向新增node
+    else
+        f.prev = node;
+    ++count;
+    // 唤醒notEmpty
+    notEmpty.signal();
+    return true;
+}
+```
+linkFirst主要是设置node节点队列的列头节点，成功返回true，如果队列满了返回false。整个过程还是比较简单的。
+
+putLast
+
+putLast(E e) :将指定的元素插入此双端队列的末尾，必要时将一直等待可用空间。
+```java
+public void putLast(E e) throws InterruptedException {
+    if (e == null) throw new NullPointerException();
+    Node<E> node = new Node<E>(e);
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        while (!linkLast(node))
+            notFull.await();
+    } finally {
+        lock.unlock();
+    }
+}
+```
+调用linkLast将节点Node链接到队列尾部：
+```java
+private boolean linkLast(Node<E> node) {
+    if (count >= capacity)
+        return false;
+    // 尾节点
+    Node<E> l = last;
+
+    // 将Node的前驱指向原本的last
+    node.prev = l;
+
+    // 将node设置为last
+    last = node;
+    // 首节点为null，则设置node为first
+    if (first == null)
+        first = node;
+    else
+    //非null，说明之前的last有值，就将之前的last的next指向node
+        l.next = node;
+    ++count;
+    notEmpty.signal();
+    return true;
+}
+```
+pollFirst
+
+pollFirst()：获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
+```java
+public E pollFirst() {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        return unlinkFirst();
+    } finally {
+        lock.unlock();
+    }
+}
+```
+调用unlinkFirst移除队列首元素：
+```java
+private E unlinkFirst() {
+    // 首节点
+    Node<E> f = first;
+
+    // 空队列，直接返回null
+    if (f == null)
+        return null;
+
+    // first.next
+    Node<E> n = f.next;
+
+    // 节点item
+    E item = f.item;
+
+    // 移除掉first ==> first = first.next
+    f.item = null;
+    f.next = f; // help GC
+    first = n;
+
+    // 移除后为空队列，仅有一个节点
+    if (n == null)
+        last = null;
+    else
+    // n的pre原来指向之前的first，现在n变为first了，pre指向null
+        n.prev = null;
+    --count;
+    notFull.signal();
+    return item;
+}
+```
+pollLast
+
+pollLast():获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
+```java
+public E pollLast() {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        return unlinkLast();
+    } finally {
+        lock.unlock();
+    }
+}
+```
+调用unlinkLast移除尾结点，链表空返回null ：
+```java
+private E unlinkLast() {
+    // assert lock.isHeldByCurrentThread();
+    Node<E> l = last;
+    if (l == null)
+        return null;
+    Node<E> p = l.prev;
+    E item = l.item;
+    l.item = null;
+    l.prev = l; // help GC
+    last = p;
+    if (p == null)
+        first = null;
+    else
+        p.next = null;
+    --count;
+    notFull.signal();
+    return item;
+}
+```
+LinkedBlockingDeque大部分方法都是通过linkFirst、linkLast、unlinkFirst、unlinkLast这四个方法来实现的，因为是双向队列，所以他们都是针对first、last的操作，看懂这个整个LinkedBlockingDeque就不难了。
+
+掌握了双向队列的插入、删除操作，LinkedBlockingDeque就没有任何难度可言了，数据结构的重要性啊！！！！
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/29 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232BlockingQueue\346\200\273\347\273\223.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/29 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232BlockingQueue\346\200\273\347\273\223.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/29 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232BlockingQueue\346\200\273\347\273\223.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/29 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232BlockingQueue\346\200\273\347\273\223.md"
index cedad376..440cc58c 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/29 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232BlockingQueue\346\200\273\347\273\223.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/29 - J.U.C\344\271\213\351\230\273\345\241\236\351\230\237\345\210\227\357\274\232BlockingQueue\346\200\273\347\273\223.md"	
@@ -1,66 +1,66 @@
-
-整个类图：
-
-<div align="center"><img src="img/2251324-caff4e70c0181879.png"></div>
-
-### BlockingQueue
-
-BlockingQueue接口实现Queue接口，它支持两个附加操作：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。相对于同一操作他提供了四种机制：抛出异常、返回特殊值、阻塞等待、超时：
-
-<div align="center"><img src="img/2251324-9013dd0f86ed018e.png"></div>
-
-`BlockingQueue`常用于 **生产者和消费者场景**。
-
-JDK 8 中提供了七个阻塞队列可供使用（上图的`DelayedWorkQueue`是`ScheduledThreadPoolExecutor的内部类`）：
-
-`ArrayBlockingQueue` ：一个由`数组`结构组成的`有界阻塞`队列。
-`LinkedBlockingQueue` ：一个由`链表`结构组成的`无界阻塞`队列。
-`PriorityBlockingQueue` ：一个支持`优先级`排序的`无界阻塞`队列。
-`DelayQueue`：一个使用`优先级`队列实现的`无界阻塞`队列。
-`SynchronousQueue`：一个`不存储元素`的`阻塞`队列。
-`LinkedTransferQueue`：一个由`链表`结构组成的`无界阻塞`队列。
-`LinkedBlockingDeque`：一个由`链表`结构组成的`双向阻塞`队列。
-
-### 1. ArrayBlockingQueue
-基于数组的阻塞队列，ArrayBlockingQueue内部维护这一个定长数组，阻塞队列的大小在初始化时就已经确定了，其后无法更改。
-
-采用可重入锁ReentrantLock来保证线程安全性，但是生产者和消费者是共用同一个锁对象，这样势必会导致降低一定的吞吐量。当然ArrayBlockingQueue完全可以采用分离锁来实现生产者和消费者的并行操作，但是我认为这样做只会给代码带来额外的复杂性，对于性能而言应该不会有太大的提升，因为基于数组的ArrayBlockingQueue在数据的写入和读取操作已经非常轻巧了。
-
-ArrayBlockingQueue支持公平性和非公平性，默认采用非公平模式，可以通过构造函数设置为公平访问策略（true）。
-
-### 2. PriorityBlockingQueue
-PriorityBlockingQueue是支持优先级的无界队列。默认情况下采用自然顺序排序，当然也可以通过自定义Comparator来指定元素的排序顺序。
-
-PriorityBlockingQueue内部采用二叉堆的实现方式，整个处理过程并不是特别复杂。添加操作则是不断“上冒”，而删除操作则是不断“下掉”。
-
-### 3. DelayQueue
-DelayQueue是一个支持延时操作的无界阻塞队列。列头的元素是最先“到期”的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。也就是说只有在延迟期满时才能够从队列中去元素。
-
-它主要运用于如下场景：
-
-缓存系统的设计：缓存是有一定的时效性的，可以用DelayQueue保存缓存的有效期，然后利用一个线程查询DelayQueue，如果取到元素就证明该缓存已经失效了。
-定时任务的调度：DelayQueue保存当天将要执行的任务和执行时间，一旦取到元素（任务），就执行该任务。
-DelayQueue采用支持优先级的PriorityQueue来实现，但是队列中的元素必须要实现Delayed接口，Delayed接口用来标记那些应该在给定延迟时间之后执行的对象，该接口提供了getDelay()方法返回元素节点的剩余时间。同时，元素也必须要实现compareTo()方法，compareTo()方法需要提供与getDelay()方法一致的排序。
-
-### 4. SynchronousQueue
-SynchronousQueue是一个神奇的队列，他是一个不存储元素的阻塞队列，也就是说他的每一个put操作都需要等待一个take操作，否则就不能继续添加元素了，有点儿像Exchanger，类似于生产者和消费者进行交换。
-
-队列本身不存储任何元素，所以非常适用于传递性场景，两者直接进行对接。其吞吐量会高于ArrayBlockingQueue和LinkedBlockingQueue。
-
-SynchronousQueue支持公平和非公平的访问策略，在默认情况下采用非公平性，也可以通过构造函数来设置为公平性。
-
-SynchronousQueue的实现核心为Transferer接口，该接口有TransferQueue和TransferStack两个实现类，分别对应着公平策略和非公平策略。接口Transferer有一个tranfer()方法，该方法定义了转移数据，如果e != null，相当于将一个数据交给消费者，如果e == null，则相当于从一个生产者接收一个消费者交出的数据。
-
-### 5. LinkedTransferQueue
-LinkedTransferQueue是一个由链表组成的的无界阻塞队列，该队列是一个相当牛逼的队列：它是ConcurrentLinkedQueue、SynchronousQueue (公平模式下)、无界的LinkedBlockingQueues等的超集。
-
-与其他BlockingQueue相比，他多实现了一个接口TransferQueue，该接口是对BlockingQueue的一种补充，多了tryTranfer()和transfer()两类方法：
-
-tranfer()：若当前存在一个正在等待获取的消费者线程，即立刻移交之。 否则，会插入当前元素e到队列尾部，并且等待进入阻塞状态，到有消费者线程取走该元素
-
-tryTranfer()： 若当前存在一个正在等待获取的消费者线程（使用take()或者poll()函数），使用该方法会即刻转移/传输对象元素e；若不存在，则返回false，并且不进入队列。这是一个不阻塞的操作
-
-### 6. LinkedBlockingDeque
-LinkedBlockingDeque是一个有链表组成的双向阻塞队列，与前面的阻塞队列相比它支持从两端插入和移出元素。以first结尾的表示从对头操作，以last结尾的表示从对尾操作。
-
-在初始化LinkedBlockingDeque时可以初始化队列的容量，用来防止其再扩容时过渡膨胀。另外双向阻塞队列可以运用在“工作窃取”模式中。
+
+整个类图：
+
+<div align="center"><img src="img/2251324-caff4e70c0181879.png"></div>
+
+### BlockingQueue
+
+BlockingQueue接口实现Queue接口，它支持两个附加操作：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。相对于同一操作他提供了四种机制：抛出异常、返回特殊值、阻塞等待、超时：
+
+<div align="center"><img src="img/2251324-9013dd0f86ed018e.png"></div>
+
+`BlockingQueue`常用于 **生产者和消费者场景**。
+
+JDK 8 中提供了七个阻塞队列可供使用（上图的`DelayedWorkQueue`是`ScheduledThreadPoolExecutor的内部类`）：
+
+`ArrayBlockingQueue` ：一个由`数组`结构组成的`有界阻塞`队列。
+`LinkedBlockingQueue` ：一个由`链表`结构组成的`无界阻塞`队列。
+`PriorityBlockingQueue` ：一个支持`优先级`排序的`无界阻塞`队列。
+`DelayQueue`：一个使用`优先级`队列实现的`无界阻塞`队列。
+`SynchronousQueue`：一个`不存储元素`的`阻塞`队列。
+`LinkedTransferQueue`：一个由`链表`结构组成的`无界阻塞`队列。
+`LinkedBlockingDeque`：一个由`链表`结构组成的`双向阻塞`队列。
+
+### 1. ArrayBlockingQueue
+基于数组的阻塞队列，ArrayBlockingQueue内部维护这一个定长数组，阻塞队列的大小在初始化时就已经确定了，其后无法更改。
+
+采用可重入锁ReentrantLock来保证线程安全性，但是生产者和消费者是共用同一个锁对象，这样势必会导致降低一定的吞吐量。当然ArrayBlockingQueue完全可以采用分离锁来实现生产者和消费者的并行操作，但是我认为这样做只会给代码带来额外的复杂性，对于性能而言应该不会有太大的提升，因为基于数组的ArrayBlockingQueue在数据的写入和读取操作已经非常轻巧了。
+
+ArrayBlockingQueue支持公平性和非公平性，默认采用非公平模式，可以通过构造函数设置为公平访问策略（true）。
+
+### 2. PriorityBlockingQueue
+PriorityBlockingQueue是支持优先级的无界队列。默认情况下采用自然顺序排序，当然也可以通过自定义Comparator来指定元素的排序顺序。
+
+PriorityBlockingQueue内部采用二叉堆的实现方式，整个处理过程并不是特别复杂。添加操作则是不断“上冒”，而删除操作则是不断“下掉”。
+
+### 3. DelayQueue
+DelayQueue是一个支持延时操作的无界阻塞队列。列头的元素是最先“到期”的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。也就是说只有在延迟期满时才能够从队列中去元素。
+
+它主要运用于如下场景：
+
+缓存系统的设计：缓存是有一定的时效性的，可以用DelayQueue保存缓存的有效期，然后利用一个线程查询DelayQueue，如果取到元素就证明该缓存已经失效了。
+定时任务的调度：DelayQueue保存当天将要执行的任务和执行时间，一旦取到元素（任务），就执行该任务。
+DelayQueue采用支持优先级的PriorityQueue来实现，但是队列中的元素必须要实现Delayed接口，Delayed接口用来标记那些应该在给定延迟时间之后执行的对象，该接口提供了getDelay()方法返回元素节点的剩余时间。同时，元素也必须要实现compareTo()方法，compareTo()方法需要提供与getDelay()方法一致的排序。
+
+### 4. SynchronousQueue
+SynchronousQueue是一个神奇的队列，他是一个不存储元素的阻塞队列，也就是说他的每一个put操作都需要等待一个take操作，否则就不能继续添加元素了，有点儿像Exchanger，类似于生产者和消费者进行交换。
+
+队列本身不存储任何元素，所以非常适用于传递性场景，两者直接进行对接。其吞吐量会高于ArrayBlockingQueue和LinkedBlockingQueue。
+
+SynchronousQueue支持公平和非公平的访问策略，在默认情况下采用非公平性，也可以通过构造函数来设置为公平性。
+
+SynchronousQueue的实现核心为Transferer接口，该接口有TransferQueue和TransferStack两个实现类，分别对应着公平策略和非公平策略。接口Transferer有一个tranfer()方法，该方法定义了转移数据，如果e != null，相当于将一个数据交给消费者，如果e == null，则相当于从一个生产者接收一个消费者交出的数据。
+
+### 5. LinkedTransferQueue
+LinkedTransferQueue是一个由链表组成的的无界阻塞队列，该队列是一个相当牛逼的队列：它是ConcurrentLinkedQueue、SynchronousQueue (公平模式下)、无界的LinkedBlockingQueues等的超集。
+
+与其他BlockingQueue相比，他多实现了一个接口TransferQueue，该接口是对BlockingQueue的一种补充，多了tryTranfer()和transfer()两类方法：
+
+tranfer()：若当前存在一个正在等待获取的消费者线程，即立刻移交之。 否则，会插入当前元素e到队列尾部，并且等待进入阻塞状态，到有消费者线程取走该元素
+
+tryTranfer()： 若当前存在一个正在等待获取的消费者线程（使用take()或者poll()函数），使用该方法会即刻转移/传输对象元素e；若不存在，则返回false，并且不进入队列。这是一个不阻塞的操作
+
+### 6. LinkedBlockingDeque
+LinkedBlockingDeque是一个有链表组成的双向阻塞队列，与前面的阻塞队列相比它支持从两端插入和移出元素。以first结尾的表示从对头操作，以last结尾的表示从对尾操作。
+
+在初始化LinkedBlockingDeque时可以初始化队列的容量，用来防止其再扩容时过渡膨胀。另外双向阻塞队列可以运用在“工作窃取”模式中。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/30 - \346\267\261\345\205\245\345\210\206\346\236\220ThreadLocal.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/30 - \346\267\261\345\205\245\345\210\206\346\236\220ThreadLocal.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/30 - \346\267\261\345\205\245\345\210\206\346\236\220ThreadLocal.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/30 - \346\267\261\345\205\245\345\210\206\346\236\220ThreadLocal.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/31 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232\347\272\277\347\250\213\346\261\240\347\232\204\345\237\272\347\241\200\346\236\266\346\236\204.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/31 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232\347\272\277\347\250\213\346\261\240\347\232\204\345\237\272\347\241\200\346\236\266\346\236\204.md"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/31 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232\347\272\277\347\250\213\346\261\240\347\232\204\345\237\272\347\241\200\346\236\266\346\236\204.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/31 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232\347\272\277\347\250\213\346\261\240\347\232\204\345\237\272\347\241\200\346\236\266\346\236\204.md"
index 5933737e..243b0d0d 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/31 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232\347\272\277\347\250\213\346\261\240\347\232\204\345\237\272\347\241\200\346\236\266\346\236\204.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/31 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232\347\272\277\347\250\213\346\261\240\347\232\204\345\237\272\347\241\200\346\236\266\346\236\204.md"	
@@ -1,198 +1,198 @@
-t
-  经历了Java内存模型、JUC基础之AQS、CAS、Lock、并发工具类、并发容器、阻塞队列、atomic类后，我们开始JUC的最后一部分：线程池。在这个部分你将了解到下面几个部分：
-
-  1. 线程池的基础架构
-  2. 线程池的原理分析
-  3. 线程池核心类的源码分析
-  4. 线程池调优
-
-  Executor
-  我们先看线程池的基础架构图：
-  <img src="img/2251324-f27c0413b40951c3.png">
-
-### Executor
-
-  Executor，任务的执行者，线程池框架中几乎所有类都直接或者间接实现Executor接口，它是线程池框架的基础。Executor提供了一种将“任务提交”与“任务执行”分离开来的机制，它仅提供了一个Execute()方法用来执行已经提交的Runnable任务。
-  ```java
-  public interface Executor {
-      void execute(Runnable command);
-  }
-  ```
-### ExcutorService
-  继承Executor，它是“执行者服务”接口，它是为"执行者接口Executor"服务而存在的。准确的地说，ExecutorService提供了"将任务提交给执行者的接口(submit方法)"，"让执行者执行任务(invokeAll, invokeAny方法)"的接口等等。
-  ```java
-  public interface ExecutorService extends Executor {
-      /**
-       * 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
-       */
-      void shutdown();
-
-      /**
-       * 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表
-       */
-      List<Runnable> shutdownNow();
-
-      /**
-       * 如果此执行程序已关闭，则返回 true。
-       */
-      boolean isShutdown();
-
-      /**
-       * 如果关闭后所有任务都已完成，则返回 true
-       */
-      boolean isTerminated();
-
-      /**
-       * 请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行
-       */
-      boolean awaitTermination(long timeout, TimeUnit unit)
-          throws InterruptedException;
-
-      /**
-       * 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future
-       */
-      <T> Future<T> submit(Callable<T> task);
-
-      /**
-       * 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
-       */
-      <T> Future<T> submit(Runnable task, T result);
-
-      /**
-       * 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
-       */
-      Future<?> submit(Runnable task);
-
-      /**
-       * 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表
-       */
-      <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
-          throws InterruptedException;
-
-      /**
-       * 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表
-       */
-      <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
-                                    long timeout, TimeUnit unit)
-          throws InterruptedException;
-
-      /**
-       * 执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果
-       */
-      <T> T invokeAny(Collection<? extends Callable<T>> tasks)
-          throws InterruptedException, ExecutionException;
-
-      /**
-       * 执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果
-       */
-      <T> T invokeAny(Collection<? extends Callable<T>> tasks,
-                      long timeout, TimeUnit unit)
-          throws InterruptedException, ExecutionException, TimeoutException;
-  }
-  ```
-### AbstractExecutorService
-
-  抽象类，实现ExecutorService接口，为其提供默认实现。AbstractExecutorService除了实现ExecutorService接口外，还提供了newTaskFor()方法返回一个RunnableFuture，在运行的时候，它将调用底层可调用任务，作为 Future 任务，它将生成可调用的结果作为其结果，并为底层任务提供取消操作。
-
-### ScheduledExecutorService
-
-  继承ExcutorService，为一个“延迟”和“定期执行”的ExecutorService。他提供了一些如下几个方法安排任务在给定的延时执行或者周期性执行。
-  ```java
-  // 创建并执行在给定延迟后启用的 ScheduledFuture。
-  <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
-
-  // 创建并执行在给定延迟后启用的一次性操作。
-  ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
-
-  // 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；
-  //也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
-  ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
-
-  // 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
-  ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
-  ```
-
-### ThreadPoolExecutor
-
-  大名鼎鼎的“线程池”，后续做详细介绍。
-
-### ScheduledThreadPoolExecutor
-
-  ScheduledThreadPoolExecutor继承ThreadPoolExecutor并且实现ScheduledExecutorService接口，是两者的集大成者，相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。
-
-### Executors
-
-  静态工厂类，提供了Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 、Callable 等类的静态工厂方法，通过这些工厂方法我们可以得到相对应的对象。
-
-  1. 创建并返回设置有常用配置字符串的 ExecutorService 的方法。
-  2. 创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。
-  3. 创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
-  4. 创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
-  5. 创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。
-
-### Future
-  Future接口和实现Future接口的FutureTask代表了线程池的异步计算结果。
-
-  AbstractExecutorService提供了newTaskFor()方法返回一个RunnableFuture，除此之外当我们把一个Runnable或者Callable提交给（submit()）ThreadPoolExecutor或者ScheduledThreadPoolExecutor时，他们则会向我们返回一个FutureTask对象。如下：
-  ```java
-  protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
-      return new FutureTask<T>(runnable, value);
-  }
-
-      protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
-      return new FutureTask<T>(callable);
-  }
-
-  <T> Future<T> submit(Callable<T> task)
-  <T> Future<T> submit(Runnable task, T result)
-  Future<> submit(Runnable task)
-  ```
-  <img src="img/2251324-7fc4eec11964a492.png">
-  Future
-
-  作为异步计算的顶层接口，Future对具体的Runnable或者Callable任务提供了三种操作：执行任务的取消、查询任务是否完成、获取任务的执行结果。其接口定义如下：
-  ```java
-  public interface Future<V> {
-
-      /**
-       * 试图取消对此任务的执行
-       * 如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。
-       * 当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。
-       * 如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程
-       */
-      boolean cancel(boolean mayInterruptIfRunning);
-
-      /**
-       * 如果在任务正常完成前将其取消，则返回 true
-       */
-      boolean isCancelled();
-
-      /**
-       * 如果任务已完成，则返回 true
-       */
-      boolean isDone();
-
-      /**
-       *   如有必要，等待计算完成，然后获取其结果
-       */
-      V get() throws InterruptedException, ExecutionException;
-
-      /**
-       * 如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）
-       */
-      V get(long timeout, TimeUnit unit)
-          throws InterruptedException, ExecutionException, TimeoutException;
-  }
-  ```
-  RunnableFuture
-
-  继承Future、Runnable两个接口，为两者的合体，即所谓的Runnable的Future。提供了一个run()方法可以完成Future并允许访问其结果。
-  ```java
-  public interface RunnableFuture<V> extends Runnable, Future<V> {
-      //在未被取消的情况下，将此 Future 设置为计算的结果
-      void run();
-  }
-  ```
-  FutureTask
-
-  实现RunnableFuture接口，既可以作为Runnable被执行，也可以作为Future得到Callable的返回值。
+t
+  经历了Java内存模型、JUC基础之AQS、CAS、Lock、并发工具类、并发容器、阻塞队列、atomic类后，我们开始JUC的最后一部分：线程池。在这个部分你将了解到下面几个部分：
+
+  1. 线程池的基础架构
+  2. 线程池的原理分析
+  3. 线程池核心类的源码分析
+  4. 线程池调优
+
+  Executor
+  我们先看线程池的基础架构图：
+  <img src="img/2251324-f27c0413b40951c3.png">
+
+### Executor
+
+  Executor，任务的执行者，线程池框架中几乎所有类都直接或者间接实现Executor接口，它是线程池框架的基础。Executor提供了一种将“任务提交”与“任务执行”分离开来的机制，它仅提供了一个Execute()方法用来执行已经提交的Runnable任务。
+  ```java
+  public interface Executor {
+      void execute(Runnable command);
+  }
+  ```
+### ExcutorService
+  继承Executor，它是“执行者服务”接口，它是为"执行者接口Executor"服务而存在的。准确的地说，ExecutorService提供了"将任务提交给执行者的接口(submit方法)"，"让执行者执行任务(invokeAll, invokeAny方法)"的接口等等。
+  ```java
+  public interface ExecutorService extends Executor {
+      /**
+       * 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
+       */
+      void shutdown();
+
+      /**
+       * 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表
+       */
+      List<Runnable> shutdownNow();
+
+      /**
+       * 如果此执行程序已关闭，则返回 true。
+       */
+      boolean isShutdown();
+
+      /**
+       * 如果关闭后所有任务都已完成，则返回 true
+       */
+      boolean isTerminated();
+
+      /**
+       * 请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行
+       */
+      boolean awaitTermination(long timeout, TimeUnit unit)
+          throws InterruptedException;
+
+      /**
+       * 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future
+       */
+      <T> Future<T> submit(Callable<T> task);
+
+      /**
+       * 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
+       */
+      <T> Future<T> submit(Runnable task, T result);
+
+      /**
+       * 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
+       */
+      Future<?> submit(Runnable task);
+
+      /**
+       * 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表
+       */
+      <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
+          throws InterruptedException;
+
+      /**
+       * 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表
+       */
+      <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
+                                    long timeout, TimeUnit unit)
+          throws InterruptedException;
+
+      /**
+       * 执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果
+       */
+      <T> T invokeAny(Collection<? extends Callable<T>> tasks)
+          throws InterruptedException, ExecutionException;
+
+      /**
+       * 执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果
+       */
+      <T> T invokeAny(Collection<? extends Callable<T>> tasks,
+                      long timeout, TimeUnit unit)
+          throws InterruptedException, ExecutionException, TimeoutException;
+  }
+  ```
+### AbstractExecutorService
+
+  抽象类，实现ExecutorService接口，为其提供默认实现。AbstractExecutorService除了实现ExecutorService接口外，还提供了newTaskFor()方法返回一个RunnableFuture，在运行的时候，它将调用底层可调用任务，作为 Future 任务，它将生成可调用的结果作为其结果，并为底层任务提供取消操作。
+
+### ScheduledExecutorService
+
+  继承ExcutorService，为一个“延迟”和“定期执行”的ExecutorService。他提供了一些如下几个方法安排任务在给定的延时执行或者周期性执行。
+  ```java
+  // 创建并执行在给定延迟后启用的 ScheduledFuture。
+  <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
+
+  // 创建并执行在给定延迟后启用的一次性操作。
+  ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
+
+  // 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；
+  //也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
+  ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
+
+  // 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
+  ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
+  ```
+
+### ThreadPoolExecutor
+
+  大名鼎鼎的“线程池”，后续做详细介绍。
+
+### ScheduledThreadPoolExecutor
+
+  ScheduledThreadPoolExecutor继承ThreadPoolExecutor并且实现ScheduledExecutorService接口，是两者的集大成者，相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。
+
+### Executors
+
+  静态工厂类，提供了Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 、Callable 等类的静态工厂方法，通过这些工厂方法我们可以得到相对应的对象。
+
+  1. 创建并返回设置有常用配置字符串的 ExecutorService 的方法。
+  2. 创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。
+  3. 创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
+  4. 创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
+  5. 创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。
+
+### Future
+  Future接口和实现Future接口的FutureTask代表了线程池的异步计算结果。
+
+  AbstractExecutorService提供了newTaskFor()方法返回一个RunnableFuture，除此之外当我们把一个Runnable或者Callable提交给（submit()）ThreadPoolExecutor或者ScheduledThreadPoolExecutor时，他们则会向我们返回一个FutureTask对象。如下：
+  ```java
+  protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
+      return new FutureTask<T>(runnable, value);
+  }
+
+      protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
+      return new FutureTask<T>(callable);
+  }
+
+  <T> Future<T> submit(Callable<T> task)
+  <T> Future<T> submit(Runnable task, T result)
+  Future<> submit(Runnable task)
+  ```
+  <img src="img/2251324-7fc4eec11964a492.png">
+  Future
+
+  作为异步计算的顶层接口，Future对具体的Runnable或者Callable任务提供了三种操作：执行任务的取消、查询任务是否完成、获取任务的执行结果。其接口定义如下：
+  ```java
+  public interface Future<V> {
+
+      /**
+       * 试图取消对此任务的执行
+       * 如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。
+       * 当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。
+       * 如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程
+       */
+      boolean cancel(boolean mayInterruptIfRunning);
+
+      /**
+       * 如果在任务正常完成前将其取消，则返回 true
+       */
+      boolean isCancelled();
+
+      /**
+       * 如果任务已完成，则返回 true
+       */
+      boolean isDone();
+
+      /**
+       *   如有必要，等待计算完成，然后获取其结果
+       */
+      V get() throws InterruptedException, ExecutionException;
+
+      /**
+       * 如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）
+       */
+      V get(long timeout, TimeUnit unit)
+          throws InterruptedException, ExecutionException, TimeoutException;
+  }
+  ```
+  RunnableFuture
+
+  继承Future、Runnable两个接口，为两者的合体，即所谓的Runnable的Future。提供了一个run()方法可以完成Future并允许访问其结果。
+  ```java
+  public interface RunnableFuture<V> extends Runnable, Future<V> {
+      //在未被取消的情况下，将此 Future 设置为计算的结果
+      void run();
+  }
+  ```
+  FutureTask
+
+  实现RunnableFuture接口，既可以作为Runnable被执行，也可以作为Future得到Callable的返回值。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/32 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ThreadPoolExecutor.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/32 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ThreadPoolExecutor.md"
similarity index 96%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/32 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ThreadPoolExecutor.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/32 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ThreadPoolExecutor.md"
index c9c9eef2..6b5f2b72 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/32 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ThreadPoolExecutor.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/32 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ThreadPoolExecutor.md"	
@@ -1,723 +1,724 @@
-  作为Executor框架中最核心的类，ThreadPoolExecutor代表着鼎鼎大名的线程池，它给了我们足够的理由来弄清楚它。
-
-  下面我们就通过源码来一步一步弄清楚它。
-
-### 内部状态
-  线程有五种状态：`新建，就绪，运行，阻塞，死亡`，线程池同样有五种状态：`Running, SHUTDOWN, STOP, TIDYING, TERMINATED`。
-  ```java
-  private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
-  private static final int COUNT_BITS = Integer.SIZE - 3;
-  private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
-
-  // runState is stored in the high-order bits
-  private static final int RUNNING    = -1 << COUNT_BITS;
-  private static final int SHUTDOWN   =  0 << COUNT_BITS;
-  private static final int STOP       =  1 << COUNT_BITS;
-  private static final int TIDYING    =  2 << COUNT_BITS;
-  private static final int TERMINATED =  3 << COUNT_BITS;
-
-  // Packing and unpacking ctl
-  private static int runStateOf(int c)     { return c & ~CAPACITY; }
-  private static int workerCountOf(int c)  { return c & CAPACITY; }
-  private static int ctlOf(int rs, int wc) { return rs | wc; }
-  ```
-  变量ctl定义为`AtomicInteger` ，其功能非常强大，记录了“线程池中的任务数量”和“线程池的状态”两个信息。
-  共32位，其中高3位表示"线程池状态"，低29位表示"线程池中的任务数量"。
-
-  `RUNNING`            -- 对应的高3位值是111。
-  `SHUTDOWN`           -- 对应的高3位值是000。
-  `STOP`               -- 对应的高3位值是001。
-  `TIDYING`            -- 对应的高3位值是010。
-  `TERMINATED`         -- 对应的高3位值是011。
-
-  `RUNNING`：处于RUNNING状态的线程池能够接受新任务，以及对新添加的任务进行处理。
-
-  `SHUTDOWN`：指调用了 `shutdown()` 方法，处于SHUTDOWN状态的线程池不可以接受新任务，但是可以对已添加的任务进行处理。
-
-  `STOP`：指调用了 `shutdownNow()` 方法，处于STOP状态的线程池不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
-
-  `TIDYING`：当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态。，在调用 `shutdown()/shutdownNow()` 中都会尝试更新为这个状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
-
-  `TERMINATED`：线程池彻底终止的状态。当执行 `terminated()` 后会更新为这个状态。
-
-  各个状态的转换如下：  
-  <img src = "img/20171007215630217.png">
-
-### 创建线程池
-
-  我们可以通过`ThreadPoolExecutor构造函数`来创建一个线程池：
-  ```JAVA
-  public ThreadPoolExecutor(int corePoolSize,
-                            int maximumPoolSize,
-                            long keepAliveTime,
-                            TimeUnit unit,
-                            BlockingQueue<Runnable> workQueue,
-                            ThreadFactory threadFactory,
-                            RejectedExecutionHandler handler) {
-      if (corePoolSize < 0 ||
-          maximumPoolSize <= 0 ||
-          maximumPoolSize < corePoolSize ||
-          keepAliveTime < 0)
-          throw new IllegalArgumentException();
-      if (workQueue == null || threadFactory == null || handler == null)
-          throw new NullPointerException();
-      this.corePoolSize = corePoolSize;
-      this.maximumPoolSize = maximumPoolSize;
-      this.workQueue = workQueue;
-      this.keepAliveTime = unit.toNanos(keepAliveTime);
-      this.threadFactory = threadFactory;
-      this.handler = handler;
-  }
-  ```
-  共有七个参数，每个参数含义如下：
-
-  **corePoolSize**
-
-  线程池中核心线程的数量。当提交一个任务时，线程池会新建一个线程来执行任务，直到当前线程数等于corePoolSize。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
-
-  **maximumPoolSize**
-
-  线程池中允许的最大线程数。线程池的阻塞队列满了之后，如果还有任务提交，如果当前的线程数小于maximumPoolSize，则会新建线程来执行任务。注意，如果使用的是无界队列，该参数也就没有什么效果了。
-
-  **keepAliveTime**
-
-  线程空闲的时间。线程的创建和销毁是需要代价的。线程执行完任务后不会立即销毁，而是继续存活一段时间：keepAliveTime。默认情况下，该参数只有在线程数大于corePoolSize时才会生效。
-
-  **unit**
-
-  keepAliveTime的单位。TimeUnit
-
-  **workQueue**
-
-  用来保存等待执行的任务的阻塞队列，等待的任务必须实现Runnable接口。我们可以选择如下几种：
-
-  `ArrayBlockingQueue`：基于数组结构的有界阻塞队列，FIFO。
-  `LinkedBlockingQueue`：基于链表结构的有界阻塞队列，FIFO。
-  `SynchronousQueue`：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作，反之亦然。
-  `PriorityBlockingQueue`：具有优先界别的阻塞队列。
-
-  **threadFactory**
-
-  用于设置创建线程的工厂。该对象可以通过 `Executors.defaultThreadFactory()`，如下：
-  ```JAVA
-  public static ThreadFactory defaultThreadFactory() {
-      return new DefaultThreadFactory();
-  }
-  ```
-  返回的是`DefaultThreadFactory`对象，源码如下：
-  ```JAVA
-  static class DefaultThreadFactory implements ThreadFactory {
-      private static final AtomicInteger poolNumber = new AtomicInteger(1);
-      private final ThreadGroup group;
-      private final AtomicInteger threadNumber = new AtomicInteger(1);
-      private final String namePrefix;
-
-      DefaultThreadFactory() {
-          SecurityManager s = System.getSecurityManager();
-          group = (s != null) ? s.getThreadGroup() :
-                                Thread.currentThread().getThreadGroup();
-          namePrefix = "pool-" +
-                        poolNumber.getAndIncrement() +
-                       "-thread-";
-      }
-
-      public Thread newThread(Runnable r) {
-          Thread t = new Thread(group, r,
-                                namePrefix + threadNumber.getAndIncrement(),
-                                0);
-          if (t.isDaemon())
-              t.setDaemon(false);
-          if (t.getPriority() != Thread.NORM_PRIORITY)
-              t.setPriority(Thread.NORM_PRIORITY);
-          return t;
-      }
-  }
-  ```
-  ThreadFactory的作用就是提供创建线程的功能的线程工厂。他是通过newThread()方法提供创建线程的功能，newThread()方法创建的线程都是“非守护线程”而且“线程优先级都是Thread.NORM_PRIORITY”。
-
-  **handler**
-
-  `RejectedExecutionHandler`，线程池的拒绝策略。所谓拒绝策略，是指将任务添加到线程池中时，线程池拒绝该任务所采取的相应策略。当向线程池中提交任务时，如果此时线程池中的线程已经饱和了，而且阻塞队列也已经满了，则线程池会选择一种拒绝策略来处理该任务。
-
-  线程池提供了四种拒绝策略：
-
-  1. AbortPolicy：直接抛出异常，默认策略；
-  2. CallerRunsPolicy：用调用者所在的线程来执行任务；
-  3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
-  4. DiscardPolicy：直接丢弃任务；
-
-  当然我们也可以实现自己的拒绝策略，例如记录日志等等，实现RejectedExecutionHandler接口即可。
-
-### 线程池
-  Executor框架提供了 **三种线程池** ，他们都可以通过工具类Executors来创建。
-
-  1. **FixedThreadPool**
-  FixedThreadPool，可重用固定线程数的线程池，其定义如下：
-  ```JAVA
-  public static ExecutorService newFixedThreadPool(int nThreads) {
-      return new ThreadPoolExecutor(nThreads, nThreads,
-                                    0L, TimeUnit.MILLISECONDS,
-                                    new LinkedBlockingQueue<Runnable>());
-  }
-  ```
-  `corePoolSize` 和 `maximumPoolSize`都设置为创建`FixedThreadPool`时指定的参数`nThreads`，意味着当线程池满时且阻塞队列也已经满时，如果继续提交任务，则会直接走拒绝策略，该线程池不会再新建线程来执行任务，而是直接走拒绝策略。FixedThreadPool使用的是默认的拒绝策略，即AbortPolicy，则直接抛出异常。
-
-  keepAliveTime设置为0L，表示空闲的线程会立刻终止。
-
-  workQueue则是使用`LinkedBlockingQueue`，但是没有设置范围，那么则是最大值（Integer.MAX_VALUE），这基本就相当于一个无界队列了。
-  **使用该“无界队列”则会带来哪些影响呢？**
-  当线程池中的线程数量等于corePoolSize 时，如果继续提交任务，该任务会被添加到阻塞队列workQueue中，当阻塞队列也满了之后，则线程池会新建线程执行任务直到maximumPoolSize。由于FixedThreadPool使用的是“无界队列”LinkedBlockingQueue，那么maximumPoolSize参数无效，同时指定的拒绝策略AbortPolicy也将无效。而且该线程池也不会拒绝提交的任务，如果客户端提交任务的速度快于任务的执行，那么keepAliveTime也是一个无效参数。
-
-  其运行图如下（参考《Java并发编程的艺术》）：
-  <img src="img/20171007215932303.png">
-
-  2. **SingleThreadExecutor**
-
-  SingleThreadExecutor是使用单个worker线程的Executor，定义如下：
-  ```java
-  public static ExecutorService newSingleThreadExecutor() {
-      return new FinalizableDelegatedExecutorService
-          (new ThreadPoolExecutor(1, 1,
-                                  0L, TimeUnit.MILLISECONDS,
-                                  new LinkedBlockingQueue<Runnable>()));
-  }
-  ```
-  作为单一worker线程的线程池，SingleThreadExecutor把`corePool`和`maximumPoolSize`均被设置为1，和FixedThreadPool一样使用的是无界队列`LinkedBlockingQueue`,所以带来的影响和FixedThreadPool一样。
-  <img src="img/20171007220046613.png">
-
-  3. **CachedThreadPool**
-
-  CachedThreadPool是一个会`根据需要`创建新线程的线程池 ，他定义如下：
-  ```java
-  public static ExecutorService newCachedThreadPool() {
-      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
-                                    60L, TimeUnit.SECONDS,
-                                    new SynchronousQueue<Runnable>());
-  }
-  ```
-  CachedThreadPool的`corePool`为0，`maximumPoolSize`为Integer.MAX_VALUE，这就意味着所有的任务一提交`就会加入到阻塞队列中`。
-  keepAliveTime这是为60L，unit设置为TimeUnit.SECONDS，意味着空闲线程等待`新任务的最长时间为60秒`，空闲线程超过60秒后将会被终止。
-  阻塞队列采用的`SynchronousQueue`，SynchronousQueue是一个没有元素的阻塞队列，加上corePool = 0 ，maximumPoolSize = Integer.MAX_VALUE，
-  这样就会存在一个 **问题**
-  如果主线程提交任务的速度远远大于CachedThreadPool的处理速度，则CachedThreadPool会不断地创建新线程来执行任务，这样有可能会导致系统耗尽CPU和内存资源，所以在使用该线程池是，一定要注意控制并发的任务数，否则创建大量的线程可能导致严重的性能问题。
-  <img src="img/20171007220114901.png">
-
-### 任务提交
-
-  线程池根据业务不同的需求提供了两种方式提交任务：`Executor.execute()`、`ExecutorService.submit()`。
-  其中ExecutorService.submit()可以获取该任务执行的`Future`。
-  我们以Executor.execute()为例，来看看线程池的任务提交经历了那些过程。
-
-  定义：
-  ```java
-  public interface Executor {
-      void execute(Runnable command);
-  }
-  ```
-  ThreadPoolExecutor提供实现：
-  ```java
-  public void execute(Runnable command) {
-      if (command == null)
-          throw new NullPointerException();
-      int c = ctl.get();
-      if (workerCountOf(c) < corePoolSize) {
-          if (addWorker(command, true))
-              return;
-          c = ctl.get();
-      }
-      if (isRunning(c) && workQueue.offer(command)) {
-          int recheck = ctl.get();
-          if (! isRunning(recheck) && remove(command))
-              reject(command);
-          else if (workerCountOf(recheck) == 0)
-              addWorker(null, false);
-      }
-      else if (!addWorker(command, false))
-          reject(command);
-  }
-  ```
-  执行流程如下：
-
-  如果线程池当前线程数小于corePoolSize，则调用`addWorker()`创建新线程执行任务，成功返回true，失败执行步骤2。
-  如果线程池处于RUNNING状态，则尝试加入阻塞队列，如果加入阻塞队列成功，则尝试进行Double Check，如果加入失败，则执行步骤3。
-  如果线程池不是RUNNING状态或者加入阻塞队列失败，则尝试创建新线程直到maxPoolSize，如果失败，则调用`reject()`方法运行相应的拒绝策略。
-  在步骤2中如果加入阻塞队列成功了，则会进行一个Double Check的过程。Double Check过程的主要目的是判断加入到阻塞队里中的线程是否可以被执行。如果线程池不是RUNNING状态，则调用`remove()`方法从阻塞队列中删除该任务，然后调用reject()方法处理任务。否则需要确保还有线程执行。
-
-  **addWorker**
-
-  当线程中的当前线程数小于corePoolSize，则调用addWorker()创建新线程执行任务，当前线程数则是根据ctl变量来获取的，调用workerCountOf(ctl)获取低29位即可：
-  ```java
-  private static int workerCountOf(int c)  { return c & CAPACITY; }
-  ```
-  addWorker(Runnable firstTask, boolean core)方法用于创建线程执行任务，源码如下：
-  ```java
-  private boolean addWorker(Runnable firstTask, boolean core) {
-    retry:
-    for (;;) {
-        int c = ctl.get();
-
-        // 获取当前线程状态
-        int rs = runStateOf(c);
-
-
-        if (rs >= SHUTDOWN &&
-                ! (rs == SHUTDOWN &&
-                        firstTask == null &&
-                        ! workQueue.isEmpty()))
-            return false;
-
-        // 内层循环，worker + 1
-        for (;;) {
-            // 线程数量
-            int wc = workerCountOf(c);
-            // 如果当前线程数大于线程最大上限CAPACITY  return false
-            // 若core == true，则与corePoolSize 比较，否则与maximumPoolSize ，大于 return false
-            if (wc >= CAPACITY ||
-                    wc >= (core ? corePoolSize : maximumPoolSize))
-                return false;
-            // worker + 1,成功跳出retry循环
-            if (compareAndIncrementWorkerCount(c))
-                break retry;
-
-            // CAS add worker 失败，再次读取ctl
-            c = ctl.get();
-
-            // 如果状态不等于之前获取的state，跳出内层循环，继续去外层循环判断
-            if (runStateOf(c) != rs)
-                continue retry;
-        }
-    }
-
-    boolean workerStarted = false;
-    boolean workerAdded = false;
-    Worker w = null;
-    try {
-
-        // 新建线程：Worker
-        w = new Worker(firstTask);
-        // 当前线程
-        final Thread t = w.thread;
-        if (t != null) {
-            // 获取主锁：mainLock
-            final ReentrantLock mainLock = this.mainLock;
-            mainLock.lock();
-            try {
-
-                // 线程状态
-                int rs = runStateOf(ctl.get());
-
-                // rs < SHUTDOWN ==> 线程处于RUNNING状态
-                // 或者线程处于SHUTDOWN状态，且firstTask == null（可能是workQueue中仍有未执行完成的任务，创建没有初始任务的worker线程执行）
-                if (rs < SHUTDOWN ||
-                        (rs == SHUTDOWN && firstTask == null)) {
-
-                    // 当前线程已经启动，抛出异常
-                    if (t.isAlive()) // precheck that t is startable
-                        throw new IllegalThreadStateException();
-
-                    // workers是一个HashSet<Worker>
-                    workers.add(w);
-
-                    // 设置最大的池大小largestPoolSize，workerAdded设置为true
-                    int s = workers.size();
-                    if (s > largestPoolSize)
-                        largestPoolSize = s;
-                    workerAdded = true;
-                }
-            } finally {
-                // 释放锁
-                mainLock.unlock();
-            }
-            // 启动线程
-            if (workerAdded) {
-                t.start();
-                workerStarted = true;
-            }
-        }
-    } finally {
-
-        // 线程启动失败
-        if (! workerStarted)
-            addWorkerFailed(w);
-    }
-    return workerStarted;
-  }
-  ```
-  判断当前线程是否可以添加任务，如果可以则进行下一步，否则return false；
-  rs >= SHUTDOWN ，表示当前线程处于SHUTDOWN ，STOP、TIDYING、TERMINATED状态
-  rs == SHUTDOWN , firstTask != null时不允许添加线程，因为线程处于SHUTDOWN 状态，不允许添加任务
-  rs == SHUTDOWN , firstTask == null，但workQueue.isEmpty() == true，不允许添加线程，因为firstTask == null是为了添加一个没有任务的线程然后再从workQueue中获取任务的，如果workQueue == null，则说明添加的任务没有任何意义。
-  内嵌循环，通过CAS worker + 1
-  获取主锁mailLock，如果线程池处于RUNNING状态获取处于SHUTDOWN状态且 firstTask == null，则将任务添加到workers Queue中，然后释放主锁mainLock，然后启动线程，然后return true，如果中途失败导致workerStarted= false，则调用addWorkerFailed()方法进行处理。
-  在这里需要好好理论addWorker中的参数，在execute()方法中，有三处调用了该方法：
-  第一次：workerCountOf(c) < corePoolSize ==> addWorker(command, true)，这个很好理解，当然线程池的线程数量小于 corePoolSize ，则新建线程执行任务即可，在执行过程core == true，内部与corePoolSize比较即可。
-  第二次：加入阻塞队列进行Double Check时，else if (workerCountOf(recheck) == 0) ==>addWorker(null, false)。如果线程池中的线程==0，按照道理应该该任务应该新建线程执行任务，但是由于已经该任务已经添加到了阻塞队列，那么就在线程池中新建一个空线程，然后从阻塞队列中取线程即可。
-  第三次：线程池不是RUNNING状态或者加入阻塞队列失败：else if (!addWorker(command, false))，这里core == fase，则意味着是与maximumPoolSize比较。
-
-  在新建线程执行任务时，将讲Runnable包装成一个Worker，Woker为ThreadPoolExecutor的内部类
-
-  **Woker内部类**
-
-  Woker的源码如下：
-  ```java
-  private final class Worker extends AbstractQueuedSynchronizer
-            implements Runnable {
-      private static final long serialVersionUID = 6138294804551838833L;
-
-      // task 的thread
-      final Thread thread;
-
-      // 运行的任务task
-      Runnable firstTask;
-
-      volatile long completedTasks;
-
-      Worker(Runnable firstTask) {
-
-          //设置AQS的同步状态private volatile int state，是一个计数器，大于0代表锁已经被获取
-          setState(-1);
-          this.firstTask = firstTask;
-
-          // 利用ThreadFactory和 Worker这个Runnable创建的线程对象
-          this.thread = getThreadFactory().newThread(this);
-      }
-
-      // 任务执行
-      public void run() {
-          runWorker(this);
-      }
-
-  }
-  ```
-  从Worker的源码中我们可以看到Woker继承AQS，实现Runnable接口，所以可以认为Worker既是一个可以执行的任务，也可以达到获取锁释放锁的效果。这里继承AQS主要是为了方便线程的中断处理。这里注意两个地方：构造函数、run()。构造函数主要是做三件事：1.设置同步状态state为-1，同步状态大于0表示就已经获取了锁，2.设置将当前任务task设置为firstTask，3.利用Worker本身对象this和ThreadFactory创建线程对象。
-
-  当线程thread启动（调用start()方法）时，其实就是执行Worker的run()方法，内部调用runWorker()。
-
-  **runWorker**
-  ```java
-  final void runWorker(Worker w) {
-      // 当前线程
-      Thread wt = Thread.currentThread();
-
-      // 要执行的任务
-      Runnable task = w.firstTask;
-
-      w.firstTask = null;
-
-      // 释放锁，运行中断
-      w.unlock(); // allow interrupts
-      boolean completedAbruptly = true;
-      try {
-          while (task != null || (task = getTask()) != null) {
-              // worker 获取锁
-              w.lock();
-
-              // 确保只有当线程是stoping时，才会被设置为中断，否则清楚中断标示
-              // 如果线程池状态 >= STOP ,且当前线程没有设置中断状态，则wt.interrupt()
-              // 如果线程池状态 < STOP，但是线程已经中断了，再次判断线程池是否 >= STOP，如果是 wt.interrupt()
-              if ((runStateAtLeast(ctl.get(), STOP) ||
-                      (Thread.interrupted() &&
-                              runStateAtLeast(ctl.get(), STOP))) &&
-                      !wt.isInterrupted())
-                  wt.interrupt();
-              try {
-                  // 自定义方法
-                  beforeExecute(wt, task);
-                  Throwable thrown = null;
-                  try {
-                      // 执行任务
-                      task.run();
-                  } catch (RuntimeException x) {
-                      thrown = x; throw x;
-                  } catch (Error x) {
-                      thrown = x; throw x;
-                  } catch (Throwable x) {
-                      thrown = x; throw new Error(x);
-                  } finally {
-                      afterExecute(task, thrown);
-                  }
-              } finally {
-                  task = null;
-                  // 完成任务数 + 1
-                  w.completedTasks++;
-                  // 释放锁
-                  w.unlock();
-              }
-          }
-          completedAbruptly = false;
-      } finally {
-          processWorkerExit(w, completedAbruptly);
-      }
-  }
-  ```
-  运行流程
-
-  根据worker获取要执行的任务task，然后调用unlock()方法释放锁，这里释放锁的主要目的在于中断，因为在new Worker时，设置的state为-1，调用unlock()方法可以将state设置为0，这里主要原因就在于interruptWorkers()方法只有在state >= 0时才会执行；
-  通过getTask()获取执行的任务，调用task.run()执行，当然在执行之前会调用worker.lock()上锁，执行之后调用worker.unlock()放锁；
-  在任务执行前后，可以根据业务场景自定义beforeExecute() 和 afterExecute()方法，则两个方法在ThreadPoolExecutor中是空实现；
-  如果线程执行完成，则会调用getTask()方法从阻塞队列中获取新任务，如果阻塞队列为空，则根据是否超时来判断是否需要阻塞；
-  task == null或者抛出异常（beforeExecute()、task.run()、afterExecute()均有可能）导致worker线程终止，则调用processWorkerExit()方法处理worker退出流程。
-
-  **getTask()**
-
-  ```java
-  private Runnable getTask() {
-      boolean timedOut = false; // Did the last poll() time out?
-
-      for (;;) {
-
-          // 线程池状态
-          int c = ctl.get();
-          int rs = runStateOf(c);
-
-          // 线程池中状态 >= STOP 或者 线程池状态 == SHUTDOWN且阻塞队列为空，则worker - 1，return null
-          if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
-              decrementWorkerCount();
-              return null;
-          }
-
-          int wc = workerCountOf(c);
-
-          // 判断是否需要超时控制
-          boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
-
-          if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
-              if (compareAndDecrementWorkerCount(c))
-                  return null;
-              continue;
-          }
-
-          try {
-
-              // 从阻塞队列中获取task
-              // 如果需要超时控制，则调用poll()，否则调用take()
-              Runnable r = timed ?
-                      workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
-                      workQueue.take();
-              if (r != null)
-                  return r;
-              timedOut = true;
-          } catch (InterruptedException retry) {
-              timedOut = false;
-          }
-      }
-  }
-  ```
-
-  timed == true，调用poll()方法，如果在keepAliveTime时间内还没有获取task的话，则返回null，继续循环。timed == false，**则调用take()方法，该方法为一个阻塞方法，没有任务时会一直阻塞挂起，直到有任务加入时对该线程唤醒，返回任务。**
-
-  在runWorker()方法中，无论最终结果如何，都会执行processWorkerExit()方法对worker进行退出处理。
-
-  **processWorkerExit()**
-  ```java
-  private void processWorkerExit(Worker w, boolean completedAbruptly) {
-      // true：用户线程运行异常,需要扣减
-      // false：getTask方法中扣减线程数量
-      if (completedAbruptly)
-          decrementWorkerCount();
-
-      // 获取主锁
-      final ReentrantLock mainLock = this.mainLock;
-      mainLock.lock();
-      try {
-          completedTaskCount += w.completedTasks;
-          // 从HashSet中移出worker
-          workers.remove(w);
-      } finally {
-          mainLock.unlock();
-      }
-
-      // 有worker线程移除，可能是最后一个线程退出需要尝试终止线程池
-      tryTerminate();
-
-      int c = ctl.get();
-      // 如果线程为running或shutdown状态，即tryTerminate()没有成功终止线程池，则判断是否有必要一个worker
-      if (runStateLessThan(c, STOP)) {
-          // 正常退出，计算min：需要维护的最小线程数量
-          if (!completedAbruptly) {
-              // allowCoreThreadTimeOut 默认false：是否需要维持核心线程的数量
-              int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
-              // 如果min ==0 或者workerQueue为空，min = 1
-              if (min == 0 && ! workQueue.isEmpty())
-                  min = 1;
-
-              // 如果线程数量大于最少数量min，直接返回，不需要新增线程
-              if (workerCountOf(c) >= min)
-                  return; // replacement not needed
-          }
-          // 添加一个没有firstTask的worker
-          addWorker(null, false);
-      }
-  }
-  ```
-  首先completedAbruptly的值来判断是否需要对线程数-1处理，如果completedAbruptly == true，说明在任务运行过程中出现了异常，那么需要进行减1处理，否则不需要，因为减1处理在getTask()方法中处理了。然后从HashSet中移出该worker，过程需要获取mainlock。然后调用tryTerminate()方法处理，该方法是对最后一个线程退出做终止线程池动作。如果线程池没有终止，那么线程池需要保持一定数量的线程，则通过addWorker(null,false)新增一个空的线程。
-
-  **addWorkerFailed()**
-
-  在addWorker()方法中，如果线程t==null，或者在add过程出现异常，会导致workerStarted == false，那么在最后会调用addWorkerFailed()方法：
-  ```java
-  private void addWorkerFailed(Worker w) {
-      final ReentrantLock mainLock = this.mainLock;
-      mainLock.lock();
-      try {
-          // 从HashSet中移除该worker
-          if (w != null)
-              workers.remove(w);
-
-          // 线程数 - 1
-          decrementWorkerCount();
-          // 尝试终止线程
-          tryTerminate();
-      } finally {
-          mainLock.unlock();
-      }
-  }
-  ```
-  整个逻辑显得比较简单。
-
-  **tryTerminate()**
-
-  当线程池涉及到要移除worker时候都会调用tryTerminate()，该方法主要用于判断线程池中的线程是否已经全部移除了，如果是的话则关闭线程池。
-  ```java
-  final void tryTerminate() {
-      for (;;) {
-          int c = ctl.get();
-          // 线程池处于Running状态
-          // 线程池已经终止了
-          // 线程池处于ShutDown状态，但是阻塞队列不为空
-          if (isRunning(c) ||
-                  runStateAtLeast(c, TIDYING) ||
-                  (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
-              return;
-
-          // 执行到这里，就意味着线程池要么处于STOP状态，要么处于SHUTDOWN且阻塞队列为空
-          // 这时如果线程池中还存在线程，则会尝试中断线程
-          if (workerCountOf(c) != 0) {
-              // /线程池还有线程，但是队列没有任务了，需要中断唤醒等待任务的线程
-              // （runwoker的时候首先就通过w.unlock设置线程可中断，getTask最后面的catch处理中断）
-              interruptIdleWorkers(ONLY_ONE);
-              return;
-          }
-
-          final ReentrantLock mainLock = this.mainLock;
-          mainLock.lock();
-          try {
-              // 尝试终止线程池
-              if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
-                  try {
-                      terminated();
-                  } finally {
-                      // 线程池状态转为TERMINATED
-                      ctl.set(ctlOf(TERMINATED, 0));
-                      termination.signalAll();
-                  }
-                  return;
-              }
-          } finally {
-              mainLock.unlock();
-          }
-      }
-  }
-  ```
-  在关闭线程池的过程中，如果线程池处于STOP状态或者处于SHUDOWN状态且阻塞队列为null，则线程池会调用interruptIdleWorkers()方法中断所有线程，注意ONLY_ONE== true，表示仅中断一个线程。
-
- **interruptIdleWorkers**
- ```java
-  private void interruptIdleWorkers(boolean onlyOne) {
-      final ReentrantLock mainLock = this.mainLock;
-      mainLock.lock();
-      try {
-          for (Worker w : workers) {
-              Thread t = w.thread;
-              if (!t.isInterrupted() && w.tryLock()) {
-                  try {
-                      t.interrupt();
-                  } catch (SecurityException ignore) {
-                  } finally {
-                      w.unlock();
-                  }
-              }
-              if (onlyOne)
-                  break;
-          }
-      } finally {
-          mainLock.unlock();
-      }
-  }
-  ```
-  onlyOne==true仅终止一个线程，否则终止所有线程。
-
-###  线程终止
-  线程池ThreadPoolExecutor提供了shutdown()和shutDownNow()用于关闭线程池。
-
-  shutdown()：按过去执行已提交任务的顺序发起一个有序的关闭，但是不接受新任务。
-
-  shutdownNow() :尝试停止所有的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表。
-
-  **shutdown**
-  ```java
-  public void shutdown() {
-      final ReentrantLock mainLock = this.mainLock;
-      mainLock.lock();
-      try {
-          checkShutdownAccess();
-          // 推进线程状态
-          advanceRunState(SHUTDOWN);
-          // 中断空闲的线程
-          interruptIdleWorkers();
-          // 交给子类实现
-          onShutdown();
-      } finally {
-          mainLock.unlock();
-      }
-      tryTerminate();
-  }
-  ```
-  **shutdownNow**
-  ```java
-  public List<Runnable> shutdownNow() {
-      List<Runnable> tasks;
-      final ReentrantLock mainLock = this.mainLock;
-      mainLock.lock();
-      try {
-          checkShutdownAccess();
-          advanceRunState(STOP);
-          // 中断所有线程
-          interruptWorkers();
-          // 返回等待执行的任务列表
-          tasks = drainQueue();
-      } finally {
-          mainLock.unlock();
-      }
-      tryTerminate();
-      return tasks;
-  }
-  ```
-  与shutdown不同，shutdownNow会调用interruptWorkers()方法中断所有线程。
-  ```java
-  private void interruptWorkers() {
-      final ReentrantLock mainLock = this.mainLock;
-      mainLock.lock();
-      try {
-          for (Worker w : workers)
-              w.interruptIfStarted();
-      } finally {
-          mainLock.unlock();
-      }
-  }
-  ```
-  同时会调用drainQueue()方法返回等待执行到任务列表。
-  ```java
-  private List<Runnable> drainQueue() {
-      BlockingQueue<Runnable> q = workQueue;
-      ArrayList<Runnable> taskList = new ArrayList<Runnable>();
-      q.drainTo(taskList);
-      if (!q.isEmpty()) {
-          for (Runnable r : q.toArray(new Runnable[0])) {
-              if (q.remove(r))
-                  taskList.add(r);
-          }
-      }
-      return taskList;
-  }
-  ```
+  作为Executor框架中最核心的类，ThreadPoolExecutor代表着鼎鼎大名的线程池，它给了我们足够的理由来弄清楚它。
+
+  下面我们就通过源码来一步一步弄清楚它。
+
+### 内部状态
+  线程有五种状态：`新建，就绪，运行，阻塞，死亡`，线程池同样有五种状态：`Running, SHUTDOWN, STOP, TIDYING, TERMINATED`。
+  ```java
+  private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
+  private static final int COUNT_BITS = Integer.SIZE - 3;
+  private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
+
+  // runState is stored in the high-order bits
+  private static final int RUNNING    = -1 << COUNT_BITS;
+  private static final int SHUTDOWN   =  0 << COUNT_BITS;
+  private static final int STOP       =  1 << COUNT_BITS;
+  private static final int TIDYING    =  2 << COUNT_BITS;
+  private static final int TERMINATED =  3 << COUNT_BITS;
+
+  // Packing and unpacking ctl
+  private static int runStateOf(int c)     { return c & ~CAPACITY; }
+  private static int workerCountOf(int c)  { return c & CAPACITY; }
+  private static int ctlOf(int rs, int wc) { return rs | wc; }
+  ```
+  变量ctl定义为`AtomicInteger` ，其功能非常强大，记录了“线程池中的任务数量”和“线程池的状态”两个信息。
+  共32位，其中高3位表示"线程池状态"，低29位表示"线程池中的任务数量"。
+
+  `RUNNING`            -- 对应的高3位值是111。
+  `SHUTDOWN`           -- 对应的高3位值是000。
+  `STOP`               -- 对应的高3位值是001。
+  `TIDYING`            -- 对应的高3位值是010。
+  `TERMINATED`         -- 对应的高3位值是011。
+
+  `RUNNING`：处于RUNNING状态的线程池能够接受新任务，以及对新添加的任务进行处理。
+
+  `SHUTDOWN`：指调用了 `shutdown()` 方法，处于SHUTDOWN状态的线程池不可以接受新任务，但是可以对已添加的任务进行处理。
+
+  `STOP`：指调用了 `shutdownNow()` 方法，处于STOP状态的线程池不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
+
+  `TIDYING`：当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态。，在调用 `shutdown()/shutdownNow()` 中都会尝试更新为这个状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
+
+  `TERMINATED`：线程池彻底终止的状态。当执行 `terminated()` 后会更新为这个状态。
+
+  各个状态的转换如下：  
+  <img src = "img/20171007215630217.png">
+
+### 创建线程池
+
+  我们可以通过`ThreadPoolExecutor构造函数`来创建一个线程池：
+  ```JAVA
+  public ThreadPoolExecutor(int corePoolSize,
+                            int maximumPoolSize,
+                            long keepAliveTime,
+                            TimeUnit unit,
+                            BlockingQueue<Runnable> workQueue,
+                            ThreadFactory threadFactory,
+                            RejectedExecutionHandler handler) {
+      if (corePoolSize < 0 ||
+          maximumPoolSize <= 0 ||
+          maximumPoolSize < corePoolSize ||
+          keepAliveTime < 0)
+          throw new IllegalArgumentException();
+      if (workQueue == null || threadFactory == null || handler == null)
+          throw new NullPointerException();
+      this.corePoolSize = corePoolSize;
+      this.maximumPoolSize = maximumPoolSize;
+      this.workQueue = workQueue;
+      this.keepAliveTime = unit.toNanos(keepAliveTime);
+      this.threadFactory = threadFactory;
+      this.handler = handler;
+  }
+  ```
+  共有七个参数，每个参数含义如下：
+
+  **corePoolSize**
+
+  线程池中核心线程的数量。当提交一个任务时，线程池会新建一个线程来执行任务，直到当前线程数等于corePoolSize。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
+
+  **maximumPoolSize**
+
+  线程池中允许的最大线程数。线程池的阻塞队列满了之后，如果还有任务提交，如果当前的线程数小于maximumPoolSize，则会新建线程来执行任务。注意，如果使用的是无界队列，该参数也就没有什么效果了。
+
+  **keepAliveTime**
+
+  线程空闲的时间。线程的创建和销毁是需要代价的。线程执行完任务后不会立即销毁，而是继续存活一段时间：keepAliveTime。默认情况下，该参数只有在线程数大于corePoolSize时才会生效。
+
+  **unit**
+
+  keepAliveTime的单位。TimeUnit
+
+  **workQueue**
+
+  用来保存等待执行的任务的阻塞队列，等待的任务必须实现Runnable接口。我们可以选择如下几种：
+
+  `ArrayBlockingQueue`：基于数组结构的有界阻塞队列，FIFO。
+  `LinkedBlockingQueue`：基于链表结构的有界阻塞队列，FIFO。
+  `SynchronousQueue`：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作，反之亦然。
+  `PriorityBlockingQueue`：具有优先界别的阻塞队列。
+
+  **threadFactory**
+
+  用于设置创建线程的工厂。该对象可以通过 `Executors.defaultThreadFactory()`，如下：
+  ```JAVA
+  public static ThreadFactory defaultThreadFactory() {
+      return new DefaultThreadFactory();
+  }
+  ```
+  返回的是`DefaultThreadFactory`对象，源码如下：
+  ```JAVA
+  static class DefaultThreadFactory implements ThreadFactory {
+      private static final AtomicInteger poolNumber = new AtomicInteger(1);
+      private final ThreadGroup group;
+      private final AtomicInteger threadNumber = new AtomicInteger(1);
+      private final String namePrefix;
+
+      DefaultThreadFactory() {
+          SecurityManager s = System.getSecurityManager();
+          group = (s != null) ? s.getThreadGroup() :
+                                Thread.currentThread().getThreadGroup();
+          namePrefix = "pool-" +
+                        poolNumber.getAndIncrement() +
+                       "-thread-";
+      }
+
+      public Thread newThread(Runnable r) {
+          Thread t = new Thread(group, r,
+                                namePrefix + threadNumber.getAndIncrement(),
+                                0);
+          if (t.isDaemon())
+              t.setDaemon(false);
+          if (t.getPriority() != Thread.NORM_PRIORITY)
+              t.setPriority(Thread.NORM_PRIORITY);
+          return t;
+      }
+  }
+  ```
+  ThreadFactory的作用就是提供创建线程的功能的线程工厂。他是通过newThread()方法提供创建线程的功能，newThread()方法创建的线程都是“非守护线程”而且“线程优先级都是Thread.NORM_PRIORITY”。
+
+  **handler**
+
+  `RejectedExecutionHandler`，线程池的拒绝策略。所谓拒绝策略，是指将任务添加到线程池中时，线程池拒绝该任务所采取的相应策略。当向线程池中提交任务时，如果此时线程池中的线程已经饱和了，而且阻塞队列也已经满了，则线程池会选择一种拒绝策略来处理该任务。
+
+  线程池提供了四种拒绝策略：
+
+  1. AbortPolicy：直接抛出异常，默认策略；
+  2. CallerRunsPolicy：用调用者所在的线程来执行任务；
+  3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
+  4. DiscardPolicy：直接丢弃任务；
+
+  当然我们也可以实现自己的拒绝策略，例如记录日志等等，实现RejectedExecutionHandler接口即可。
+
+### 线程池
+  Executor框架提供了 **三种线程池** ，他们都可以通过工具类Executors来创建。
+
+  1. **FixedThreadPool**
+  FixedThreadPool，可重用固定线程数的线程池，其定义如下：
+  ```JAVA
+  public static ExecutorService newFixedThreadPool(int nThreads) {
+      return new ThreadPoolExecutor(nThreads, nThreads,
+                                    0L, TimeUnit.MILLISECONDS,
+                                    new LinkedBlockingQueue<Runnable>());
+  }
+  ```
+  `corePoolSize` 和 `maximumPoolSize`都设置为创建`FixedThreadPool`时指定的参数`nThreads`，意味着当线程池满时且阻塞队列也已经满时，如果继续提交任务，则会直接走拒绝策略，该线程池不会再新建线程来执行任务，而是直接走拒绝策略。FixedThreadPool使用的是默认的拒绝策略，即AbortPolicy，则直接抛出异常。
+
+  keepAliveTime设置为0L，表示空闲的线程会立刻终止。
+
+  workQueue则是使用`LinkedBlockingQueue`，但是没有设置范围，那么则是最大值（Integer.MAX_VALUE），这基本就相当于一个无界队列了。
+  **使用该“无界队列”则会带来哪些影响呢？**
+  当线程池中的线程数量等于corePoolSize 时，如果继续提交任务，该任务会被添加到阻塞队列workQueue中，当阻塞队列也满了之后，则线程池会新建线程执行任务直到maximumPoolSize。由于FixedThreadPool使用的是“无界队列”LinkedBlockingQueue，那么maximumPoolSize参数无效，同时指定的拒绝策略AbortPolicy也将无效。而且该线程池也不会拒绝提交的任务，如果客户端提交任务的速度快于任务的执行，那么keepAliveTime也是一个无效参数。
+
+  其运行图如下（参考《Java并发编程的艺术》）：
+  <img src="img/20171007215932303.png">
+
+  2. **SingleThreadExecutor**
+
+  SingleThreadExecutor是使用单个worker线程的Executor，定义如下：
+  ```java
+  public static ExecutorService newSingleThreadExecutor() {
+      return new FinalizableDelegatedExecutorService
+          (new ThreadPoolExecutor(1, 1,
+                                  0L, TimeUnit.MILLISECONDS,
+                                  new LinkedBlockingQueue<Runnable>()));
+  }
+  ```
+  作为单一worker线程的线程池，SingleThreadExecutor把`corePool`和`maximumPoolSize`均被设置为1，和FixedThreadPool一样使用的是无界队列`LinkedBlockingQueue`,所以带来的影响和FixedThreadPool一样。
+  <img src="img/20171007220046613.png">
+
+  3. **CachedThreadPool**
+
+  CachedThreadPool是一个会`根据需要`创建新线程的线程池 ，他定义如下：
+  ```java
+  public static ExecutorService newCachedThreadPool() {
+      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
+                                    60L, TimeUnit.SECONDS,
+                                    new SynchronousQueue<Runnable>());
+  }
+  ```
+  CachedThreadPool的`corePool`为0，`maximumPoolSize`为Integer.MAX_VALUE，这就意味着所有的任务一提交`就会加入到阻塞队列中`。
+  keepAliveTime这是为60L，unit设置为TimeUnit.SECONDS，意味着空闲线程等待`新任务的最长时间为60秒`，空闲线程超过60秒后将会被终止。
+  阻塞队列采用的`SynchronousQueue`，SynchronousQueue是一个没有元素的阻塞队列，加上corePool = 0 ，maximumPoolSize = Integer.MAX_VALUE，
+  这样就会存在一个 **问题**
+  如果主线程提交任务的速度远远大于CachedThreadPool的处理速度，则CachedThreadPool会不断地创建新线程来执行任务，这样有可能会导致系统耗尽CPU和内存资源，所以在使用该线程池是，一定要注意控制并发的任务数，否则创建大量的线程可能导致严重的性能问题。
+  <img src="img/20171007220114901.png">
+
+### 任务提交
+
+  线程池根据业务不同的需求提供了两种方式提交任务：`Executor.execute()`、`ExecutorService.submit()`。
+  其中ExecutorService.submit()可以获取该任务执行的`Future`。
+  我们以Executor.execute()为例，来看看线程池的任务提交经历了那些过程。
+
+  定义：
+  ```java
+  public interface Executor {
+      void execute(Runnable command);
+  }
+  ```
+  ThreadPoolExecutor提供实现：
+  ```java
+  public void execute(Runnable command) {
+      if (command == null)
+          throw new NullPointerException();
+      int c = ctl.get();
+      if (workerCountOf(c) < corePoolSize) {
+          if (addWorker(command, true))
+              return;
+          c = ctl.get();
+      }
+      if (isRunning(c) && workQueue.offer(command)) {
+          int recheck = ctl.get();
+          if (! isRunning(recheck) && remove(command))
+              reject(command);
+          else if (workerCountOf(recheck) == 0)
+              addWorker(null, false);
+      }
+      else if (!addWorker(command, false))
+          reject(command);
+  }
+  ```
+  执行流程如下：
+
+  1. 如果线程池当前线程数小于corePoolSize，则调用`addWorker()`创建新线程执行任务，成功返回true，失败执行步骤2。
+  2. 如果线程池处于RUNNING状态，则尝试加入阻塞队列，如果加入阻塞队列成功，则尝试进行Double Check，如果加入失败，则执行步骤3。
+  3. 如果线程池不是RUNNING状态或者加入阻塞队列失败，则尝试创建新线程直到maxPoolSize，如果失败，则调用`reject()`方法运行相应的拒绝策略。
+  
+  在步骤2中如果加入阻塞队列成功了，则会进行一个Double Check的过程。Double Check过程的主要目的是判断加入到阻塞队里中的线程是否可以被执行。如果线程池不是RUNNING状态，则调用`remove()`方法从阻塞队列中删除该任务，然后调用reject()方法处理任务。否则需要确保还有线程执行。
+
+  **addWorker**
+
+  当线程中的当前线程数小于corePoolSize，则调用addWorker()创建新线程执行任务，当前线程数则是根据ctl变量来获取的，调用workerCountOf(ctl)获取低29位即可：
+  ```java
+  private static int workerCountOf(int c)  { return c & CAPACITY; }
+  ```
+  addWorker(Runnable firstTask, boolean core)方法用于创建线程执行任务，源码如下：
+  ```java
+  private boolean addWorker(Runnable firstTask, boolean core) {
+    retry:
+    for (;;) {
+        int c = ctl.get();
+
+        // 获取当前线程状态
+        int rs = runStateOf(c);
+
+
+        if (rs >= SHUTDOWN &&
+                ! (rs == SHUTDOWN &&
+                        firstTask == null &&
+                        ! workQueue.isEmpty()))
+            return false;
+
+        // 内层循环，worker + 1
+        for (;;) {
+            // 线程数量
+            int wc = workerCountOf(c);
+            // 如果当前线程数大于线程最大上限CAPACITY  return false
+            // 若core == true，则与corePoolSize 比较，否则与maximumPoolSize ，大于 return false
+            if (wc >= CAPACITY ||
+                    wc >= (core ? corePoolSize : maximumPoolSize))
+                return false;
+            // worker + 1,成功跳出retry循环
+            if (compareAndIncrementWorkerCount(c))
+                break retry;
+
+            // CAS add worker 失败，再次读取ctl
+            c = ctl.get();
+
+            // 如果状态不等于之前获取的state，跳出内层循环，继续去外层循环判断
+            if (runStateOf(c) != rs)
+                continue retry;
+        }
+    }
+
+    boolean workerStarted = false;
+    boolean workerAdded = false;
+    Worker w = null;
+    try {
+
+        // 新建线程：Worker
+        w = new Worker(firstTask);
+        // 当前线程
+        final Thread t = w.thread;
+        if (t != null) {
+            // 获取主锁：mainLock
+            final ReentrantLock mainLock = this.mainLock;
+            mainLock.lock();
+            try {
+
+                // 线程状态
+                int rs = runStateOf(ctl.get());
+
+                // rs < SHUTDOWN ==> 线程处于RUNNING状态
+                // 或者线程处于SHUTDOWN状态，且firstTask == null（可能是workQueue中仍有未执行完成的任务，创建没有初始任务的worker线程执行）
+                if (rs < SHUTDOWN ||
+                        (rs == SHUTDOWN && firstTask == null)) {
+
+                    // 当前线程已经启动，抛出异常
+                    if (t.isAlive()) // precheck that t is startable
+                        throw new IllegalThreadStateException();
+
+                    // workers是一个HashSet<Worker>
+                    workers.add(w);
+
+                    // 设置最大的池大小largestPoolSize，workerAdded设置为true
+                    int s = workers.size();
+                    if (s > largestPoolSize)
+                        largestPoolSize = s;
+                    workerAdded = true;
+                }
+            } finally {
+                // 释放锁
+                mainLock.unlock();
+            }
+            // 启动线程
+            if (workerAdded) {
+                t.start();
+                workerStarted = true;
+            }
+        }
+    } finally {
+
+        // 线程启动失败
+        if (! workerStarted)
+            addWorkerFailed(w);
+    }
+    return workerStarted;
+  }
+  ```
+  判断当前线程是否可以添加任务，如果可以则进行下一步，否则return false；
+  rs >= SHUTDOWN ，表示当前线程处于SHUTDOWN ，STOP、TIDYING、TERMINATED状态
+  rs == SHUTDOWN , firstTask != null时不允许添加线程，因为线程处于SHUTDOWN 状态，不允许添加任务
+  rs == SHUTDOWN , firstTask == null，但workQueue.isEmpty() == true，不允许添加线程，因为firstTask == null是为了添加一个没有任务的线程然后再从workQueue中获取任务的，如果workQueue == null，则说明添加的任务没有任何意义。
+  内嵌循环，通过CAS worker + 1
+  获取主锁mailLock，如果线程池处于RUNNING状态获取处于SHUTDOWN状态且 firstTask == null，则将任务添加到workers Queue中，然后释放主锁mainLock，然后启动线程，然后return true，如果中途失败导致workerStarted= false，则调用addWorkerFailed()方法进行处理。
+  在这里需要好好理论addWorker中的参数，在execute()方法中，有三处调用了该方法：
+  第一次：workerCountOf(c) < corePoolSize ==> addWorker(command, true)，这个很好理解，当然线程池的线程数量小于 corePoolSize ，则新建线程执行任务即可，在执行过程core == true，内部与corePoolSize比较即可。
+  第二次：加入阻塞队列进行Double Check时，else if (workerCountOf(recheck) == 0) ==>addWorker(null, false)。如果线程池中的线程==0，按照道理应该该任务应该新建线程执行任务，但是由于已经该任务已经添加到了阻塞队列，那么就在线程池中新建一个空线程，然后从阻塞队列中取线程即可。
+  第三次：线程池不是RUNNING状态或者加入阻塞队列失败：else if (!addWorker(command, false))，这里core == fase，则意味着是与maximumPoolSize比较。
+
+  在新建线程执行任务时，将讲Runnable包装成一个Worker，Woker为ThreadPoolExecutor的内部类
+
+  **Woker内部类**
+
+  Woker的源码如下：
+  ```java
+  private final class Worker extends AbstractQueuedSynchronizer
+            implements Runnable {
+      private static final long serialVersionUID = 6138294804551838833L;
+
+      // task 的thread
+      final Thread thread;
+
+      // 运行的任务task
+      Runnable firstTask;
+
+      volatile long completedTasks;
+
+      Worker(Runnable firstTask) {
+
+          //设置AQS的同步状态private volatile int state，是一个计数器，大于0代表锁已经被获取
+          setState(-1);
+          this.firstTask = firstTask;
+
+          // 利用ThreadFactory和 Worker这个Runnable创建的线程对象
+          this.thread = getThreadFactory().newThread(this);
+      }
+
+      // 任务执行
+      public void run() {
+          runWorker(this);
+      }
+
+  }
+  ```
+  从Worker的源码中我们可以看到Woker继承AQS，实现Runnable接口，所以可以认为Worker既是一个可以执行的任务，也可以达到获取锁释放锁的效果。这里继承AQS主要是为了方便线程的中断处理。这里注意两个地方：构造函数、run()。构造函数主要是做三件事：1.设置同步状态state为-1，同步状态大于0表示就已经获取了锁，2.设置将当前任务task设置为firstTask，3.利用Worker本身对象this和ThreadFactory创建线程对象。
+
+  当线程thread启动（调用start()方法）时，其实就是执行Worker的run()方法，内部调用runWorker()。
+
+  **runWorker**
+  ```java
+  final void runWorker(Worker w) {
+      // 当前线程
+      Thread wt = Thread.currentThread();
+
+      // 要执行的任务
+      Runnable task = w.firstTask;
+
+      w.firstTask = null;
+
+      // 释放锁，运行中断
+      w.unlock(); // allow interrupts
+      boolean completedAbruptly = true;
+      try {
+          while (task != null || (task = getTask()) != null) {
+              // worker 获取锁
+              w.lock();
+
+              // 确保只有当线程是stoping时，才会被设置为中断，否则清楚中断标示
+              // 如果线程池状态 >= STOP ,且当前线程没有设置中断状态，则wt.interrupt()
+              // 如果线程池状态 < STOP，但是线程已经中断了，再次判断线程池是否 >= STOP，如果是 wt.interrupt()
+              if ((runStateAtLeast(ctl.get(), STOP) ||
+                      (Thread.interrupted() &&
+                              runStateAtLeast(ctl.get(), STOP))) &&
+                      !wt.isInterrupted())
+                  wt.interrupt();
+              try {
+                  // 自定义方法
+                  beforeExecute(wt, task);
+                  Throwable thrown = null;
+                  try {
+                      // 执行任务
+                      task.run();
+                  } catch (RuntimeException x) {
+                      thrown = x; throw x;
+                  } catch (Error x) {
+                      thrown = x; throw x;
+                  } catch (Throwable x) {
+                      thrown = x; throw new Error(x);
+                  } finally {
+                      afterExecute(task, thrown);
+                  }
+              } finally {
+                  task = null;
+                  // 完成任务数 + 1
+                  w.completedTasks++;
+                  // 释放锁
+                  w.unlock();
+              }
+          }
+          completedAbruptly = false;
+      } finally {
+          processWorkerExit(w, completedAbruptly);
+      }
+  }
+  ```
+  运行流程
+
+  根据worker获取要执行的任务task，然后调用unlock()方法释放锁，这里释放锁的主要目的在于中断，因为在new Worker时，设置的state为-1，调用unlock()方法可以将state设置为0，这里主要原因就在于interruptWorkers()方法只有在state >= 0时才会执行；
+  通过getTask()获取执行的任务，调用task.run()执行，当然在执行之前会调用worker.lock()上锁，执行之后调用worker.unlock()放锁；
+  在任务执行前后，可以根据业务场景自定义beforeExecute() 和 afterExecute()方法，则两个方法在ThreadPoolExecutor中是空实现；
+  如果线程执行完成，则会调用getTask()方法从阻塞队列中获取新任务，如果阻塞队列为空，则根据是否超时来判断是否需要阻塞；
+  task == null或者抛出异常（beforeExecute()、task.run()、afterExecute()均有可能）导致worker线程终止，则调用processWorkerExit()方法处理worker退出流程。
+
+  **getTask()**
+
+  ```java
+  private Runnable getTask() {
+      boolean timedOut = false; // Did the last poll() time out?
+
+      for (;;) {
+
+          // 线程池状态
+          int c = ctl.get();
+          int rs = runStateOf(c);
+
+          // 线程池中状态 >= STOP 或者 线程池状态 == SHUTDOWN且阻塞队列为空，则worker - 1，return null
+          if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
+              decrementWorkerCount();
+              return null;
+          }
+
+          int wc = workerCountOf(c);
+
+          // 判断是否需要超时控制
+          boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
+
+          if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
+              if (compareAndDecrementWorkerCount(c))
+                  return null;
+              continue;
+          }
+
+          try {
+
+              // 从阻塞队列中获取task
+              // 如果需要超时控制，则调用poll()，否则调用take()
+              Runnable r = timed ?
+                      workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
+                      workQueue.take();
+              if (r != null)
+                  return r;
+              timedOut = true;
+          } catch (InterruptedException retry) {
+              timedOut = false;
+          }
+      }
+  }
+  ```
+
+  timed == true，调用poll()方法，如果在keepAliveTime时间内还没有获取task的话，则返回null，继续循环。timed == false，**则调用take()方法，该方法为一个阻塞方法，没有任务时会一直阻塞挂起，直到有任务加入时对该线程唤醒，返回任务。**
+
+  在runWorker()方法中，无论最终结果如何，都会执行processWorkerExit()方法对worker进行退出处理。
+
+  **processWorkerExit()**
+  ```java
+  private void processWorkerExit(Worker w, boolean completedAbruptly) {
+      // true：用户线程运行异常,需要扣减
+      // false：getTask方法中扣减线程数量
+      if (completedAbruptly)
+          decrementWorkerCount();
+
+      // 获取主锁
+      final ReentrantLock mainLock = this.mainLock;
+      mainLock.lock();
+      try {
+          completedTaskCount += w.completedTasks;
+          // 从HashSet中移出worker
+          workers.remove(w);
+      } finally {
+          mainLock.unlock();
+      }
+
+      // 有worker线程移除，可能是最后一个线程退出需要尝试终止线程池
+      tryTerminate();
+
+      int c = ctl.get();
+      // 如果线程为running或shutdown状态，即tryTerminate()没有成功终止线程池，则判断是否有必要一个worker
+      if (runStateLessThan(c, STOP)) {
+          // 正常退出，计算min：需要维护的最小线程数量
+          if (!completedAbruptly) {
+              // allowCoreThreadTimeOut 默认false：是否需要维持核心线程的数量
+              int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
+              // 如果min ==0 或者workerQueue为空，min = 1
+              if (min == 0 && ! workQueue.isEmpty())
+                  min = 1;
+
+              // 如果线程数量大于最少数量min，直接返回，不需要新增线程
+              if (workerCountOf(c) >= min)
+                  return; // replacement not needed
+          }
+          // 添加一个没有firstTask的worker
+          addWorker(null, false);
+      }
+  }
+  ```
+  首先completedAbruptly的值来判断是否需要对线程数-1处理，如果completedAbruptly == true，说明在任务运行过程中出现了异常，那么需要进行减1处理，否则不需要，因为减1处理在getTask()方法中处理了。然后从HashSet中移出该worker，过程需要获取mainlock。然后调用tryTerminate()方法处理，该方法是对最后一个线程退出做终止线程池动作。如果线程池没有终止，那么线程池需要保持一定数量的线程，则通过addWorker(null,false)新增一个空的线程。
+
+  **addWorkerFailed()**
+
+  在addWorker()方法中，如果线程t==null，或者在add过程出现异常，会导致workerStarted == false，那么在最后会调用addWorkerFailed()方法：
+  ```java
+  private void addWorkerFailed(Worker w) {
+      final ReentrantLock mainLock = this.mainLock;
+      mainLock.lock();
+      try {
+          // 从HashSet中移除该worker
+          if (w != null)
+              workers.remove(w);
+
+          // 线程数 - 1
+          decrementWorkerCount();
+          // 尝试终止线程
+          tryTerminate();
+      } finally {
+          mainLock.unlock();
+      }
+  }
+  ```
+  整个逻辑显得比较简单。
+
+  **tryTerminate()**
+
+  当线程池涉及到要移除worker时候都会调用tryTerminate()，该方法主要用于判断线程池中的线程是否已经全部移除了，如果是的话则关闭线程池。
+  ```java
+  final void tryTerminate() {
+      for (;;) {
+          int c = ctl.get();
+          // 线程池处于Running状态
+          // 线程池已经终止了
+          // 线程池处于ShutDown状态，但是阻塞队列不为空
+          if (isRunning(c) ||
+                  runStateAtLeast(c, TIDYING) ||
+                  (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
+              return;
+
+          // 执行到这里，就意味着线程池要么处于STOP状态，要么处于SHUTDOWN且阻塞队列为空
+          // 这时如果线程池中还存在线程，则会尝试中断线程
+          if (workerCountOf(c) != 0) {
+              // /线程池还有线程，但是队列没有任务了，需要中断唤醒等待任务的线程
+              // （runwoker的时候首先就通过w.unlock设置线程可中断，getTask最后面的catch处理中断）
+              interruptIdleWorkers(ONLY_ONE);
+              return;
+          }
+
+          final ReentrantLock mainLock = this.mainLock;
+          mainLock.lock();
+          try {
+              // 尝试终止线程池
+              if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
+                  try {
+                      terminated();
+                  } finally {
+                      // 线程池状态转为TERMINATED
+                      ctl.set(ctlOf(TERMINATED, 0));
+                      termination.signalAll();
+                  }
+                  return;
+              }
+          } finally {
+              mainLock.unlock();
+          }
+      }
+  }
+  ```
+  在关闭线程池的过程中，如果线程池处于STOP状态或者处于SHUDOWN状态且阻塞队列为null，则线程池会调用interruptIdleWorkers()方法中断所有线程，注意ONLY_ONE== true，表示仅中断一个线程。
+
+ **interruptIdleWorkers**
+ ```java
+  private void interruptIdleWorkers(boolean onlyOne) {
+      final ReentrantLock mainLock = this.mainLock;
+      mainLock.lock();
+      try {
+          for (Worker w : workers) {
+              Thread t = w.thread;
+              if (!t.isInterrupted() && w.tryLock()) {
+                  try {
+                      t.interrupt();
+                  } catch (SecurityException ignore) {
+                  } finally {
+                      w.unlock();
+                  }
+              }
+              if (onlyOne)
+                  break;
+          }
+      } finally {
+          mainLock.unlock();
+      }
+  }
+  ```
+  onlyOne==true仅终止一个线程，否则终止所有线程。
+
+###  线程终止
+  线程池ThreadPoolExecutor提供了shutdown()和shutDownNow()用于关闭线程池。
+
+  shutdown()：按过去执行已提交任务的顺序发起一个有序的关闭，但是不接受新任务。
+
+  shutdownNow() :尝试停止所有的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表。
+
+  **shutdown**
+  ```java
+  public void shutdown() {
+      final ReentrantLock mainLock = this.mainLock;
+      mainLock.lock();
+      try {
+          checkShutdownAccess();
+          // 推进线程状态
+          advanceRunState(SHUTDOWN);
+          // 中断空闲的线程
+          interruptIdleWorkers();
+          // 交给子类实现
+          onShutdown();
+      } finally {
+          mainLock.unlock();
+      }
+      tryTerminate();
+  }
+  ```
+  **shutdownNow**
+  ```java
+  public List<Runnable> shutdownNow() {
+      List<Runnable> tasks;
+      final ReentrantLock mainLock = this.mainLock;
+      mainLock.lock();
+      try {
+          checkShutdownAccess();
+          advanceRunState(STOP);
+          // 中断所有线程
+          interruptWorkers();
+          // 返回等待执行的任务列表
+          tasks = drainQueue();
+      } finally {
+          mainLock.unlock();
+      }
+      tryTerminate();
+      return tasks;
+  }
+  ```
+  与shutdown不同，shutdownNow会调用interruptWorkers()方法中断所有线程。
+  ```java
+  private void interruptWorkers() {
+      final ReentrantLock mainLock = this.mainLock;
+      mainLock.lock();
+      try {
+          for (Worker w : workers)
+              w.interruptIfStarted();
+      } finally {
+          mainLock.unlock();
+      }
+  }
+  ```
+  同时会调用drainQueue()方法返回等待执行到任务列表。
+  ```java
+  private List<Runnable> drainQueue() {
+      BlockingQueue<Runnable> q = workQueue;
+      ArrayList<Runnable> taskList = new ArrayList<Runnable>();
+      q.drainTo(taskList);
+      if (!q.isEmpty()) {
+          for (Runnable r : q.toArray(new Runnable[0])) {
+              if (q.remove(r))
+                  taskList.add(r);
+          }
+      }
+      return taskList;
+  }
+  ```
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/33 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ScheduledThreadPoolExecutor.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/33 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ScheduledThreadPoolExecutor.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/33 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ScheduledThreadPoolExecutor.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/33 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ScheduledThreadPoolExecutor.md"
index e87ca583..9374619e 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/33 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ScheduledThreadPoolExecutor.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/33 - J.U.C\344\271\213\347\272\277\347\250\213\346\261\240\357\274\232ScheduledThreadPoolExecutor.md"	
@@ -1,210 +1,210 @@
-### ScheduledThreadPoolExecutor解析
-
-  我们知道Timer与TimerTask虽然可以实现线程的周期和延迟调度，但是Timer与TimerTask存在一些缺陷，所以对于这种`定期、周期执行任务的调度策略`，我们一般都是推荐`ScheduledThreadPoolExecutor`来实现。下面就深入分析ScheduledThreadPoolExecutor是如何来实现线程的周期、延迟调度的。
-
-  ScheduledThreadPoolExecutor，继承`ThreadPoolExecutor`且实现了`ScheduledExecutorService`接口，它就相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。在JDK API中是这样定义它的：**ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求 ThreadPoolExecutor 具有额外的灵活性或功能时，此类要优于 Timer。 一旦启用已延迟的任务就执行它，但是有关何时启用，启用后何时执行则没有任何实时保证。按照提交的先进先出 (FIFO) 顺序来启用那些被安排在同一执行时间的任务。**
-
-  它提供了四个构造方法：
-  ```java
-  public ScheduledThreadPoolExecutor(int corePoolSize) {
-      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
-             new DelayedWorkQueue());
-  }
-
-  public ScheduledThreadPoolExecutor(int corePoolSize,
-                                    ThreadFactory threadFactory) {
-      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
-             new DelayedWorkQueue(), threadFactory);
-  }
-
-  public ScheduledThreadPoolExecutor(int corePoolSize,
-                                    RejectedExecutionHandler handler) {
-      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
-             new DelayedWorkQueue(), handler);
-  }
-
-
-  public ScheduledThreadPoolExecutor(int corePoolSize,
-                                    ThreadFactory threadFactory,
-                                    RejectedExecutionHandler handler) {
-      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
-             new DelayedWorkQueue(), threadFactory, handler);
-  }
-  ```
-  当然我们一般都不会直接通过其构造函数来生成一个ScheduledThreadPoolExecutor对象（例如new ScheduledThreadPoolExecutor(10)之类的），而是通过Executors类（例如`Executors.newScheduledThreadPool(int);`）
-
-  在ScheduledThreadPoolExecutor的构造函数中，我们发现它都是利用ThreadLocalExecutor来构造的，唯一变动的地方就在于它所使用的阻塞队列变成了`DelayedWorkQueue`，而不是ThreadLocalhExecutor的LinkedBlockingQueue（通过Executors产生ThreadLocalhExecutor对象）。DelayedWorkQueue为ScheduledThreadPoolExecutor中的内部类，它其实和阻塞队列DelayQueue有点儿类似。DelayQueue是可以`提供延迟的阻塞队列`，它只有在延迟期满时才能从中提取元素，其列头是延迟期满后保存时间最长的Delayed元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。有关于DelayQueue的更多介绍请参考这篇博客【死磕Java并发】-----J.U.C之阻塞队列：DelayQueue。所以DelayedWorkQueue中的任务必然是按照延迟时间从短到长来进行排序的。下面我们再深入分析DelayedWorkQueue，这里留一个引子。
-
-  ScheduledThreadPoolExecutor提供了如下四个方法，也就是四个调度器：
-
-  1. `schedule(Callable callable, long delay, TimeUnit unit)`:创建并执行在给定延迟后启用的 ScheduledFuture。
-  2. `schedule(Runnable command, long delay, TimeUnit unit)`:创建并执行在给定延迟后启用的一次性操作。
-  3. `scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)` :创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
-  4. `scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)` :创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
-
-
-  第一、二个方法差不多，都是 **一次性操作**，只不过参数一个是Callable，一个是Runnable。
-
-  稍微分析下第三（`scheduleAtFixedRate`）、四个（`scheduleWithFixedDelay`）方法，加入 **initialDelay = 5，period/delay = 3，unit为秒**。
-  如果每个线程都是都运行非常良好不存在延迟的问题，那么这两个方法线程运行周期是5、8、11、14、17.......，
-  **但是如果存在延迟呢？比如第三个线程用了5秒钟，那么这两个方法的处理策略是怎样的？**
-  第三个方法（scheduleAtFixedRate）是周期固定，也就说它是不会受到这个延迟的影响的，每个线程的调度周期在初始化时就已经绝对了，是什么时候调度就是什么时候调度，它不会因为上一个线程的调度失效延迟而受到影响。
-  但是第四个方法（scheduleWithFixedDelay），则不一样，它是 **每个线程的调度间隔固定**，也就是说第一个线程与第二线程之间间隔delay，第二个与第三个间隔delay，以此类推。如果第二线程推迟了那么后面所有的线程调度都会推迟，例如，上面第二线程推迟了2秒，那么第三个就不再是11秒执行了，而是13秒执行。
-  第四个方法和 **@Scheduled(initialDelay=1000, fixedRate=5000)第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次** 一样的策略
-
-  查看着四个方法的源码，会发现其实他们的处理逻辑都差不多，所以我们就挑`scheduleWithFixedDelay`方法来分析，如下：
-  ```java
-  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
-                                                    long initialDelay,
-                                                    long delay,
-                                                    TimeUnit unit) {
-     if (command == null || unit == null)
-         throw new NullPointerException();
-     if (delay <= 0)
-         throw new IllegalArgumentException();
-     ScheduledFutureTask<Void> sft =
-         new ScheduledFutureTask<Void>(command,
-                                       null,
-                                       triggerTime(initialDelay, unit),
-                                       unit.toNanos(-delay));
-     RunnableScheduledFuture<Void> t = decorateTask(command, sft);
-     sft.outerTask = t;
-     delayedExecute(t);
-     return t;
-  }
-  ```
-  scheduleWithFixedDelay方法处理的逻辑如下：
-
-    1. 校验，如果参数不合法则抛出异常
-    2. 构造一个task，该task为ScheduledFutureTask
-    3. 调用delayedExecute()方法做后续相关处理
-
-
-  这段代码涉及两个类ScheduledFutureTask和RunnableScheduledFuture，其中RunnableScheduledFuture不用多说，他继承RunnableFuture和ScheduledFuture两个接口，除了具备RunnableFuture和ScheduledFuture两类特性外，它还定义了一个方法isPeriodic() ，该方法用于判断执行的任务是否为定期任务，如果是则返回true。而ScheduledFutureTask作为ScheduledThreadPoolExecutor的内部类，它扮演着极其重要的作用，因为它的作用则是负责ScheduledThreadPoolExecutor中任务的调度。
-
-  ScheduledFutureTask内部继承FutureTask，实现RunnableScheduledFuture接口，它内部定义了三个比较重要的变量
-  ```java
-  /** 任务被添加到ScheduledThreadPoolExecutor中的序号 */
-  private final long sequenceNumber;
-
-  /** 任务要执行的具体时间 */
-  private long time;
-
-  /**  任务的间隔周期 **/
-  private final long period;
-  ```
-  这三个变量与任务的执行有着非常密切的关系，什么关系？先看ScheduledFutureTask的几个构造函数和核心方法：
-  ```java
-  ScheduledFutureTask(Runnable r, V result, long ns) {
-     super(r, result);
-     this.time = ns;
-     this.period = 0;
-     this.sequenceNumber = sequencer.getAndIncrement();
-  }
-
-  ScheduledFutureTask(Runnable r, V result, long ns, long period) {
-     super(r, result);
-     this.time = ns;
-     this.period = period;
-     this.sequenceNumber = sequencer.getAndIncrement();
-  }
-
-  ScheduledFutureTask(Callable<V> callable, long ns) {
-     super(callable);
-     this.time = ns;
-     this.period = 0;
-     this.sequenceNumber = sequencer.getAndIncrement();
-  }
-
-  ScheduledFutureTask(Callable<V> callable, long ns) {
-     super(callable);
-     this.time = ns;
-     this.period = 0;
-     this.sequenceNumber = sequencer.getAndIncrement();
-  }
-  ```
-  ScheduledFutureTask 提供了四个构造方法，这些构造方法与上面三个参数是不是一一对应了？这些参数有什么用，如何用，则要看ScheduledFutureTask在那些方法使用了该方法，在ScheduledFutureTask中有一个compareTo()方法：
-  ```java
-  public int compareTo(Delayed other) {
-     if (other == this) // compare zero if same object
-         return 0;
-     if (other instanceof ScheduledFutureTask) {
-         ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
-         long diff = time - x.time;
-         if (diff < 0)
-             return -1;
-         else if (diff > 0)
-             return 1;
-         else if (sequenceNumber < x.sequenceNumber)
-             return -1;
-         else
-             return 1;
-     }
-     long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
-     return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
-  }
-  ```
-  相信各位都知道该方法是干嘛用的，提供一个排序算法，该算法规则是：首先按照time排序，time小的排在前面，大的排在后面，如果time相同，则使用sequenceNumber排序，小的排在前面，大的排在后面。那么为什么在这个类里面提供compareTo()方法呢？在前面就介绍过ScheduledThreadPoolExecutor在构造方法中提供的是DelayedWorkQueue()队列中，也就是说ScheduledThreadPoolExecutor是把任务添加到DelayedWorkQueue中的，而DelayedWorkQueue则是类似于DelayQueue，内部维护着一个以时间为先后顺序的队列，所以compareTo()方法使用与DelayedWorkQueue队列对其元素ScheduledThreadPoolExecutor task进行排序的算法。
-
-  排序已经解决了，那么ScheduledThreadPoolExecutor 是如何对task任务进行调度和延迟的呢？任何线程的执行，都是通过run()方法执行，ScheduledThreadPoolExecutor 的run()方法如下：
-  ```java
-  public void run() {
-     boolean periodic = isPeriodic();
-     if (!canRunInCurrentRunState(periodic))
-         cancel(false);
-     else if (!periodic)
-         ScheduledFutureTask.super.run();
-     else if (ScheduledFutureTask.super.runAndReset()) {
-         setNextRunTime();
-         reExecutePeriodic(outerTask);
-     }
-  }
-  ```
-  调用isPeriodic()获取该线程是否为周期性任务标志，然后调用canRunInCurrentRunState()方法判断该线程是否可以执行，如果不可以执行则调用cancel()取消任务。
-  如果当线程已经到达了执行点，则调用run()方法执行task，该run()方法是在FutureTask中定义的。
-  否则调用runAndReset()方法运行并充值，调用setNextRunTime()方法计算任务下次的执行时间，重新把任务添加到队列中，让该任务可以重复执行。
-
-  **isPeriodic()**
-
-  该方法用于判断指定的任务是否为定期任务。
-  ```java
-  public boolean isPeriodic() {
-     return period != 0;
-  }
-  ```
-  canRunInCurrentRunState()判断任务是否可以取消，cancel()取消任务，这两个方法比较简单，而run()执行任务，runAndReset()运行并重置状态，牵涉比较广，我们放在FutureTask后面介绍。所以重点介绍setNextRunTime()和reExecutePeriodic()这两个涉及到延迟的方法。
-
-  **setNextRunTime()**
-
-  setNextRunTime()方法用于重新计算任务的下次执行时间。如下：
-  ```java
-  private void setNextRunTime() {
-     long p = period;
-     if (p > 0)
-         time += p;
-     else
-         time = triggerTime(-p);
-  }
-  ```
-  该方法定义很简单，p > 0 ,time += p ，否则调用triggerTime()方法重新计算time：
-  ```java
-  long triggerTime(long delay) {
-     return now() +
-         ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
-  }
-  ```
-  reExecutePeriodic
-  ```java
-  void reExecutePeriodic(RunnableScheduledFuture<?> task) {
-     if (canRunInCurrentRunState(true)) {
-         super.getQueue().add(task);
-         if (!canRunInCurrentRunState(true) && remove(task))
-             task.cancel(false);
-         else
-             ensurePrestart();
-     }
-  }
-  ```
-  reExecutePeriodic重要的是调用super.getQueue().add(task);将任务task加入的队列DelayedWorkQueue中。ensurePrestart()在【死磕Java并发】-----J.U.C之线程池：ThreadPoolExecutor已经做了详细介绍。
-
-  到这里ScheduledFutureTask已经介绍完了，ScheduledFutureTask在ScheduledThreadPoolExecutor扮演作用的重要性不言而喻。其实ScheduledThreadPoolExecutor的实现不是很复杂，因为有FutureTask和ThreadPoolExecutor的支撑，其实现就显得不是那么难了。
+### ScheduledThreadPoolExecutor解析
+
+  我们知道Timer与TimerTask虽然可以实现线程的周期和延迟调度，但是Timer与TimerTask存在一些缺陷，所以对于这种`定期、周期执行任务的调度策略`，我们一般都是推荐`ScheduledThreadPoolExecutor`来实现。下面就深入分析ScheduledThreadPoolExecutor是如何来实现线程的周期、延迟调度的。
+
+  ScheduledThreadPoolExecutor，继承`ThreadPoolExecutor`且实现了`ScheduledExecutorService`接口，它就相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。在JDK API中是这样定义它的：**ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求 ThreadPoolExecutor 具有额外的灵活性或功能时，此类要优于 Timer。 一旦启用已延迟的任务就执行它，但是有关何时启用，启用后何时执行则没有任何实时保证。按照提交的先进先出 (FIFO) 顺序来启用那些被安排在同一执行时间的任务。**
+
+  它提供了四个构造方法：
+  ```java
+  public ScheduledThreadPoolExecutor(int corePoolSize) {
+      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
+             new DelayedWorkQueue());
+  }
+
+  public ScheduledThreadPoolExecutor(int corePoolSize,
+                                    ThreadFactory threadFactory) {
+      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
+             new DelayedWorkQueue(), threadFactory);
+  }
+
+  public ScheduledThreadPoolExecutor(int corePoolSize,
+                                    RejectedExecutionHandler handler) {
+      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
+             new DelayedWorkQueue(), handler);
+  }
+
+
+  public ScheduledThreadPoolExecutor(int corePoolSize,
+                                    ThreadFactory threadFactory,
+                                    RejectedExecutionHandler handler) {
+      super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
+             new DelayedWorkQueue(), threadFactory, handler);
+  }
+  ```
+  当然我们一般都不会直接通过其构造函数来生成一个ScheduledThreadPoolExecutor对象（例如new ScheduledThreadPoolExecutor(10)之类的），而是通过Executors类（例如`Executors.newScheduledThreadPool(int);`）
+
+  在ScheduledThreadPoolExecutor的构造函数中，我们发现它都是利用ThreadLocalExecutor来构造的，唯一变动的地方就在于它所使用的阻塞队列变成了`DelayedWorkQueue`，而不是ThreadLocalhExecutor的LinkedBlockingQueue（通过Executors产生ThreadLocalhExecutor对象）。DelayedWorkQueue为ScheduledThreadPoolExecutor中的内部类，它其实和阻塞队列DelayQueue有点儿类似。DelayQueue是可以`提供延迟的阻塞队列`，它只有在延迟期满时才能从中提取元素，其列头是延迟期满后保存时间最长的Delayed元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。有关于DelayQueue的更多介绍请参考这篇博客【死磕Java并发】-----J.U.C之阻塞队列：DelayQueue。所以DelayedWorkQueue中的任务必然是按照延迟时间从短到长来进行排序的。下面我们再深入分析DelayedWorkQueue，这里留一个引子。
+
+  ScheduledThreadPoolExecutor提供了如下四个方法，也就是四个调度器：
+
+  1. `schedule(Callable callable, long delay, TimeUnit unit)`:创建并执行在给定延迟后启用的 ScheduledFuture。
+  2. `schedule(Runnable command, long delay, TimeUnit unit)`:创建并执行在给定延迟后启用的一次性操作。
+  3. `scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)` :创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
+  4. `scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)` :创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
+
+
+  第一、二个方法差不多，都是 **一次性操作**，只不过参数一个是Callable，一个是Runnable。
+
+  稍微分析下第三（`scheduleAtFixedRate`）、四个（`scheduleWithFixedDelay`）方法，加入 **initialDelay = 5，period/delay = 3，unit为秒**。
+  如果每个线程都是都运行非常良好不存在延迟的问题，那么这两个方法线程运行周期是5、8、11、14、17.......，
+  **但是如果存在延迟呢？比如第三个线程用了5秒钟，那么这两个方法的处理策略是怎样的？**
+  第三个方法（scheduleAtFixedRate）是周期固定，也就说它是不会受到这个延迟的影响的，每个线程的调度周期在初始化时就已经绝对了，是什么时候调度就是什么时候调度，它不会因为上一个线程的调度失效延迟而受到影响。
+  但是第四个方法（scheduleWithFixedDelay），则不一样，它是 **每个线程的调度间隔固定**，也就是说第一个线程与第二线程之间间隔delay，第二个与第三个间隔delay，以此类推。如果第二线程推迟了那么后面所有的线程调度都会推迟，例如，上面第二线程推迟了2秒，那么第三个就不再是11秒执行了，而是13秒执行。
+  第四个方法和 **@Scheduled(initialDelay=1000, fixedRate=5000)第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次** 一样的策略
+
+  查看着四个方法的源码，会发现其实他们的处理逻辑都差不多，所以我们就挑`scheduleWithFixedDelay`方法来分析，如下：
+  ```java
+  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
+                                                    long initialDelay,
+                                                    long delay,
+                                                    TimeUnit unit) {
+     if (command == null || unit == null)
+         throw new NullPointerException();
+     if (delay <= 0)
+         throw new IllegalArgumentException();
+     ScheduledFutureTask<Void> sft =
+         new ScheduledFutureTask<Void>(command,
+                                       null,
+                                       triggerTime(initialDelay, unit),
+                                       unit.toNanos(-delay));
+     RunnableScheduledFuture<Void> t = decorateTask(command, sft);
+     sft.outerTask = t;
+     delayedExecute(t);
+     return t;
+  }
+  ```
+  scheduleWithFixedDelay方法处理的逻辑如下：
+
+    1. 校验，如果参数不合法则抛出异常
+    2. 构造一个task，该task为ScheduledFutureTask
+    3. 调用delayedExecute()方法做后续相关处理
+
+
+  这段代码涉及两个类ScheduledFutureTask和RunnableScheduledFuture，其中RunnableScheduledFuture不用多说，他继承RunnableFuture和ScheduledFuture两个接口，除了具备RunnableFuture和ScheduledFuture两类特性外，它还定义了一个方法isPeriodic() ，该方法用于判断执行的任务是否为定期任务，如果是则返回true。而ScheduledFutureTask作为ScheduledThreadPoolExecutor的内部类，它扮演着极其重要的作用，因为它的作用则是负责ScheduledThreadPoolExecutor中任务的调度。
+
+  ScheduledFutureTask内部继承FutureTask，实现RunnableScheduledFuture接口，它内部定义了三个比较重要的变量
+  ```java
+  /** 任务被添加到ScheduledThreadPoolExecutor中的序号 */
+  private final long sequenceNumber;
+
+  /** 任务要执行的具体时间 */
+  private long time;
+
+  /**  任务的间隔周期 **/
+  private final long period;
+  ```
+  这三个变量与任务的执行有着非常密切的关系，什么关系？先看ScheduledFutureTask的几个构造函数和核心方法：
+  ```java
+  ScheduledFutureTask(Runnable r, V result, long ns) {
+     super(r, result);
+     this.time = ns;
+     this.period = 0;
+     this.sequenceNumber = sequencer.getAndIncrement();
+  }
+
+  ScheduledFutureTask(Runnable r, V result, long ns, long period) {
+     super(r, result);
+     this.time = ns;
+     this.period = period;
+     this.sequenceNumber = sequencer.getAndIncrement();
+  }
+
+  ScheduledFutureTask(Callable<V> callable, long ns) {
+     super(callable);
+     this.time = ns;
+     this.period = 0;
+     this.sequenceNumber = sequencer.getAndIncrement();
+  }
+
+  ScheduledFutureTask(Callable<V> callable, long ns) {
+     super(callable);
+     this.time = ns;
+     this.period = 0;
+     this.sequenceNumber = sequencer.getAndIncrement();
+  }
+  ```
+  ScheduledFutureTask 提供了四个构造方法，这些构造方法与上面三个参数是不是一一对应了？这些参数有什么用，如何用，则要看ScheduledFutureTask在那些方法使用了该方法，在ScheduledFutureTask中有一个compareTo()方法：
+  ```java
+  public int compareTo(Delayed other) {
+     if (other == this) // compare zero if same object
+         return 0;
+     if (other instanceof ScheduledFutureTask) {
+         ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
+         long diff = time - x.time;
+         if (diff < 0)
+             return -1;
+         else if (diff > 0)
+             return 1;
+         else if (sequenceNumber < x.sequenceNumber)
+             return -1;
+         else
+             return 1;
+     }
+     long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
+     return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
+  }
+  ```
+  相信各位都知道该方法是干嘛用的，提供一个排序算法，该算法规则是：首先按照time排序，time小的排在前面，大的排在后面，如果time相同，则使用sequenceNumber排序，小的排在前面，大的排在后面。那么为什么在这个类里面提供compareTo()方法呢？在前面就介绍过ScheduledThreadPoolExecutor在构造方法中提供的是DelayedWorkQueue()队列中，也就是说ScheduledThreadPoolExecutor是把任务添加到DelayedWorkQueue中的，而DelayedWorkQueue则是类似于DelayQueue，内部维护着一个以时间为先后顺序的队列，所以compareTo()方法使用与DelayedWorkQueue队列对其元素ScheduledThreadPoolExecutor task进行排序的算法。
+
+  排序已经解决了，那么ScheduledThreadPoolExecutor 是如何对task任务进行调度和延迟的呢？任何线程的执行，都是通过run()方法执行，ScheduledThreadPoolExecutor 的run()方法如下：
+  ```java
+  public void run() {
+     boolean periodic = isPeriodic();
+     if (!canRunInCurrentRunState(periodic))
+         cancel(false);
+     else if (!periodic)
+         ScheduledFutureTask.super.run();
+     else if (ScheduledFutureTask.super.runAndReset()) {
+         setNextRunTime();
+         reExecutePeriodic(outerTask);
+     }
+  }
+  ```
+  调用isPeriodic()获取该线程是否为周期性任务标志，然后调用canRunInCurrentRunState()方法判断该线程是否可以执行，如果不可以执行则调用cancel()取消任务。
+  如果当线程已经到达了执行点，则调用run()方法执行task，该run()方法是在FutureTask中定义的。
+  否则调用runAndReset()方法运行并充值，调用setNextRunTime()方法计算任务下次的执行时间，重新把任务添加到队列中，让该任务可以重复执行。
+
+  **isPeriodic()**
+
+  该方法用于判断指定的任务是否为定期任务。
+  ```java
+  public boolean isPeriodic() {
+     return period != 0;
+  }
+  ```
+  canRunInCurrentRunState()判断任务是否可以取消，cancel()取消任务，这两个方法比较简单，而run()执行任务，runAndReset()运行并重置状态，牵涉比较广，我们放在FutureTask后面介绍。所以重点介绍setNextRunTime()和reExecutePeriodic()这两个涉及到延迟的方法。
+
+  **setNextRunTime()**
+
+  setNextRunTime()方法用于重新计算任务的下次执行时间。如下：
+  ```java
+  private void setNextRunTime() {
+     long p = period;
+     if (p > 0)
+         time += p;
+     else
+         time = triggerTime(-p);
+  }
+  ```
+  该方法定义很简单，p > 0 ,time += p ，否则调用triggerTime()方法重新计算time：
+  ```java
+  long triggerTime(long delay) {
+     return now() +
+         ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
+  }
+  ```
+  reExecutePeriodic
+  ```java
+  void reExecutePeriodic(RunnableScheduledFuture<?> task) {
+     if (canRunInCurrentRunState(true)) {
+         super.getQueue().add(task);
+         if (!canRunInCurrentRunState(true) && remove(task))
+             task.cancel(false);
+         else
+             ensurePrestart();
+     }
+  }
+  ```
+  reExecutePeriodic重要的是调用super.getQueue().add(task);将任务task加入的队列DelayedWorkQueue中。ensurePrestart()在【死磕Java并发】-----J.U.C之线程池：ThreadPoolExecutor已经做了详细介绍。
+
+  到这里ScheduledFutureTask已经介绍完了，ScheduledFutureTask在ScheduledThreadPoolExecutor扮演作用的重要性不言而喻。其实ScheduledThreadPoolExecutor的实现不是很复杂，因为有FutureTask和ThreadPoolExecutor的支撑，其实现就显得不是那么难了。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/34 - \345\210\206\346\236\220 ArrayBlockingQueue \346\236\204\351\200\240\345\207\275\346\225\260\345\212\240\351\224\201\351\227\256\351\242\230.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/34 - \345\210\206\346\236\220 ArrayBlockingQueue \346\236\204\351\200\240\345\207\275\346\225\260\345\212\240\351\224\201\351\227\256\351\242\230.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/34 - \345\210\206\346\236\220 ArrayBlockingQueue \346\236\204\351\200\240\345\207\275\346\225\260\345\212\240\351\224\201\351\227\256\351\242\230.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/34 - \345\210\206\346\236\220 ArrayBlockingQueue \346\236\204\351\200\240\345\207\275\346\225\260\345\212\240\351\224\201\351\227\256\351\242\230.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/all.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/all.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/all.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/all.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2_thumb-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2_thumb-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2_thumb-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/11111111111_2_thumb-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/14844980432094444444_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/14844980432094444444_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/14844980432094444444_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/14844980432094444444_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1484498051529555555_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1484498051529555555_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1484498051529555555_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1484498051529555555_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1485225206860201701240002_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1485225206860201701240002_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1485225206860201701240002_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/1485225206860201701240002_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile2_thumb-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile2_thumb-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile2_thumb-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile2_thumb-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile_thumb-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile_thumb-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile_thumb-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170104-volatile_thumb-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170110001_thumb-2.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170110001_thumb-2.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170110001_thumb-2.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20170110001_thumb-2.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240001_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240001_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240001_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240001_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240003_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240003_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240003_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701240003_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701260001_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701260001_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701260001_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701260001_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701270001_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701270001_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701270001_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701270001_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701310001_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701310001_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701310001_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201701310001_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702010001_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702010001_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702010001_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702010001_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060001_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060001_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060001_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060001_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060002.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060002.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060002.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702060002.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702100001_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702100001_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702100001_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702100001_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110001_2.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110001_2.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110001_2.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110001_2.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110002_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110002_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110002_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702110002_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200001_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200001_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200001_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200001_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200002_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200002_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200002_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017021200002_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170001_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170001_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170001_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170001_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170002.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170002.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170002.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201702170002.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017022100011_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017022100011_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017022100011_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2017022100011_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703050001_24.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703050001_24.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703050001_24.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703050001_24.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090001_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090001_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090001_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090001_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090002_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090002_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090002_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090002_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090003_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090003_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090003_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090003_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090004_2_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090004_2_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090004_2_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703090004_2_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270001_thumb.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270001_thumb.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270001_thumb.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270001_thumb.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270002_2_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270002_2_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270002_2_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270002_2_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270003_3_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270003_3_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270003_3_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270003_3_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270004_4_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270004_4_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270004_4_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270004_4_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270005_3_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270005_3_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270005_3_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270005_3_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270006_3_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270006_3_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270006_3_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270006_3_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270007_4_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270007_4_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270007_4_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270007_4_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270008_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270008_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270008_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270008_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270009_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270009_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270009_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270009_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270010_3_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270010_3_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270010_3_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/201703270010_3_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215630217.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215630217.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215630217.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215630217.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215932303.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215932303.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215932303.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007215932303.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220046613.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220046613.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220046613.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220046613.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220114901.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220114901.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220114901.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/20171007220114901.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/212219343783699_thumb-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/212219343783699_thumb-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/212219343783699_thumb-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/212219343783699_thumb-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/22222222222222_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/22222222222222_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/22222222222222_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/22222222222222_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/222222_2_thumb-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/222222_2_thumb-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/222222_2_thumb-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/222222_2_thumb-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-7fc4eec11964a492.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-7fc4eec11964a492.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-7fc4eec11964a492.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-7fc4eec11964a492.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-9013dd0f86ed018e.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-9013dd0f86ed018e.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-9013dd0f86ed018e.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-9013dd0f86ed018e.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-caff4e70c0181879.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-caff4e70c0181879.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-caff4e70c0181879.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-caff4e70c0181879.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-f27c0413b40951c3.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-f27c0413b40951c3.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-f27c0413b40951c3.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/2251324-f27c0413b40951c3.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/44444_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/44444_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/44444_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/44444_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/DCL00001_2_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/DCL00001_2_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/DCL00001_2_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/DCL00001_2_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/Synchronize-1_thumb-1.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/Synchronize-1_thumb-1.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/Synchronize-1_thumb-1.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/Synchronize-1_thumb-1.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/happens-before_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/happens-before_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/happens-before_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/happens-before_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/image2_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/image2_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/image2_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/image2_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/singleton_thumb.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/singleton_thumb.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/singleton_thumb.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/singleton_thumb.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/u7ED8_u56FE1_thumb-1.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/u7ED8_u56FE1_thumb-1.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/u7ED8_u56FE1_thumb-1.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/img/u7ED8_u56FE1_thumb-1.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/redeme.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/redeme.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/redeme.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/redeme.md"
index 88789608..dd0478ca 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/redeme.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\255\273\347\243\225Java\345\271\266\345\217\221/redeme.md"	
@@ -1,183 +1,183 @@
-from http://cmsblogs.com/
-
-
-### 01 - 深入分析synchronized 的实现原理
-
-synchronized 可以保证方法或者代码块在运行时，**同一时刻只有一个方法** 可以进入到临界区，同时它还可以保证共享变量的内存可见性。深入分析 synchronized 的内在实现机制，锁优化、锁升级过程。
-
-### 02 - 深入分析volatile的实现原理
-
-volatile 可以保证线程可见性且提供了一定的 **有序性**，但是 **无法保证原子性**。在 JVM 底层 volatile 是采用 **“内存屏障”** 来实现的。这篇博文将带你分析 volatile 的本质
-
-### 03 - Java内存模型之happens-before
-
-happens-before 原则是判断数据是否存在竞争、线程是否安全的主要依据，保证了多线程环境下的可见性。
-
-定义如下：
-
-如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
-两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。
-
-### 04 - Java内存模型之重排序
-
-在执行程序时，为了提供性能，处理器和编译器常常会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么排序，它需要满足以下两个条件：
-
-在单线程环境下不能改变程序运行的结果；
-存在数据依赖关系的不允许重排序
-as-if-serial 语义保证在单线程环境下重排序后的执行结果不会改变。
-
-### 05 - Java内存模型之分析volatile
-
-volatile的内存语义是：
-
-当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值立即刷新到主内存中。
-当读一个 volatile 变量时，JMM 会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量
-总是说 volatile 保证可见性，happens-before 是 JMM 实现可见性的基础理论，两者会碰撞怎样的火花？这篇博文给你答案。
-
-### 06 - Java内存模型之从JMM角度分析DCL
-
-DCL，即Double Check Lock，双重检查锁定。是实现单例模式比较好的方式，这篇博客告诉你 DCL 中为何要加 volatile 这个关键字。
-
-### 08 - J.U.C之AQS：AQS简介
-
-AQS，`AbstractQueuedSynchronizer`，即队列同步器。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），为 JUC 并发包中的核心基础组件。
-
-### 09 - J.U.C之AQS：CLH同步队列
-
-前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
-
-### 10 - J.U.C之AQS：同步状态的获取与释放
-
-AQS的设计模式采用的`模板方法模式`，子类通过继承的方式，实现它的抽象方法来管理同步状态，对于子类而言它并没有太多的活要做，AQS提供了大量的模板方法来实现同步，主要是分为三类：独占式获取和释放同步状态、共享式获取和释放同步状态、查询同步队列中的等待线程情况。
-
-### 11 - J.U.C之AQS：阻塞和唤醒线程
-
-当需要阻塞或者唤醒一个线程的时候，AQS 都是使用 LockSupport 这个工具类来完成。
-
-LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
-
-### 12 - J.U.C之重入锁：ReentrantLock
-
-一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。
-
-这篇博客带你理解 重入锁：ReentrantLock 内在本质。
-
-### 13 - J.U.C之读写锁：ReentrantReadWriteLock
-
-读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时，所有读线程和写线程都会被阻塞。
-
-读写锁的主要特性：
-
-公平性：支持公平性和非公平性。
-重入性：支持重入。读写锁最多支持65535个递归写入锁和65535个递归读取锁。
-锁降级：遵循获取写锁、获取读锁在释放写锁的次序，写锁能够降级成为读锁
-
-### 14 - J.U.C之Condition
-
-在没有Lock之前，我们使用synchronized来控制同步，配合Object的wait()、notify()系列方法可以实现等待/通知模式。在Java SE5后，Java提供了Lock接口，相对于Synchronized而言，Lock提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活
-
-### 15 - 深入分析CAS
-
-CAS，Compare And Swap，即比较并交换。Doug lea大神在同步组件中大量使用 CAS 技术鬼斧神工地实现了Java 多线程的并发操作。整个 AQS 同步组件、Atomic 原子类操作等等都是以 CAS 实现的。可以说CAS是整个JUC的基石。
-
-### 16 - J.U.C之并发工具类：CyclicBarrier
-
-CyclicBarrier，一个同步辅助类。它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
-
-### 17 - J.U.C之并发工具类：CountDownLatch
-
-CountDownLatch 所描述的是”在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待“。
-
-用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
-
-### 18 - J.U.C之并发工具类：Semaphore
-
-Semaphore，信号量，是一个控制访问多个共享资源的计数器。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。
-
-### 19 - J.U.C之并发工具类：Exchanger
-
-可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。Exchanger 可能在应用程序（比如遗传算法和管道设计）中很有用。
-
-### 20 - J.U.C之Java并发容器：ConcurrentHashMap
-
-ConcurrentHashMap 作为 Concurrent 一族，其有着高效地并发操作。在1.8 版本以前，ConcurrentHashMap 采用`分段锁`的概念，使`锁更加细化`，但是 1.8 已经改变了这种思路，而是利用 `CAS + Synchronized` 来保证并发更新的安全，当然底层采用`数组+链表+红黑树`的存储结构。这篇博客带你彻底理解 ConcurrentHashMap。
-
-### 21 - J.U.C之ConcurrentHashMap红黑树转换分析
-
-在 1.8 ConcurrentHashMap 的put操作中，如果发现链表结构中的元素超过了TREEIFY_THRESHOLD（默认为8），则会把链表转换为`红黑树`，已便于提高查询效率。那么具体的转换过程是怎么样的？这篇博客给你答案。
-
-### 22 - J.U.C之Java并发容器：ConcurrentLinkedQueue
-
-ConcurrentLinkedQueue是一个基于链接节点的无边界的线程安全队列，它采用FIFO原则对元素进行排序。采用“wait-free”算法（即CAS算法）来实现的。
-
-CoucurrentLinkedQueue规定了如下几个不变性：
-
-在入队的最后一个元素的next为null
-队列中所有未删除的节点的item都不能为null且都能从head节点遍历到
-对于要删除的节点，不是直接将其设置为null，而是先将其item域设置为null（迭代器会跳过item为null的节点）
-允许head和tail更新滞后。这是什么意思呢？意思就说是head、tail不总是指向第一个元素和最后一个元素（后面阐述）。
-### 22 - J.U.C之Java并发容器：ConcurrentSkipListMap
-
-我们在Java世界里看到了两种实现key-value的数据结构：Hash、TreeMap，这两种数据结构各自都有着优缺点。
-
-Hash表：插入、查找最快，为O(1)；如使用链表实现则可实现无锁；数据有序化需要显式的排序操作。
-红黑树：插入、查找为O(logn)，但常数项较小；无锁实现的复杂性很高，一般需要加锁；数据天然有序。
-这里介绍第三种实现 key-value 的数据结构：SkipList。SkipList 有着不低于红黑树的效率，但是其原理和实现的复杂度要比红黑树简单多了。
-
-ConcurrentSkipListMap 其内部采用 SkipLis 数据结构实现。
-
-### 23 - J.U.C之阻塞队列：ArrayBlockingQueue
-
-ArrayBlockingQueue，一个由数组实现的有界阻塞队列。该队列采用FIFO的原则对元素进行排序添加的。
-
-ArrayBlockingQueue 为有界且固定，其大小在构造时由构造函数来决定，确认之后就不能再改变了。ArrayBlockingQueue 支持对等待的生产者线程和使用者线程进行排序的可选公平策略，但是在默认情况下不保证线程公平的访问，在构造时可以选择公平策略（fair = true）。公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。
-
-### 24 - J.U.C之阻塞队列：PriorityBlockingQueue
-
-PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采用自然顺序升序排序，当然我们也可以通过构造函数来指定Comparator来对元素进行排序。需要注意的是PriorityBlockingQueue不能保证同优先级元素的顺序。
-
-### 25 - J.U.C之阻塞队列：DelayQueue
-
-DelayQueue是一个支持延时获取元素的无界阻塞队列。里面的元素全部都是“可延期”的元素，列头的元素是最先“到期”的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。也就是说只有在延迟期到时才能够从队列中取元素。
-
-DelayQueue主要用于两个方面：
-
-缓存：清掉缓存中超时的缓存数据
-任务超时处理
-### 26 - J.U.C之阻塞队列：SynchronousQueue
-
-SynchronousQueue与其他BlockingQueue有着不同特性：
-
-SynchronousQueue没有容量。与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue。每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
-因为没有容量，所以对应 peek, contains, clear, isEmpty ... 等方法其实是无效的。例如clear是不执行任何操作的，contains始终返回false,peek始终返回null。
-SynchronousQueue分为公平和非公平，默认情况下采用非公平性访问策略，当然也可以通过构造函数来设置为公平性访问策略（为true即可）。
-若使用 TransferQueue, 则队列中永远会存在一个 dummy node（这点后面详细阐述）。
-SynchronousQueue非常适合做交换工作，生产者的线程和消费者的线程同步以传递某些信息、事件或者任务。
-
-### 27 - J.U.C之阻塞队列：LinkedTransferQueue
-
-LinkedTransferQueue 是基于链表的 FIFO 无界阻塞队列，它出现在 JDK7 中。Doug Lea 大神说 LinkedTransferQueue 是一个聪明的队列。它是 ConcurrentLinkedQueue、SynchronousQueue (公平模式下)、无界的LinkedBlockingQueues 等的超集。
-
-### 28 - J.U.C之阻塞队列：LinkedBlockingDeque
-
-LinkedBlockingDeque 是一个由链表组成的双向阻塞队列，双向队列就意味着可以从对头、对尾两端插入和移除元素，同样意味着 LinkedBlockingDeque 支持 FIFO、FILO 两种操作方式。
-
-LinkedBlockingDeque 是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为 Integer.MAX_VALUE。
-
-### 30 - 深入分析ThreadLocal
-
-ThreadLocal 提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。
-
-所以ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。
-
-### 31 - J.U.C之线程池：ThreadPoolExecutor
-
-鼎鼎大名的线程池。不需要多说!!!!!
-
-这篇博客深入分析 Java 中线程池的实现。
-
-### 32 - J.U.C之线程池：ScheduledThreadPoolExecutor
-
-ScheduledThreadPoolExecutor 是实现线程的周期、延迟调度的。
-
-ScheduledThreadPoolExecutor，继承 ThreadPoolExecutor 且实现了 ScheduledExecutorService 接口，它就相当于提供了“延迟”和“周期执行”功能的 ThreadPoolExecutor。在JDK API中是这样定义它的：ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求 ThreadPoolExecutor 具有额外的灵活性或功能时，此类要优于 Timer。 一旦启用已延迟的任务就执行它，但是有关何时启用，启用后何时执行则没有任何实时保证。按照提交的先进先出 (FIFO) 顺序来启用那些被安排在同一执行时间的任务。
+from http://cmsblogs.com/
+
+
+### 01 - 深入分析synchronized 的实现原理
+
+synchronized 可以保证方法或者代码块在运行时，**同一时刻只有一个方法** 可以进入到临界区，同时它还可以保证共享变量的内存可见性。深入分析 synchronized 的内在实现机制，锁优化、锁升级过程。
+
+### 02 - 深入分析volatile的实现原理
+
+volatile 可以保证线程可见性且提供了一定的 **有序性**，但是 **无法保证原子性**。在 JVM 底层 volatile 是采用 **“内存屏障”** 来实现的。这篇博文将带你分析 volatile 的本质
+
+### 03 - Java内存模型之happens-before
+
+happens-before 原则是判断数据是否存在竞争、线程是否安全的主要依据，保证了多线程环境下的可见性。
+
+定义如下：
+
+如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
+两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。
+
+### 04 - Java内存模型之重排序
+
+在执行程序时，为了提供性能，处理器和编译器常常会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么排序，它需要满足以下两个条件：
+
+在单线程环境下不能改变程序运行的结果；
+存在数据依赖关系的不允许重排序
+as-if-serial 语义保证在单线程环境下重排序后的执行结果不会改变。
+
+### 05 - Java内存模型之分析volatile
+
+volatile的内存语义是：
+
+当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值立即刷新到主内存中。
+当读一个 volatile 变量时，JMM 会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量
+总是说 volatile 保证可见性，happens-before 是 JMM 实现可见性的基础理论，两者会碰撞怎样的火花？这篇博文给你答案。
+
+### 06 - Java内存模型之从JMM角度分析DCL
+
+DCL，即Double Check Lock，双重检查锁定。是实现单例模式比较好的方式，这篇博客告诉你 DCL 中为何要加 volatile 这个关键字。
+
+### 08 - J.U.C之AQS：AQS简介
+
+AQS，`AbstractQueuedSynchronizer`，即队列同步器。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），为 JUC 并发包中的核心基础组件。
+
+### 09 - J.U.C之AQS：CLH同步队列
+
+前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
+
+### 10 - J.U.C之AQS：同步状态的获取与释放
+
+AQS的设计模式采用的`模板方法模式`，子类通过继承的方式，实现它的抽象方法来管理同步状态，对于子类而言它并没有太多的活要做，AQS提供了大量的模板方法来实现同步，主要是分为三类：独占式获取和释放同步状态、共享式获取和释放同步状态、查询同步队列中的等待线程情况。
+
+### 11 - J.U.C之AQS：阻塞和唤醒线程
+
+当需要阻塞或者唤醒一个线程的时候，AQS 都是使用 LockSupport 这个工具类来完成。
+
+LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
+
+### 12 - J.U.C之重入锁：ReentrantLock
+
+一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。
+
+这篇博客带你理解 重入锁：ReentrantLock 内在本质。
+
+### 13 - J.U.C之读写锁：ReentrantReadWriteLock
+
+读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时，所有读线程和写线程都会被阻塞。
+
+读写锁的主要特性：
+
+公平性：支持公平性和非公平性。
+重入性：支持重入。读写锁最多支持65535个递归写入锁和65535个递归读取锁。
+锁降级：遵循获取写锁、获取读锁在释放写锁的次序，写锁能够降级成为读锁
+
+### 14 - J.U.C之Condition
+
+在没有Lock之前，我们使用synchronized来控制同步，配合Object的wait()、notify()系列方法可以实现等待/通知模式。在Java SE5后，Java提供了Lock接口，相对于Synchronized而言，Lock提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活
+
+### 15 - 深入分析CAS
+
+CAS，Compare And Swap，即比较并交换。Doug lea大神在同步组件中大量使用 CAS 技术鬼斧神工地实现了Java 多线程的并发操作。整个 AQS 同步组件、Atomic 原子类操作等等都是以 CAS 实现的。可以说CAS是整个JUC的基石。
+
+### 16 - J.U.C之并发工具类：CyclicBarrier
+
+CyclicBarrier，一个同步辅助类。它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
+
+### 17 - J.U.C之并发工具类：CountDownLatch
+
+CountDownLatch 所描述的是”在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待“。
+
+用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
+
+### 18 - J.U.C之并发工具类：Semaphore
+
+Semaphore，信号量，是一个控制访问多个共享资源的计数器。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。
+
+### 19 - J.U.C之并发工具类：Exchanger
+
+可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。Exchanger 可能在应用程序（比如遗传算法和管道设计）中很有用。
+
+### 20 - J.U.C之Java并发容器：ConcurrentHashMap
+
+ConcurrentHashMap 作为 Concurrent 一族，其有着高效地并发操作。在1.8 版本以前，ConcurrentHashMap 采用`分段锁`的概念，使`锁更加细化`，但是 1.8 已经改变了这种思路，而是利用 `CAS + Synchronized` 来保证并发更新的安全，当然底层采用`数组+链表+红黑树`的存储结构。这篇博客带你彻底理解 ConcurrentHashMap。
+
+### 21 - J.U.C之ConcurrentHashMap红黑树转换分析
+
+在 1.8 ConcurrentHashMap 的put操作中，如果发现链表结构中的元素超过了TREEIFY_THRESHOLD（默认为8），则会把链表转换为`红黑树`，已便于提高查询效率。那么具体的转换过程是怎么样的？这篇博客给你答案。
+
+### 22 - J.U.C之Java并发容器：ConcurrentLinkedQueue
+
+ConcurrentLinkedQueue是一个基于链接节点的无边界的线程安全队列，它采用FIFO原则对元素进行排序。采用“wait-free”算法（即CAS算法）来实现的。
+
+CoucurrentLinkedQueue规定了如下几个不变性：
+
+在入队的最后一个元素的next为null
+队列中所有未删除的节点的item都不能为null且都能从head节点遍历到
+对于要删除的节点，不是直接将其设置为null，而是先将其item域设置为null（迭代器会跳过item为null的节点）
+允许head和tail更新滞后。这是什么意思呢？意思就说是head、tail不总是指向第一个元素和最后一个元素（后面阐述）。
+### 22 - J.U.C之Java并发容器：ConcurrentSkipListMap
+
+我们在Java世界里看到了两种实现key-value的数据结构：Hash、TreeMap，这两种数据结构各自都有着优缺点。
+
+Hash表：插入、查找最快，为O(1)；如使用链表实现则可实现无锁；数据有序化需要显式的排序操作。
+红黑树：插入、查找为O(logn)，但常数项较小；无锁实现的复杂性很高，一般需要加锁；数据天然有序。
+这里介绍第三种实现 key-value 的数据结构：SkipList。SkipList 有着不低于红黑树的效率，但是其原理和实现的复杂度要比红黑树简单多了。
+
+ConcurrentSkipListMap 其内部采用 SkipLis 数据结构实现。
+
+### 23 - J.U.C之阻塞队列：ArrayBlockingQueue
+
+ArrayBlockingQueue，一个由数组实现的有界阻塞队列。该队列采用FIFO的原则对元素进行排序添加的。
+
+ArrayBlockingQueue 为有界且固定，其大小在构造时由构造函数来决定，确认之后就不能再改变了。ArrayBlockingQueue 支持对等待的生产者线程和使用者线程进行排序的可选公平策略，但是在默认情况下不保证线程公平的访问，在构造时可以选择公平策略（fair = true）。公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。
+
+### 24 - J.U.C之阻塞队列：PriorityBlockingQueue
+
+PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采用自然顺序升序排序，当然我们也可以通过构造函数来指定Comparator来对元素进行排序。需要注意的是PriorityBlockingQueue不能保证同优先级元素的顺序。
+
+### 25 - J.U.C之阻塞队列：DelayQueue
+
+DelayQueue是一个支持延时获取元素的无界阻塞队列。里面的元素全部都是“可延期”的元素，列头的元素是最先“到期”的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。也就是说只有在延迟期到时才能够从队列中取元素。
+
+DelayQueue主要用于两个方面：
+
+缓存：清掉缓存中超时的缓存数据
+任务超时处理
+### 26 - J.U.C之阻塞队列：SynchronousQueue
+
+SynchronousQueue与其他BlockingQueue有着不同特性：
+
+SynchronousQueue没有容量。与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue。每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
+因为没有容量，所以对应 peek, contains, clear, isEmpty ... 等方法其实是无效的。例如clear是不执行任何操作的，contains始终返回false,peek始终返回null。
+SynchronousQueue分为公平和非公平，默认情况下采用非公平性访问策略，当然也可以通过构造函数来设置为公平性访问策略（为true即可）。
+若使用 TransferQueue, 则队列中永远会存在一个 dummy node（这点后面详细阐述）。
+SynchronousQueue非常适合做交换工作，生产者的线程和消费者的线程同步以传递某些信息、事件或者任务。
+
+### 27 - J.U.C之阻塞队列：LinkedTransferQueue
+
+LinkedTransferQueue 是基于链表的 FIFO 无界阻塞队列，它出现在 JDK7 中。Doug Lea 大神说 LinkedTransferQueue 是一个聪明的队列。它是 ConcurrentLinkedQueue、SynchronousQueue (公平模式下)、无界的LinkedBlockingQueues 等的超集。
+
+### 28 - J.U.C之阻塞队列：LinkedBlockingDeque
+
+LinkedBlockingDeque 是一个由链表组成的双向阻塞队列，双向队列就意味着可以从对头、对尾两端插入和移除元素，同样意味着 LinkedBlockingDeque 支持 FIFO、FILO 两种操作方式。
+
+LinkedBlockingDeque 是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为 Integer.MAX_VALUE。
+
+### 30 - 深入分析ThreadLocal
+
+ThreadLocal 提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。
+
+所以ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。
+
+### 31 - J.U.C之线程池：ThreadPoolExecutor
+
+鼎鼎大名的线程池。不需要多说!!!!!
+
+这篇博客深入分析 Java 中线程池的实现。
+
+### 32 - J.U.C之线程池：ScheduledThreadPoolExecutor
+
+ScheduledThreadPoolExecutor 是实现线程的周期、延迟调度的。
+
+ScheduledThreadPoolExecutor，继承 ThreadPoolExecutor 且实现了 ScheduledExecutorService 接口，它就相当于提供了“延迟”和“周期执行”功能的 ThreadPoolExecutor。在JDK API中是这样定义它的：ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求 ThreadPoolExecutor 具有额外的灵活性或功能时，此类要优于 Timer。 一旦启用已延迟的任务就执行它，但是有关何时启用，启用后何时执行则没有任何实时保证。按照提交的先进先出 (FIFO) 顺序来启用那些被安排在同一执行时间的任务。
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\267\261\345\205\245\345\211\226\346\236\220ThreadLocal.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\267\261\345\205\245\345\211\226\346\236\220ThreadLocal.md"
similarity index 96%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\267\261\345\205\245\345\211\226\346\236\220ThreadLocal.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\267\261\345\205\245\345\211\226\346\236\220ThreadLocal.md"
index 725a96e3..761e568f 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\267\261\345\205\245\345\211\226\346\236\220ThreadLocal.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\346\267\261\345\205\245\345\211\226\346\236\220ThreadLocal.md"	
@@ -1,44 +1,44 @@
-http://www.cnblogs.com/dolphin0520/p/3920407.html
-
-看源码
-
-例子
-
-总结：
-
-1）实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；
-
-2）为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量，就像上面代码中的longLocal和stringLocal；
-
-3）在进行get之前，必须先set，否则会报空指针异常；
-
-应用场景
-
- 用来解决 数据库连接、Session管理等。
-``` java
-private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
-	public Connection initialValue() {
-		return DriverManager.getConnection(DB_URL);
-	}
-};
-
-public static Connection getConnection() {
-	return connectionHolder.get();
-}
-
-
-private static final ThreadLocal threadSession = new ThreadLocal();
-
-public static Session getSession() throws InfrastructureException {
-    Session s = (Session) threadSession.get();
-    try {
-        if (s == null) {
-            s = getSessionFactory().openSession();
-            threadSession.set(s);
-        }
-    } catch (HibernateException ex) {
-        throw new InfrastructureException(ex);
-    }
-    return s;
-}
-```
+http://www.cnblogs.com/dolphin0520/p/3920407.html
+
+看源码
+
+例子
+
+总结：
+
+1）实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；
+
+2）为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量，就像上面代码中的longLocal和stringLocal；
+
+3）在进行get之前，必须先set，否则会报空指针异常；
+
+应用场景
+
+ 用来解决 数据库连接、Session管理等。
+``` java
+private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
+	public Connection initialValue() {
+		return DriverManager.getConnection(DB_URL);
+	}
+};
+
+public static Connection getConnection() {
+	return connectionHolder.get();
+}
+
+
+private static final ThreadLocal threadSession = new ThreadLocal();
+
+public static Session getSession() throws InfrastructureException {
+    Session s = (Session) threadSession.get();
+    try {
+        if (s == null) {
+            s = getSessionFactory().openSession();
+            threadSession.set(s);
+        }
+    } catch (HibernateException ex) {
+        throw new InfrastructureException(ex);
+    }
+    return s;
+}
+```
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/Executor\345\271\266\345\217\221\346\241\206\346\236\266.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/Executor\345\271\266\345\217\221\346\241\206\346\236\266.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/Executor\345\271\266\345\217\221\346\241\206\346\236\266.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/Executor\345\271\266\345\217\221\346\241\206\346\236\266.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/api.png" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/api.png"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/api.png"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/api.png"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\346\240\270\345\277\203\347\272\277\347\250\213\346\200\216\344\271\210\344\277\235\346\264\273.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\346\240\270\345\277\203\347\272\277\347\250\213\346\200\216\344\271\210\344\277\235\346\264\273.md"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\346\240\270\345\277\203\347\272\277\347\250\213\346\200\216\344\271\210\344\277\235\346\264\273.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\346\240\270\345\277\203\347\272\277\347\250\213\346\200\216\344\271\210\344\277\235\346\264\273.md"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240 ThreadPoolExecutor.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240 ThreadPoolExecutor.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240 ThreadPoolExecutor.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240 ThreadPoolExecutor.txt"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\346\267\273\345\212\240\344\273\273\345\212\241\350\277\207\347\250\213 - \346\216\247\345\210\266\346\234\200\345\244\247\345\271\266\345\217\221\346\225\260.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\346\267\273\345\212\240\344\273\273\345\212\241\350\277\207\347\250\213 - \346\216\247\345\210\266\346\234\200\345\244\247\345\271\266\345\217\221\346\225\260.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\346\267\273\345\212\240\344\273\273\345\212\241\350\277\207\347\250\213 - \346\216\247\345\210\266\346\234\200\345\244\247\345\271\266\345\217\221\346\225\260.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\346\267\273\345\212\240\344\273\273\345\212\241\350\277\207\347\250\213 - \346\216\247\345\210\266\346\234\200\345\244\247\345\271\266\345\217\221\346\225\260.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\207\240\347\247\215\346\226\271\345\274\217.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\207\240\347\247\215\346\226\271\345\274\217.txt"
similarity index 96%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\207\240\347\247\215\346\226\271\345\274\217.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\207\240\347\247\215\346\226\271\345\274\217.txt"
index ac4bb619..c5b0c1bd 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\207\240\347\247\215\346\226\271\345\274\217.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\207\240\347\247\215\346\226\271\345\274\217.txt"	
@@ -1,14 +1,14 @@
-SingleThreadExecutor 单个后台线程 (其缓冲队列是无界的)
-
-
-FixedThreadPool 只有核心线程的线程池,大小固定 (其缓冲队列是无界的) 。
-
-
-CachedThreadPool 无界线程池，可以进行自动线程回收。
-
-
-ScheduledThreadPool 核心线程池固定，大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
-
-
-
- 
+SingleThreadExecutor 单个后台线程 (其缓冲队列是无界的)
+
+
+FixedThreadPool 只有核心线程的线程池,大小固定 (其缓冲队列是无界的) 。
+
+
+CachedThreadPool 无界线程池，可以进行自动线程回收。
+
+
+ScheduledThreadPool 核心线程池固定，大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
+
+
+
+ 
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.txt"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.txt"
index 82c42cae..25aa7912 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\346\261\240/\347\272\277\347\250\213\346\261\240\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.txt"	
@@ -1,57 +1,57 @@
-http://blog.csdn.net/he90227/article/details/52576452#t1
-
-线程池的优点是可总结为以下三点：
-
-	1 线程复用
-	2 控制最大并发数
-	3 管理线程
-	
-1.线程复用过程
-
-	实现线程复用的原理应该就是要保持线程处于存活状态（就绪，运行或阻塞）。接下来来看下ThreadPoolExecutor是怎么实现线程复用的。
-	
-	在ThreadPoolExecutor主要Worker类来控制线程的复用。看下Worker类简化后的代码，这样方便理解：
-	
-	private final class Worker implements Runnable {
-
-		final Thread thread;
-
-		Runnable firstTask;
-
-		Worker(Runnable firstTask) {
-			this.firstTask = firstTask;
-			this.thread = getThreadFactory().newThread(this);
-		}
-
-		public void run() {
-			runWorker(this);
-		}
-
-		final void runWorker(Worker w) {
-			Runnable task = w.firstTask;
-			w.firstTask = null;
-			while (task != null || (task = getTask()) != null){
-			task.run();
-		}
-	}
-	
-	Worker是一个Runnable，同时拥有一个thread，这个thread就是要开启的线程，在新建Worker对象时同时新建一个Thread对象，
-	同时将Worker自己作为参数传入TThread，这样当Thread的start()方法调用时，运行的实际上是Worker的run()方法，接着到runWorker()中,
-	有个while循环，一直从getTask()里得到Runnable对象，顺序执行。getTask()又是怎么得到Runnable对象的呢？
-	
-	依旧是简化后的代码：
-	
-	private Runnable getTask() {
-		if(一些特殊情况) {
-			return null;
-		}
-
-		Runnable r = workQueue.take();
-
-		return r;
-	}
-	这个workQueue就是初始化ThreadPoolExecutor时存放任务的BlockingQueue队列，
-	这个队列里的存放的都是将要执行的Runnable任务。
-	因为BlockingQueue是个阻塞队列，BlockingQueue.take()得到如果是空，则进入等待状态直到BlockingQueue有新的对象被加入时唤醒阻塞的线程。
-	所以一般情况Thread的run()方法就不会结束,而是不断执行从workQueue里的Runnable任务，这就达到了线程复用的原理了。
+http://blog.csdn.net/he90227/article/details/52576452#t1
+
+线程池的优点是可总结为以下三点：
+
+	1 线程复用
+	2 控制最大并发数
+	3 管理线程
+	
+1.线程复用过程
+
+	实现线程复用的原理应该就是要保持线程处于存活状态（就绪，运行或阻塞）。接下来来看下ThreadPoolExecutor是怎么实现线程复用的。
+	
+	在ThreadPoolExecutor主要Worker类来控制线程的复用。看下Worker类简化后的代码，这样方便理解：
+	
+	private final class Worker implements Runnable {
+
+		final Thread thread;
+
+		Runnable firstTask;
+
+		Worker(Runnable firstTask) {
+			this.firstTask = firstTask;
+			this.thread = getThreadFactory().newThread(this);
+		}
+
+		public void run() {
+			runWorker(this);
+		}
+
+		final void runWorker(Worker w) {
+			Runnable task = w.firstTask;
+			w.firstTask = null;
+			while (task != null || (task = getTask()) != null){
+			task.run();
+		}
+	}
+	
+	Worker是一个Runnable，同时拥有一个thread，这个thread就是要开启的线程，在新建Worker对象时同时新建一个Thread对象，
+	同时将Worker自己作为参数传入TThread，这样当Thread的start()方法调用时，运行的实际上是Worker的run()方法，接着到runWorker()中,
+	有个while循环，一直从getTask()里得到Runnable对象，顺序执行。getTask()又是怎么得到Runnable对象的呢？
+	
+	依旧是简化后的代码：
+	
+	private Runnable getTask() {
+		if(一些特殊情况) {
+			return null;
+		}
+
+		Runnable r = workQueue.take();
+
+		return r;
+	}
+	这个workQueue就是初始化ThreadPoolExecutor时存放任务的BlockingQueue队列，
+	这个队列里的存放的都是将要执行的Runnable任务。
+	因为BlockingQueue是个阻塞队列，BlockingQueue.take()得到如果是空，则进入等待状态直到BlockingQueue有新的对象被加入时唤醒阻塞的线程。
+	所以一般情况Thread的run()方法就不会结束,而是不断执行从workQueue里的Runnable任务，这就达到了线程复用的原理了。
 	
\ No newline at end of file
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\224\237\345\221\275\345\221\250\346\234\237.jpg" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\224\237\345\221\275\345\221\250\346\234\237.jpg"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\224\237\345\221\275\345\221\250\346\234\237.jpg"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\224\237\345\221\275\345\221\250\346\234\237.jpg"
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\232\204\347\224\237\345\221\275\345\221\250\346\234\237.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\232\204\347\224\237\345\221\275\345\221\250\346\234\237.txt"
similarity index 99%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\232\204\347\224\237\345\221\275\345\221\250\346\234\237.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\232\204\347\224\237\345\221\275\345\221\250\346\234\237.txt"
index 52374392..85f98c4f 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\232\204\347\224\237\345\221\275\345\221\250\346\234\237.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\232\204\347\224\237\345\221\275\345\221\250\346\234\237.txt"	
@@ -1,6 +1,6 @@
-线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态。
-
-
-Thread通过new来新建一个线程，这个过程是是初始化一些线程信息，如线程名，id,线程所属group等，可以认为只是个普通的对象。调用Thread的start()后Java虚拟机会为其创建方法调用栈和程序计数器，同时将hasBeenStarted为true,之后调用start方法就会有异常。
-
+线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态。
+
+
+Thread通过new来新建一个线程，这个过程是是初始化一些线程信息，如线程名，id,线程所属group等，可以认为只是个普通的对象。调用Thread的start()后Java虚拟机会为其创建方法调用栈和程序计数器，同时将hasBeenStarted为true,之后调用start方法就会有异常。
+
 处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。当线程获取cpu后，run()方法会被调用。不要自己去调用Thread的run()方法。之后根据CPU的调度在就绪——运行——阻塞间切换，直到run()方法结束或其他方式停止线程，进入dead状态。
\ No newline at end of file
diff --git "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\233\270\345\205\263\347\232\204\345\255\246\344\271\240 \347\275\221\345\235\200.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\233\270\345\205\263\347\232\204\345\255\246\344\271\240 \347\275\221\345\235\200.txt"
similarity index 97%
rename from "02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\233\270\345\205\263\347\232\204\345\255\246\344\271\240 \347\275\221\345\235\200.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\233\270\345\205\263\347\232\204\345\255\246\344\271\240 \347\275\221\345\235\200.txt"
index 6b0ad0fd..3a1013c7 100644
--- "a/02 - Java-High-Ranking/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\233\270\345\205\263\347\232\204\345\255\246\344\271\240 \347\275\221\345\235\200.txt"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\244\232\347\272\277\347\250\213 \345\271\266\345\217\221/\347\272\277\347\250\213\347\233\270\345\205\263\347\232\204\345\255\246\344\271\240 \347\275\221\345\235\200.txt"	
@@ -1,2 +1,2 @@
-并发 编程网 http://ifeve.com/
-海子博客园 http://www.cnblogs.com/dolphin0520/
+并发 编程网 http://ifeve.com/
+海子博客园 http://www.cnblogs.com/dolphin0520/
diff --git "a/02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/Fastjson.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/Fastjson.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/Fastjson.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/Fastjson.txt"
diff --git "a/02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/Google\357\274\232Guava.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/Google\357\274\232Guava.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/Google\357\274\232Guava.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/Google\357\274\232Guava.txt"
diff --git "a/02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/jackson.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/jackson.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/jackson.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/jackson.txt"
diff --git "a/02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/\344\273\243\347\240\201\347\256\200\345\214\226\357\274\232lombok.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/\344\273\243\347\240\201\347\256\200\345\214\226\357\274\232lombok.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/\344\273\243\347\240\201\347\256\200\345\214\226\357\274\232lombok.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/\344\273\243\347\240\201\347\256\200\345\214\226\357\274\232lombok.txt"
diff --git "a/02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/\345\233\276\347\211\207\345\244\204\347\220\206\357\274\232Thumbnails.txt" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/\345\233\276\347\211\207\345\244\204\347\220\206\357\274\232Thumbnails.txt"
similarity index 100%
rename from "02 - Java-High-Ranking/\345\267\245\345\205\267\347\261\273/\345\233\276\347\211\207\345\244\204\347\220\206\357\274\232Thumbnails.txt"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\345\267\245\345\205\267\347\261\273/\345\233\276\347\211\207\345\244\204\347\220\206\357\274\232Thumbnails.txt"
diff --git "a/02 - Java-High-Ranking/\351\224\201/CAS ABA.md" "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\351\224\201/CAS ABA.md"
similarity index 98%
rename from "02 - Java-High-Ranking/\351\224\201/CAS ABA.md"
rename to "02 - Java-High-Ranking Java\351\253\230\347\272\247/\351\224\201/CAS ABA.md"
index 054d60c0..be4757a4 100644
--- "a/02 - Java-High-Ranking/\351\224\201/CAS ABA.md"	
+++ "b/02 - Java-High-Ranking Java\351\253\230\347\272\247/\351\224\201/CAS ABA.md"	
@@ -1,10 +1,10 @@
-
-乐观锁用到的机制就是CAS，Compare and Swap
-CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。
-  当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
-
-
-线程1准备用CAS将变量的值由A替换为B，
-在此之前，
-线程2将变量的值由A替换为C，又由C替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。
-但实际上 **这时的现场** 已经和 **最初不同** 了，尽管CAS成功，但可能存在潜藏的问题，
+
+乐观锁用到的机制就是CAS，Compare and Swap
+CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。
+  当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
+
+
+线程1准备用CAS将变量的值由A替换为B，
+在此之前，
+线程2将变量的值由A替换为C，又由C替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。
+但实际上 **这时的现场** 已经和 **最初不同** 了，尽管CAS成功，但可能存在潜藏的问题，
diff --git "a/03 - Framework \346\241\206\346\236\266/Spring StateMachine\347\212\266\346\200\201\346\234\272.md" "b/03 - Framework \346\241\206\346\236\266/Spring StateMachine\347\212\266\346\200\201\346\234\272.md"
new file mode 100644
index 00000000..d6a761e8
--- /dev/null
+++ "b/03 - Framework \346\241\206\346\236\266/Spring StateMachine\347\212\266\346\200\201\346\234\272.md"	
@@ -0,0 +1,65 @@
+# 什么是状态机：
+
+就是一组状态，各个状态之间，依据一定的条件（如输入一个  1  或者是  0），存在一定的转换，（从状态X转换到状态Y）它有一个起始状态和若干终结状态，从起始状态开始，根据输入的串转换状态，直到所有的输入的被状态机处理，看看追最后停留的状态是否为终结状态，是的话就说这个串符合这个状态机规则，或者说被这个状态机接受！
+流程可能是瞬间的动作经历很多步骤，比如“登录”流程，点击“登录”按钮之后，会有验证帐号、密码、验证码的诸多流程，但是都是在点击登录按钮的瞬间，逐一完成。
+而状态机表示的都是一个已经完成的状态，每一个环节都是可以独立存在的。
+
+有限状态机是一种用来进行对象行为建模的工具，其作用主要是描述 **对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件**。
+在
+电商场景（订单、物流、售后）、
+社交（IM消息投递）、
+分布式集群管理（分布式计算平台任务编排）等场景都有大规模的使用。
+
+状态机的要素
+状态机可归纳为4个要素，即现态、条件、动作、次态。“现态”和“条件”是因，“动作”和“次态”是果。详解如下：
+* 现态：是指当前所处的状态。
+* 条件：又称为“事件”。当一个条件被满足，将会触发一个动作，或者执行一次状态的迁移。
+* 动作：条件满足后执行的动作。动作执行完毕后，可以迁移到新的状态，也可以仍旧保持原状态。动作不是必需的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。
+* 次态：条件满足后要迁往的新状态。“次态”是相对于“现态”而言的，“次态”一旦被激活，就转变成新的“现态”了。
+
+状态机动作类型
+进入动作（entry action）：在进入状态时进行
+退出动作：在退出状态时进行
+输入动作：依赖于当前状态和输入条件进行
+转移动作：在进行特定转移时进行
+
+有限状态机是一种对象行为建模工具，适用对象有一个明确并且复杂的生命流（一般而言三个以上状态），并且在状态变迁存在不同的触发条件以及处理行为。
+从我个人的使用经验上，使用状态机来管理对象生命流的好处更多体现在代码的可维护性、可测试性上，明确的状态条件、原子的响应动作、事件驱动迁移目标状态，对于流程复杂易变的业务场景能大大减轻维护和测试的难度。
+
+```java
+public enum States {
+	  UNPAID,                 // 待支付
+    WAITING_FOR_RECEIVE,    // 待收货
+    DONE                    // 结束
+}
+
+public enum Events {
+	  PAY,        // 支付
+    RECEIVE     // 收货
+}
+```
+其中共有三个状态（待支付、待收货、结束）以及两个引起状态迁移的事件（支付、收货），
+其中支付事件PAY会触发状态从待支付UNPAID状态到待收货WAITING_FOR_RECEIVE状态的迁移，
+而收货事件RECEIVE会触发状态从待收货WAITING_FOR_RECEIVE状态到结束DONE状态的迁移。
+
+
+* 定义状态和事件枚举
+* 为状态机定义使用的所有状态以及初始状态
+* 为状态机定义状态的迁移动作
+* 为状态机指定监听处理器
+
+
+
+1. 易于使用的扁平单级状态机，用于简单的使用案例。
+2. 分层状态机结构，以简化复杂的状态配置。
+3. 状态机区域提供更复杂的状态配置。
+4. 使用触发器，转换，警卫和操作。
+5. 键入安全配置适配器。
+6. 生成器模式，用于在Spring Application上下文之外使用的简单实例化通常用例的食谱
+7. 基于Zookeeper的分布式状态机
+8. 状态机事件监听器。
+9. UML Eclipse Papyrus建模。
+10. 将计算机配置存储在永久存储中。
+11. Spring IOC集成将bean与状态机关联起来。
+
+状态机引擎选型 https://segmentfault.com/a/1190000009906317
diff --git "a/03 - Framework \346\241\206\346\236\266/SpringBatch\346\211\271\345\244\204\347\220\206.md" "b/03 - Framework \346\241\206\346\236\266/SpringBatch\346\211\271\345\244\204\347\220\206.md"
new file mode 100644
index 00000000..872d8a4e
--- /dev/null
+++ "b/03 - Framework \346\241\206\346\236\266/SpringBatch\346\211\271\345\244\204\347\220\206.md"	
@@ -0,0 +1,57 @@
+http://www.importnew.com/26177.html
+批处理是一种处理模式，它涉及一系列自动复杂作业的执行而无需用户交互。批处理过程处理批量数据并运行很长时间。
+一些企业应用程序需要处理大量数据来执行操作，涉及
+* 基于时间的事件，如周期性计算。
+* 在大型数据集上重复处理的定期应用程序。
+* 处理和验证交易方式中可用数据的应用程序。
+因此，批处理在企业应用程序中用于执行此类事务。
+
+在大型的企业应用中，或多或少都会存在大量的任务需要处理，如邮件批量通知所有将要过期的会员等等。
+而在批量处理任务的过程中，又需要注意很多细节，如任务异常、性能瓶颈等等。那么，使用一款优秀的框架总比我们自己重复地造轮子要好得多一些。
+我所在的物联网云平台部门就有这么一个需求，需要实现批量下发命令给百万设备。为了防止枯燥乏味，下面就让我们先通过Spring Batch框架简单地实现一下这个功能，再来详细地介绍这款框架！
+
+
+# 什么是Spring批处理
+Spring批处理是一个轻量级框架，用于开发在企业应用程序中使用的批处理应用程序。
+除了批量处理外，该框架还提供以下功能
+* 包括日志和跟踪
+* 交易管理
+* 作业处理统计
+* 作业重启
+* 跳过和资源管理
+* 您还可以使用其分割技术缩放弹簧批量应用程序。
+
+# Spring Batch的特点
+以下是Spring Batch的显着特点 -
+灵活性 - Spring批处理应用程序非常灵活。您只需更改XML文件即可更改应用程序中的处理顺序。
+可维护性 - Spring批量应用程序易于维护。Spring Batch作业包括步骤，每个步骤都可以进行分离，测试和更新，而不影响其他步骤。
+可伸缩性 - 使用分区技术，您可以缩放Spring Batch应用程序。这些技术可以让你 -
+  并行执行作业的步骤。
+  并行执行单个线程。
+可靠性 - 如果发生任何故障，您可以通过将步骤分离，从完全停止的地方重新开始工作。
+支持多种文件格式 - Spring Batch为XML，Flat文件，CSV，MYSQL，Hibernate，JDBC，Mongo，Neo4j等大量读者和作者提供支持。
+多种启动作业的方式 - 您可以使用Web应用程序，Java程序，命令行等来启动Spring Batch作业。
+
+除此之外，Spring Batch应用程序支持 -
+* 失败后自动重试。
+* 跟踪批次执行过程中和完成批次处理后的状态和统计数据。
+* 运行并行作业。
+* 诸如日志记录，资源管理，跳过和重新启动处理等服务。
+
+SpringBatch 是一个大数据量的并行处理框架。通常用于数据的离线迁移，和数据处理，⽀持事务、并发、流程、监控、纵向和横向扩展，提供统⼀的接⼝管理和任务管理;SpringBatch是SpringSource和埃森哲为了统一业界并行处理标准为广大开发者提供方便开发的一套框架。
+
+官方地址：https://github.com/spring-projects/spring-batch
+
+* SpringBatch 本身提供了重试，异常处理，跳过，重启、任务处理统计，资源管理等特性，这些特性开发者看重他的主要原因;
+* SpringBatch 是一个轻量级的批处理框架;
+* SpringBatch 结构分层，业务与处理策略、结构分离;
+* 任务的运行的实例状态，执行数据，参数都会落地到数据库;
+
+# Spring Batch的分层架构
+* Insfrastructure 策略管理：包括任务的失败重试，异常处理,事务，skip,以及数据的输入输出（文本文件，DB，Message）,此组件包含应用程序和批处理核心组件使用的读取器，编写器和服务。
+* Core: springBatch 的核心，包括JobLauch,job,step等等,该组件包含控制和启动批作业所需的所有API类。
+* Application: 业务处理，创建任务，决定任务的执行方式（定时任务，手动触发等）
+
+在Spring Batch框架中，一个任务Job由一个或者多个步骤Step，而步骤又由读操作Reader、处理操作Processor、写操作Writer组成
+
+读操作需要实现ItemReader<T>接口，框架提供了一个现成的实现类FlatFileItemReader。使用该类需要设置Resource和LineMapper。Resource代表着数据源，即我们的batch-data.csv文件；LineMapper则表示如何将文件的每行数据转成对应的DTO对象。
diff --git a/03 - Framework/Velocity/all.md "b/03 - Framework \346\241\206\346\236\266/Velocity/all.md"
similarity index 100%
rename from 03 - Framework/Velocity/all.md
rename to "03 - Framework \346\241\206\346\236\266/Velocity/all.md"
diff --git "a/03 - Framework/Velocity/velocity1.6.1 \345\271\266\345\217\221\351\227\256\351\242\230.md" "b/03 - Framework \346\241\206\346\236\266/Velocity/velocity1.6.1 \345\271\266\345\217\221\351\227\256\351\242\230.md"
similarity index 100%
rename from "03 - Framework/Velocity/velocity1.6.1 \345\271\266\345\217\221\351\227\256\351\242\230.md"
rename to "03 - Framework \346\241\206\346\236\266/Velocity/velocity1.6.1 \345\271\266\345\217\221\351\227\256\351\242\230.md"
diff --git a/03 - Framework/Web/Filter.txt "b/03 - Framework \346\241\206\346\236\266/Web/Filter.txt"
similarity index 100%
rename from 03 - Framework/Web/Filter.txt
rename to "03 - Framework \346\241\206\346\236\266/Web/Filter.txt"
diff --git a/03 - Framework/Web/Handler.txt "b/03 - Framework \346\241\206\346\236\266/Web/Handler.txt"
similarity index 100%
rename from 03 - Framework/Web/Handler.txt
rename to "03 - Framework \346\241\206\346\236\266/Web/Handler.txt"
diff --git a/03 - Framework/Web/ServletContextListener.txt "b/03 - Framework \346\241\206\346\236\266/Web/ServletContextListener.txt"
similarity index 100%
rename from 03 - Framework/Web/ServletContextListener.txt
rename to "03 - Framework \346\241\206\346\236\266/Web/ServletContextListener.txt"
diff --git "a/03 - Framework/Web/filter\343\200\201Listener\343\200\201interceptor\345\260\217\347\273\223.txt" "b/03 - Framework \346\241\206\346\236\266/Web/filter\343\200\201Listener\343\200\201interceptor\345\260\217\347\273\223.txt"
similarity index 100%
rename from "03 - Framework/Web/filter\343\200\201Listener\343\200\201interceptor\345\260\217\347\273\223.txt"
rename to "03 - Framework \346\241\206\346\236\266/Web/filter\343\200\201Listener\343\200\201interceptor\345\260\217\347\273\223.txt"
diff --git "a/03 - Framework/Web/jsp\345\233\233\345\244\247\344\275\234\347\224\250\345\237\237.md" "b/03 - Framework \346\241\206\346\236\266/Web/jsp\345\233\233\345\244\247\344\275\234\347\224\250\345\237\237.md"
similarity index 100%
rename from "03 - Framework/Web/jsp\345\233\233\345\244\247\344\275\234\347\224\250\345\237\237.md"
rename to "03 - Framework \346\241\206\346\236\266/Web/jsp\345\233\233\345\244\247\344\275\234\347\224\250\345\237\237.md"
diff --git a/03 - Framework/Web/listener.txt "b/03 - Framework \346\241\206\346\236\266/Web/listener.txt"
similarity index 100%
rename from 03 - Framework/Web/listener.txt
rename to "03 - Framework \346\241\206\346\236\266/Web/listener.txt"
diff --git "a/03 - Framework/Web/servler\347\224\237\345\221\275\345\221\250\346\234\237.md" "b/03 - Framework \346\241\206\346\236\266/Web/servler\347\224\237\345\221\275\345\221\250\346\234\237.md"
similarity index 100%
rename from "03 - Framework/Web/servler\347\224\237\345\221\275\345\221\250\346\234\237.md"
rename to "03 - Framework \346\241\206\346\236\266/Web/servler\347\224\237\345\221\275\345\221\250\346\234\237.md"
diff --git "a/03 - Framework/Web/web.xml \347\232\204\345\212\240\350\275\275\351\241\272\345\272\217\346\230\257\357\274\232context- param - listener - filter - servlet .txt" "b/03 - Framework \346\241\206\346\236\266/Web/web.xml \347\232\204\345\212\240\350\275\275\351\241\272\345\272\217\346\230\257\357\274\232context- param - listener - filter - servlet .txt"
similarity index 100%
rename from "03 - Framework/Web/web.xml \347\232\204\345\212\240\350\275\275\351\241\272\345\272\217\346\230\257\357\274\232context- param - listener - filter - servlet .txt"
rename to "03 - Framework \346\241\206\346\236\266/Web/web.xml \347\232\204\345\212\240\350\275\275\351\241\272\345\272\217\346\230\257\357\274\232context- param - listener - filter - servlet .txt"
diff --git "a/03 - Framework/hibernate/Hibernate-\346\265\213\350\257\225\351\242\230.doc" "b/03 - Framework \346\241\206\346\236\266/hibernate/Hibernate-\346\265\213\350\257\225\351\242\230.doc"
similarity index 100%
rename from "03 - Framework/hibernate/Hibernate-\346\265\213\350\257\225\351\242\230.doc"
rename to "03 - Framework \346\241\206\346\236\266/hibernate/Hibernate-\346\265\213\350\257\225\351\242\230.doc"
diff --git a/03 - Framework/hibernate/hibernate.md "b/03 - Framework \346\241\206\346\236\266/hibernate/hibernate.md"
similarity index 100%
rename from 03 - Framework/hibernate/hibernate.md
rename to "03 - Framework \346\241\206\346\236\266/hibernate/hibernate.md"
diff --git "a/03 - Framework \346\241\206\346\236\266/mybatis/JPA \345\222\214 Mybatis \345\246\202\344\275\225\350\277\233\350\241\214\346\212\200\346\234\257\351\200\211\345\236\213\357\274\237.md" "b/03 - Framework \346\241\206\346\236\266/mybatis/JPA \345\222\214 Mybatis \345\246\202\344\275\225\350\277\233\350\241\214\346\212\200\346\234\257\351\200\211\345\236\213\357\274\237.md"
new file mode 100644
index 00000000..352841d3
--- /dev/null
+++ "b/03 - Framework \346\241\206\346\236\266/mybatis/JPA \345\222\214 Mybatis \345\246\202\344\275\225\350\277\233\350\241\214\346\212\200\346\234\257\351\200\211\345\236\213\357\274\237.md"	
@@ -0,0 +1,58 @@
+from https://mp.weixin.qq.com/s/yHQJff9cMXYKy_wK68qfCA
+
+在我们平时的项目中，大家都知道可以使用 JPA 或者 Mybatis 作为 ORM 层。对 JPA 和 Mybatis 如何进行技术选型？
+
+下面看看大精华总结如下：
+
+### 最佳回答
+首先表达个人观点，JPA必然是首选的。
+个人认为仅仅讨论两者使用起来有何区别，何者更加方便，不足以真正的比较这两个框架。要评判出更加优秀的方案，我觉得可以从软件设计的角度来评判。
+个人对 mybatis 并不熟悉，但 JPA 规范和 springdata 的实现，设计理念绝对是超前的。
+软件开发复杂性的一个解决手段是遵循 DDD（DDD 只是一种手段，但不是唯一手段），而我着重几点来聊聊 JPA 的设计中是如何体现领域驱动设计思想的，抛砖引玉。
+
+### 聚合根和值对象
+领域驱动设计中有两个广为大家熟知的概念，entity（实体）和 value object（值对象）。
+entity 的特点是具有生命周期的，有标识的，而值对象是起到一个修饰的作用，其具有不可变性，无标识。
+在 JPA中 ，需要为数据库的实体类添加 @Entity 注解，相信大家也注意到了，这并不是巧合。
+```java
+public class Order {
+
+    @Id
+    private String oid;
+
+    @Embedded
+    private CustomerVo customer;
+
+    @OneToMany(cascade = {CascadeType.ALL},orphanRemoval = true, fetch = FetchType.LAZY, mappedBy = "order")
+    private List < OrderItem > orderItems;
+}
+```
+如上述的代码，Order 便是 DDD 中的实体，而 CustomerVo，OrderItem 则是值对象。
+程序设计者无需关心数据库如何映射这些字段，因为在 DDD 中，需要做的工作是领域建模，而不是数据建模。
+实体和值对象的意义不在此展开讨论，但通过此可以初见端倪，JPA 的内涵绝不仅仅是一个 ORM 框架。
+
+### 仓储
+Repository 模式是领域驱动设计中另一个经典的模式。在早期，我们常常将数据访问层命名为：DAO，而在 SpringData JPA 中，其称之为 Repository（仓储），这也不是巧合，而是设计者有意为之。
+熟悉 SpringData JPA 的朋友都知道当一个接口继承 JpaRepository 接口之后便自动具备了 一系列常用的数据操作方法，findAll， findOne ，save等。
+...
+那么仓储和DAO到底有什么区别呢？这就要提到一些遗留问题，以及一些软件设计方面的因素。在这次SpringForAll 的议题中我能够预想到有很多会强调 SpringData JPA 具有方便可扩展的 API，像下面这样：
+...
+但我要强调的是，这是 SpringData JPA 的妥协，其支持这一特性，并不代表其建议使用。因为这并不符合领域驱动设计的理念。注意对比，SpringData JPA 的设计理念是将 Repository 作为数据仓库，而不是一系列数据库脚本的集合，findByOrderNoAndXxxx 方法可以由下面一节要提到的JpaSpecificationExecutor代替，而 updateOrderStatusById 方法则可以由 findOne + save 代替，不要觉得这变得复杂了，试想一下真正的业务场景，修改操作一般不会只涉及一个字段的修改， findOne + save 可以帮助你完成更加复杂业务操作，而不必关心我们该如何编写 SQL 语句，真正做到了面向领域开发，而不是面向数据库 SQL 开发，面向对象的拥趸者也必然会觉得，这更加的 OO。
+
+### Specification
+上面提到 SpringData JPA 可以借助 Specification 模式代替复杂的 findByOrderNoAndXxxx 一类 SQL 脚本的查询。试想一下，业务不停在变，你怎么知道将来的查询会不会多一个条件 变成 findByOrderNoAndXxxxAndXxxxAndXxxx.... 。SpringData JPA 为了实现领域驱动设计中的 Specification 模式，提供了一些列的 Specification 接口，其中最常用的便是 ：JpaSpecificationExecutor
+...
+使用 SpringData JPA 构建复杂查询（join操作，聚集操作等等）都是依赖于 JpaSpecificationExecutor 构建的 Specification 。例子就不介绍，有点长。
+
+请注意，上述代码并不是一个例子，在真正遵循 DDD 设计规范的系统中，OrderRepository 接口中就应该是干干净净的，没有任何代码，只需要继承 JpaRepository （负责基础CRUD）以及 JpaSpecificationExecutor （负责Specification 查询）即可。当然， SpringData JPA 也提供了其他一系列的接口，根据特定业务场景继承即可。
+
+### 乐观锁
+为了解决数据并发问题，JPA 中提供了 @Version ，一般在 Entity 中 添加一个 Long version 字段，配合 @Version 注解，SpringData JPA 也考虑到了这一点。这一点侧面体现出，JPA 设计的理念和 SpringData 作为一个工程解决方案的双剑合璧，造就出了一个伟大的设计方案。
+
+### 复杂的多表查询
+很多人青睐 Mybatis ，原因是其提供了便利的 SQL 操作，自由度高，封装性好……SpringData JPA对复杂 SQL 的支持不好，没有实体关联的两个表要做 join ，的确要花不少功夫。但 SpringData JPA 并不把这个当做一个问题。为什么？因为现代微服务的架构，各个服务之间的数据库是隔离的，跨越很多张表的 join 操作本就不应该交给单一的业务数据库去完成。解决方案是：使用 elasticSearch做视图查询 或者 mongodb 一类的Nosql 去完成。问题本不是问题。
+
+### 总结
+真正走进 JPA，真正走进 SpringData 会发现，我们并不是在解决一个数据库查询问题，并不是在使用一个 ORM 框架，而是真正地在实践领域驱动设计。
+
+（再次补充：DDD 只是一种手段，但不是唯一手段）
diff --git a/03 - Framework/mybatis/README.md "b/03 - Framework \346\241\206\346\236\266/mybatis/README.md"
similarity index 96%
rename from 03 - Framework/mybatis/README.md
rename to "03 - Framework \346\241\206\346\236\266/mybatis/README.md"
index 98240531..8db9761a 100644
--- a/03 - Framework/mybatis/README.md	
+++ "b/03 - Framework \346\241\206\346\236\266/mybatis/README.md"	
@@ -1,7 +1,7 @@
-代码自动生成器
-MyBatis关联查询、嵌套查询
-缓存使用场景及选择策略
-Spring集成下的SqlSession
-Mapper Mybatis的事务
-分析Mybatis的动态代理的真正实现
-手写实现Mini版的Mybatis
+代码自动生成器
+MyBatis关联查询、嵌套查询
+缓存使用场景及选择策略
+Spring集成下的SqlSession
+Mapper Mybatis的事务
+分析Mybatis的动态代理的真正实现
+手写实现Mini版的Mybatis
diff --git "a/03 - Framework/mybatis/\345\270\270\347\224\250\346\240\207\347\255\276.md" "b/03 - Framework \346\241\206\346\236\266/mybatis/\345\270\270\347\224\250\346\240\207\347\255\276.md"
similarity index 100%
rename from "03 - Framework/mybatis/\345\270\270\347\224\250\346\240\207\347\255\276.md"
rename to "03 - Framework \346\241\206\346\236\266/mybatis/\345\270\270\347\224\250\346\240\207\347\255\276.md"
diff --git a/03 - Framework/shiro/Shiro_Session.md "b/03 - Framework \346\241\206\346\236\266/shiro/Shiro_Session.md"
similarity index 100%
rename from 03 - Framework/shiro/Shiro_Session.md
rename to "03 - Framework \346\241\206\346\236\266/shiro/Shiro_Session.md"
diff --git "a/03 - Framework/shiro/shiro cas\345\215\225\347\202\271\347\231\273\345\275\225.txt" "b/03 - Framework \346\241\206\346\236\266/shiro/shiro cas\345\215\225\347\202\271\347\231\273\345\275\225.txt"
similarity index 95%
rename from "03 - Framework/shiro/shiro cas\345\215\225\347\202\271\347\231\273\345\275\225.txt"
rename to "03 - Framework \346\241\206\346\236\266/shiro/shiro cas\345\215\225\347\202\271\347\231\273\345\275\225.txt"
index 468e1f61..38b5b8d2 100644
--- "a/03 - Framework/shiro/shiro cas\345\215\225\347\202\271\347\231\273\345\275\225.txt"	
+++ "b/03 - Framework \346\241\206\346\236\266/shiro/shiro cas\345\215\225\347\202\271\347\231\273\345\275\225.txt"	
@@ -1,6 +1,6 @@
-https://www.cnblogs.com/coderhuang/p/5897444.html
-介绍
-
-
-项目地址：
+https://www.cnblogs.com/coderhuang/p/5897444.html
+介绍
+
+
+项目地址：
 https://github.com/coder-huang/sso-shiro-cas
\ No newline at end of file
diff --git "a/03 - Framework/shiro/shiro10min\344\273\213\347\273\215.md" "b/03 - Framework \346\241\206\346\236\266/shiro/shiro10min\344\273\213\347\273\215.md"
similarity index 99%
rename from "03 - Framework/shiro/shiro10min\344\273\213\347\273\215.md"
rename to "03 - Framework \346\241\206\346\236\266/shiro/shiro10min\344\273\213\347\273\215.md"
index 33266c29..e36f7e3b 100644
--- "a/03 - Framework/shiro/shiro10min\344\273\213\347\273\215.md"	
+++ "b/03 - Framework \346\241\206\346\236\266/shiro/shiro10min\344\273\213\347\273\215.md"	
@@ -1,43 +1,43 @@
-介绍
-
-欢迎到Apache Shiro的10分钟tutoral！
-通过快速和简单的教程，你应该充分了解开发商在应用中使用Shiro。你应该能在10分钟内完成。
-
-概述
-Apache Shiro是什么？
-Apache Shiro是一个功能强大且易于使用的java安全框架，为开发人员提供一个直观而全面的认证、授权、加密解决方案，和会话管理。
-实际上，它实现了对应用程序安全性的所有方面的管理，同时尽可能地避开了。它建立在良好的接口驱动设计和OO原则的基础上，在您可以想象的地方启用自定义行为。但对所有的东西都有合理的默认值，这就像应用程序的安全性一样“不受欢迎”。至少这是我们奋斗的目标。
-Apache Shiro能做什么？
-很多.但是我们不想膨胀快速入门。请检查我们的功能页，如果你想看看它能为你做什么。另外，如果你好奇我们如何开始，为什么我们存在，请看Shiro的历史使命页。
-好啊.现在让我们实际做点什么！
-注
-Shiro可以在任何环境下运行，从最简单的命令行应用程序最大的企业网络和集群应用程序，但我们会使用尽可能简单的例子，一个简单的`主要`方法快速入门，你可以得到一个API的感觉。
-下载
-确保你的JDK 1.6 +和Maven 3.0.3 +安装。
-从下载页面下载最新的“源代码分发”。在这个例子中，我们使用1.3.2发布。
-解压源码包：
-解压shiro-root-1.3.2-source-release.zip美元
-进入快速入门指南：
-$ cd shiro-root-1.3.2/samples/quickstart
-运行快速入门：
-$ mvn compile exec：java
-这个目标只会打印出一些日志消息，让你知道发生了什么，然后退出。在阅读本快速入门，随时查看代码样本/快速/ SRC /主/ java / quickstart.java下发现。改变文件和运行以上mvn compile java命令执行：只要你喜欢。
-quickstart.java
-上面提到的quickstart.java文件包含所有代码会让你熟悉API。现在我们把它分解成块，这样你就可以很容易地理解发生了什么。
-在几乎所有的环境中，您都可以通过以下调用获得当前执行的用户：
-课题中securityutils getsubject() =；
-使用securityutils。getsubject()，我们可以获得当前执行的主体。主题只是应用程序用户的特定于安全的“视图”。实际上我们想把它称为“用户”，因为它“有意义”，但是我们决定不做它：太多的应用程序已经有已经有自己的用户类/框架的现有API，我们不想与那些冲突。此外，在安全领域中，术语实际上是公认的术语。好，继续前进…
-在一个独立的应用程序的getsubject()调用会返回一个基于应用程序中的特定位置的用户数据，并在服务器环境（例如Web应用程序），它获得的主题基于用户数据与当前线程的请求。
-既然你有了一个主题，你能用它做什么？
-如果您希望在应用程序的当前会话中为用户提供可用的东西，您可以获得他们的会话：
-会话的会话中getsession() =；
-会话。setAttribute（“关键”、“价值”）；
-会话是一个具体的例子，Shiro提供了大部分你用常规httpsessions但一些额外的好东西，一个很大的不同：它不需要一个HTTP环境！
-如果部署在Web应用程序中，默认情况下，会话将HttpSession的基础。但是，在非网络环境下，像这样的简单入门，Shiro将自动使用默认的企业会议管理。这意味着您可以在应用程序中在任何层中使用相同的API，而不管部署环境如何。这将打开一个新世界以来，整个应用程序的任何应用程序需要的会话不需要被迫使用HttpSession或EJB有状态会话bean。而且，任何客户机技术都可以共享会话数据。
-现在你可以获得一个主题和他们的会话。真正有用的东西是什么，比如检查它们是否允许做事情，比如检查角色和权限？
-我们只能为已知的用户做那些检查。上面的主体实例代表当前用户，但当前用户是谁？嗯，他们是匿名的，也就是说，至少在他们登录一次之前。所以，让我们这样做：
-如果（！中。isauthenticated()）{
-/以GUI特定的方式收集用户主体和凭据
-/ /如用户名/密码的HTML表单，X509证书，OpenID，等。
-/我们将使用这里的用户名/密码示例，因为它是最常见的。
-/（你做吗？）
+介绍
+
+欢迎到Apache Shiro的10分钟tutoral！
+通过快速和简单的教程，你应该充分了解开发商在应用中使用Shiro。你应该能在10分钟内完成。
+
+概述
+Apache Shiro是什么？
+Apache Shiro是一个功能强大且易于使用的java安全框架，为开发人员提供一个直观而全面的认证、授权、加密解决方案，和会话管理。
+实际上，它实现了对应用程序安全性的所有方面的管理，同时尽可能地避开了。它建立在良好的接口驱动设计和OO原则的基础上，在您可以想象的地方启用自定义行为。但对所有的东西都有合理的默认值，这就像应用程序的安全性一样“不受欢迎”。至少这是我们奋斗的目标。
+Apache Shiro能做什么？
+很多.但是我们不想膨胀快速入门。请检查我们的功能页，如果你想看看它能为你做什么。另外，如果你好奇我们如何开始，为什么我们存在，请看Shiro的历史使命页。
+好啊.现在让我们实际做点什么！
+注
+Shiro可以在任何环境下运行，从最简单的命令行应用程序最大的企业网络和集群应用程序，但我们会使用尽可能简单的例子，一个简单的`主要`方法快速入门，你可以得到一个API的感觉。
+下载
+确保你的JDK 1.6 +和Maven 3.0.3 +安装。
+从下载页面下载最新的“源代码分发”。在这个例子中，我们使用1.3.2发布。
+解压源码包：
+解压shiro-root-1.3.2-source-release.zip美元
+进入快速入门指南：
+$ cd shiro-root-1.3.2/samples/quickstart
+运行快速入门：
+$ mvn compile exec：java
+这个目标只会打印出一些日志消息，让你知道发生了什么，然后退出。在阅读本快速入门，随时查看代码样本/快速/ SRC /主/ java / quickstart.java下发现。改变文件和运行以上mvn compile java命令执行：只要你喜欢。
+quickstart.java
+上面提到的quickstart.java文件包含所有代码会让你熟悉API。现在我们把它分解成块，这样你就可以很容易地理解发生了什么。
+在几乎所有的环境中，您都可以通过以下调用获得当前执行的用户：
+课题中securityutils getsubject() =；
+使用securityutils。getsubject()，我们可以获得当前执行的主体。主题只是应用程序用户的特定于安全的“视图”。实际上我们想把它称为“用户”，因为它“有意义”，但是我们决定不做它：太多的应用程序已经有已经有自己的用户类/框架的现有API，我们不想与那些冲突。此外，在安全领域中，术语实际上是公认的术语。好，继续前进…
+在一个独立的应用程序的getsubject()调用会返回一个基于应用程序中的特定位置的用户数据，并在服务器环境（例如Web应用程序），它获得的主题基于用户数据与当前线程的请求。
+既然你有了一个主题，你能用它做什么？
+如果您希望在应用程序的当前会话中为用户提供可用的东西，您可以获得他们的会话：
+会话的会话中getsession() =；
+会话。setAttribute（“关键”、“价值”）；
+会话是一个具体的例子，Shiro提供了大部分你用常规httpsessions但一些额外的好东西，一个很大的不同：它不需要一个HTTP环境！
+如果部署在Web应用程序中，默认情况下，会话将HttpSession的基础。但是，在非网络环境下，像这样的简单入门，Shiro将自动使用默认的企业会议管理。这意味着您可以在应用程序中在任何层中使用相同的API，而不管部署环境如何。这将打开一个新世界以来，整个应用程序的任何应用程序需要的会话不需要被迫使用HttpSession或EJB有状态会话bean。而且，任何客户机技术都可以共享会话数据。
+现在你可以获得一个主题和他们的会话。真正有用的东西是什么，比如检查它们是否允许做事情，比如检查角色和权限？
+我们只能为已知的用户做那些检查。上面的主体实例代表当前用户，但当前用户是谁？嗯，他们是匿名的，也就是说，至少在他们登录一次之前。所以，让我们这样做：
+如果（！中。isauthenticated()）{
+/以GUI特定的方式收集用户主体和凭据
+/ /如用户名/密码的HTML表单，X509证书，OpenID，等。
+/我们将使用这里的用户名/密码示例，因为它是最常见的。
+/（你做吗？）
diff --git "a/03 - Framework/spring&springboot\347\237\245\350\257\206\347\202\271.md" "b/03 - Framework \346\241\206\346\236\266/spring&springboot\347\237\245\350\257\206\347\202\271.md"
similarity index 100%
rename from "03 - Framework/spring&springboot\347\237\245\350\257\206\347\202\271.md"
rename to "03 - Framework \346\241\206\346\236\266/spring&springboot\347\237\245\350\257\206\347\202\271.md"
diff --git a/03 - Framework/spring/@Aspect.md "b/03 - Framework \346\241\206\346\236\266/spring/@Aspect.md"
similarity index 98%
rename from 03 - Framework/spring/@Aspect.md
rename to "03 - Framework \346\241\206\346\236\266/spring/@Aspect.md"
index 39eb3399..f1d7110d 100644
--- a/03 - Framework/spring/@Aspect.md	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/@Aspect.md"	
@@ -1,35 +1,35 @@
-http://blog.csdn.net/jobjava/article/details/44063427
-
-http://blog.csdn.net/wangligong/article/details/53224594
-
-处理日志 
-
-@AspectJ的详细用法
-在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下：
-
-@Pointcut
-一些常见的切入点的例子
-execution(public * * (. .)) 任意公共方法被执行时，执行切入点函数。
-execution( * set* (. .)) 任何以一个“set”开始的方法被执行时，执行切入点函数。
-execution( * com.demo.service.AccountService.* (. .)) 当接口AccountService 中的任意方法被执行时，执行切入点函数。
-execution( * com.demo.service.. (. .)) 当service 包中的任意方法被执行时，执行切入点函数。 within(com.demo.service.) 在service 包里的任意连接点。 within(com.demo.service. .) 在service 包或子包的任意连接点。
-this(com.demo.service.AccountService) 实现了AccountService 接口的代理对象的任意连接点。
-target(com.demo.service.AccountService) 实现了AccountService 接口的目标对象的任意连接点。
-args(java.io.Serializable) 任何一个只接受一个参数，且在运行时传入参数实现了 Serializable 接口的连接点
-
-增强的方式：
-
-@Before ：方法前执行
-@AfterReturning ：运行方法后执行
-@AfterThrowing ：Throw后执行
-@After ：无论方法以何种方式结束，都会执行（类似于finally）
-@Around ：环绕执行
-
-例如定义切入点表达式 execution(* com.sample.service.impl..*.*(..))
-execution()是最常用的切点函数，其语法如下所示：
- 整个表达式可以分为五个部分：
- 1. execution(): 表达式主体。
- 2. 第一个*号：表示返回类型，* 号表示所有的类型。
- 3. 包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。
- 4. 第二个*号：表示类名，* 号表示所有的类。
- 5. * (..):最后这个星号表示方法名，* 号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。
+http://blog.csdn.net/jobjava/article/details/44063427
+
+http://blog.csdn.net/wangligong/article/details/53224594
+
+处理日志 
+
+@AspectJ的详细用法
+在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下：
+
+@Pointcut
+一些常见的切入点的例子
+execution(public * * (. .)) 任意公共方法被执行时，执行切入点函数。
+execution( * set* (. .)) 任何以一个“set”开始的方法被执行时，执行切入点函数。
+execution( * com.demo.service.AccountService.* (. .)) 当接口AccountService 中的任意方法被执行时，执行切入点函数。
+execution( * com.demo.service.. (. .)) 当service 包中的任意方法被执行时，执行切入点函数。 within(com.demo.service.) 在service 包里的任意连接点。 within(com.demo.service. .) 在service 包或子包的任意连接点。
+this(com.demo.service.AccountService) 实现了AccountService 接口的代理对象的任意连接点。
+target(com.demo.service.AccountService) 实现了AccountService 接口的目标对象的任意连接点。
+args(java.io.Serializable) 任何一个只接受一个参数，且在运行时传入参数实现了 Serializable 接口的连接点
+
+增强的方式：
+
+@Before ：方法前执行
+@AfterReturning ：运行方法后执行
+@AfterThrowing ：Throw后执行
+@After ：无论方法以何种方式结束，都会执行（类似于finally）
+@Around ：环绕执行
+
+例如定义切入点表达式 execution(* com.sample.service.impl..*.*(..))
+execution()是最常用的切点函数，其语法如下所示：
+ 整个表达式可以分为五个部分：
+ 1. execution(): 表达式主体。
+ 2. 第一个*号：表示返回类型，* 号表示所有的类型。
+ 3. 包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。
+ 4. 第二个*号：表示类名，* 号表示所有的类。
+ 5. * (..):最后这个星号表示方法名，* 号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。
diff --git a/03 - Framework/spring/@Async.md "b/03 - Framework \346\241\206\346\236\266/spring/@Async.md"
similarity index 95%
rename from 03 - Framework/spring/@Async.md
rename to "03 - Framework \346\241\206\346\236\266/spring/@Async.md"
index 5002567e..fa4dc221 100644
--- a/03 - Framework/spring/@Async.md	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/@Async.md"	
@@ -1,6 +1,6 @@
-启用@Async异步调用
-
-@EnableAsync
-
-<task:executor id="myexecutor" pool-size="5"  />
-<task:annotation-driven executor="myexecutor"/>
+启用@Async异步调用
+
+@EnableAsync
+
+<task:executor id="myexecutor" pool-size="5"  />
+<task:annotation-driven executor="myexecutor"/>
diff --git a/03 - Framework/spring/@ControllerAdvice.md "b/03 - Framework \346\241\206\346\236\266/spring/@ControllerAdvice.md"
similarity index 90%
rename from 03 - Framework/spring/@ControllerAdvice.md
rename to "03 - Framework \346\241\206\346\236\266/spring/@ControllerAdvice.md"
index d566699f..6ee1a9b2 100644
--- a/03 - Framework/spring/@ControllerAdvice.md	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/@ControllerAdvice.md"	
@@ -1,7 +1,7 @@
-@ControllerAdvice
-
-@ExceptionHandler
-
-@ResponseStatus
-
-处理异常
+@ControllerAdvice
+
+@ExceptionHandler
+
+@ResponseStatus
+
+处理异常
diff --git a/03 - Framework/spring/IOC AOP.md "b/03 - Framework \346\241\206\346\236\266/spring/IOC AOP.md"
similarity index 96%
rename from 03 - Framework/spring/IOC AOP.md
rename to "03 - Framework \346\241\206\346\236\266/spring/IOC AOP.md"
index 273f01fd..c8b6f0bf 100644
--- a/03 - Framework/spring/IOC AOP.md	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/IOC AOP.md"	
@@ -1,122 +1,129 @@
-### IOC **控制反转**  
-工厂模式 java反射
-容器控制程序对象之间的关系，而不是传统实现中，由程序代码之间控制，又名 **依赖注入**
-ALl类的创建，销毁都是由Spring来控制，也就是说控制对象生命周期的不是引用他的对象，而是Spring。
-对于某个对象而言，以前是他控制其他对象，现在是all对象都被spring控制，这就叫控制反转
-依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中的set方法将事先保存在hashmap中的类属性注入到类中。
-(依赖注入：在运行期间由容器将依赖关系注入到组件中，就是在运行期，由spring根据配置文件将其他对象的引用通过组将提供的setter方法进行设定)
-(控制反转：对组件对象控制权的转移，从程序代码本身转移到了外部容器，通过容器来实现对象组件的装配和管理)
-
-控制反转即IoC (Inversion of Control)，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。
-
-### AOP
-代理模式
-Spring事先aop:JDK动态代理，cglib动态代理
-`JDK`动态代理：其代理对象必须是某个接口的实现，他是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。核心类有InnovationHandler，Proxy
-`cglib`动态代理：实现原理类似于JDK动态代理，只是他在运行期间生成的代理对象时针对目标扩展的子类。MethodInterceptor
-code Generation Library， 通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，则不行）
-
-1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
-2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
-3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
-
-如何强制使用CGLIB实现AOP？
- （1）添加CGLIB库，SPRING_HOME/cglib/* .jar
- （2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>
-
- JDK动态代理和CGLIB字节码生成的区别？
-  （1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
-  （2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
-    因为是继承，所以该类或方法最好不要声明成final
-
-JDK代理是不需要以来第三方的库，只要要JDK环境就可以进行代理，它有几个要求
-* 实现InvocationHandler
-* 使用Proxy.newProxyInstance产生代理对象 `newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)`
-* 被代理的对象必须要`实现接口`
-实现原理
-* 通过实现InvocationHandler接口创建自己的调用处理器
-* 通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理
-* 通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型
-* 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入
-```java
-public interface UserManager {    
-    public void addUser(String id, String password);    
-    public void delUser(String id);    
-}
-
-public class UserManagerImpl implements UserManager {    
-
-    public void addUser(String id, String password) {    
-        System.out.println("调用了UserManagerImpl.addUser()方法！ ");    
-
-    }    
-
-    public void delUser(String id) {    
-        System.out.println("调用了UserManagerImpl.delUser()方法！ ");    
-
-    }    
-}  
-
-public class JDKProxy implements InvocationHandler {
-
-	private Object targetObject;// 需要代理的目标对象
-
-	public Object newProxy(Object targetObject) {// 将目标对象传入进行代理
-		this.targetObject = targetObject;
-		// 返回代理对象
-		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(),this);
-	}
-
-	@Override
-	public Object invoke(Object proxy, Method method, Object[] args)// invoke方法
-			throws Throwable {
-		Object ret = null;
-		// 调用invoke方法，ret存储该方法的返回值
-		System.out.println("执行前...");
-		ret = method.invoke(targetObject, args);
-		System.out.println("执行后...");
-		return ret;
-	}
-}
-
-main
-System.out.println("-----------JDKProxy-------------");
-JDKProxy jDKProxy = new JDKProxy();
-UserManager userManagerJDK = (UserManager) jDKProxy.newProxy(new UserManagerImpl());
-userManagerJDK.addUser("tom", "root");
-```
-
-
-
-CGLib 必须依赖于CGLib的类库，但是它需要类来实现任何接口代理的是指定的类生成一个子类，覆盖其中的方法，是一种继承但是针对接口编程的环境下推荐使用JDK的代理
-在Hibernate中的拦截器其实现考虑到不需要其他接口的条件Hibernate中的相关代理采用的是CGLib来执行。
-CGLib实现
-```java
-public class CGLibProxy implements MethodInterceptor {
-
-	private Object targetObject;// CGLib需要代理的目标对象
-
-	public Object createProxyObject(Object obj) {
-		this.targetObject = obj;
-		Enhancer enhancer = new Enhancer();
-		enhancer.setSuperclass(obj.getClass());
-		enhancer.setCallback(this);
-		Object proxyObj = enhancer.create();
-		return proxyObj;// 返回代理对象
-	}
-
-	@Override
-	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
-		Object obj = null;
-		System.out.println("执行前...");
-		obj = method.invoke(targetObject, args);
-		System.out.println("执行后...");
-		return obj;
-	}
-
-}
-mainSystem.out.println("-----------CGLibProxy-------------");
-CGLibProxy cGLibProxy = new CGLibProxy();
-UserManager userManagerCGLib = (UserManager) cGLibProxy.createProxyObject(new UserManagerImpl());
-userManagerCGLib.addUser("tom", "root");
-```
+### IOC **控制反转**  
+工厂模式 java反射
+容器控制程序对象之间的关系，而不是传统实现中，由程序代码之间控制，又名 **依赖注入**
+ALl类的创建，销毁都是由Spring来控制，也就是说控制对象生命周期的不是引用他的对象，而是Spring。
+对于某个对象而言，以前是他控制其他对象，现在是all对象都被spring控制，这就叫控制反转
+依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中的set方法将事先保存在hashmap中的类属性注入到类中。
+(依赖注入：在运行期间由容器将依赖关系注入到组件中，就是在运行期，由spring根据配置文件将其他对象的引用通过组将提供的setter方法进行设定)
+(控制反转：对组件对象控制权的转移，从程序代码本身转移到了外部容器，通过容器来实现对象组件的装配和管理)
+
+控制反转即IoC (Inversion of Control)，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。
+
+### AOP
+代理模式
+Spring事先aop:JDK动态代理，cglib动态代理
+`JDK`动态代理：其代理对象必须是某个接口的实现，他是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。核心类有InnovationHandler，Proxy
+`cglib`动态代理：实现原理类似于JDK动态代理，只是他在运行期间生成的代理对象时针对目标扩展的子类。MethodInterceptor
+code Generation Library， 通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，则不行）
+
+1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
+2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
+3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
+
+如何强制使用CGLIB实现AOP？
+ （1）添加CGLIB库，SPRING_HOME/cglib/* .jar
+ （2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>
+
+ JDK动态代理和CGLIB字节码生成的区别？
+  （1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
+  （2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
+    因为是继承，所以该类或方法最好`不要声明成final`
+
+JDK代理是不需要以来第三方的库，只要要JDK环境就可以进行代理，它有几个要求
+* 实现InvocationHandler
+* 使用Proxy.newProxyInstance产生代理对象 `newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)`
+* 被代理的对象必须要`实现接口`
+实现原理
+* 通过实现InvocationHandler接口创建自己的调用处理器
+* 通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理
+* 通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型
+* 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入
+```java
+public interface UserManager {    
+    public void addUser(String id, String password);    
+    public void delUser(String id);    
+}
+
+public class UserManagerImpl implements UserManager {    
+
+    public void addUser(String id, String password) {    
+        System.out.println("调用了UserManagerImpl.addUser()方法！ ");    
+
+    }    
+
+    public void delUser(String id) {    
+        System.out.println("调用了UserManagerImpl.delUser()方法！ ");    
+
+    }    
+}  
+
+public class JDKProxy implements InvocationHandler {
+
+	private Object targetObject;// 需要代理的目标对象
+
+	public Object newProxy(Object targetObject) {// 将目标对象传入进行代理
+		this.targetObject = targetObject;
+		// 返回代理对象
+		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(),this);
+	}
+
+	@Override
+	public Object invoke(Object proxy, Method method, Object[] args)// invoke方法
+			throws Throwable {
+		Object ret = null;
+		// 调用invoke方法，ret存储该方法的返回值
+		System.out.println("执行前...");
+		ret = method.invoke(targetObject, args);
+		System.out.println("执行后...");
+		return ret;
+	}
+}
+
+main
+System.out.println("-----------JDKProxy-------------");
+JDKProxy jDKProxy = new JDKProxy();
+UserManager userManagerJDK = (UserManager) jDKProxy.newProxy(new UserManagerImpl());
+userManagerJDK.addUser("tom", "root");
+```
+
+CGLib 必须依赖于CGLib的类库，但是它需要类来实现任何接口代理的是指定的类生成一个子类，覆盖其中的方法，是一种继承但是针对接口编程的环境下推荐使用JDK的代理
+在Hibernate中的拦截器其实现考虑到不需要其他接口的条件Hibernate中的相关代理采用的是CGLib来执行。
+CGLib实现
+```java
+public class CGLibProxy implements MethodInterceptor {
+
+	private Object targetObject;// CGLib需要代理的目标对象
+
+	public Object createProxyObject(Object obj) {
+		this.targetObject = obj;
+		Enhancer enhancer = new Enhancer();
+		enhancer.setSuperclass(obj.getClass());
+		enhancer.setCallback(this);
+		Object proxyObj = enhancer.create();
+		return proxyObj;// 返回代理对象
+	}
+
+	@Override
+	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
+		Object obj = null;
+		System.out.println("执行前...");
+		obj = method.invoke(targetObject, args);
+		System.out.println("执行后...");
+		return obj;
+	}
+
+}
+mainSystem.out.println("-----------CGLibProxy-------------");
+CGLibProxy cGLibProxy = new CGLibProxy();
+UserManager userManagerCGLib = (UserManager) cGLibProxy.createProxyObject(new UserManagerImpl());
+userManagerCGLib.addUser("tom", "root");
+```
+
+### MethodInterceptor
+
+### 注解
+```java
+@Component  
+@Aspect  
+@Around("execution (* com.test.controller..*.*(..))")  
+```
diff --git a/03 - Framework/spring/README.md "b/03 - Framework \346\241\206\346\236\266/spring/README.md"
similarity index 100%
rename from 03 - Framework/spring/README.md
rename to "03 - Framework \346\241\206\346\236\266/spring/README.md"
diff --git "a/03 - Framework/spring/Spring\344\272\213\345\212\241.md" "b/03 - Framework \346\241\206\346\236\266/spring/Spring\344\272\213\345\212\241.md"
similarity index 98%
rename from "03 - Framework/spring/Spring\344\272\213\345\212\241.md"
rename to "03 - Framework \346\241\206\346\236\266/spring/Spring\344\272\213\345\212\241.md"
index 8b0fd2d4..dd70a9d3 100644
--- "a/03 - Framework/spring/Spring\344\272\213\345\212\241.md"	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/Spring\344\272\213\345\212\241.md"	
@@ -1,159 +1,159 @@
-  Spring事务 的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。
-  真正的数据库层的事务提交和回滚是通过binlog或者redo log实现的。
-  https://blog.csdn.net/trigl/article/details/50968079  
-  https://juejin.im/post/5b00c52ef265da0b95276091
-
-  事务属性的种类：   **传播行为**、**隔离级别**、只读和事务超时
-
-### 传播行为
-  传播行为定义了被调用方法的事务边界。
-
-7种传播行为|描述
------|-----
-**支持当前事务** |
-`PROPAGATION_REQUIRED`(默认）| 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
-`PROPAGATION_SUPPORTS`      | 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
-`PROPAGATION_MANDATORY`     | 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
-**不支持当前事务** |
-`PROPAGATION_REQUIRES_NEW`  | 创建一个新的事务，如果当前存在事务，则把当前事务挂起。
-`PROPAGATION_NOT_SUPPORTED` | 以非事务方式运行，如果当前存在事务，则把当前事务挂起。
-`PROPAGATION_NEVER`         | 以非事务方式运行，如果当前存在事务，则抛出异常。
-**其他情况** |
-`PROPAGATION_NESTED`        | 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。
-
-###   隔离级别
-  在操作数据时可能带来 3 个副作用，分别是脏读、不可重复读、幻读。为了避免这 3 中副作用的发生，在标准的 SQL 语句中定义了 4 种隔离级别，分别是未提交读、已提交读、可重复读、可序列化。而在 spring 事务中提供了 5 种隔离级别来对应在 SQL 中定义的 4 种隔离级别，如下：
-
-5种隔离级别|描述
--|-
-ISOLATION_ **DEFAULT**           |    使用后端数据库默认的隔离级别
-ISOLATION_ **READ_UNCOMMITTED**  |    最低的隔离级别,允许读取未提交的数据（对应`未提交读`），可能 **导致脏读、不可重复读、幻读**
-ISOLATION_ **READ_COMMITTED**    |    允许读取并发事务已经提交的数据（对应`已提交读`）。可以 **避免脏读，但是无法避免不可重复读和幻读**
-ISOLATION_ **REPEATABLE_READ**   |    对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改（对应`可重复读`）。**可以避免脏读和不可重复读，但无法避免幻读**
-ISOLATION_ **SERIALIZABLE**      |    最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰（对应`可序列化`）。**可以避免脏读、不可重复读、幻读。但是这种隔离级别效率很低，因此，除非必须，否则不建议使用。**
-
-`脏读（Dirty read） 未提交读`：一事务对数据进行了增删改，但未提交，另一事务可以读取到未提交的数据。如果第一个事务这时候回滚了，那么第二个事务就读到了脏数据。
-
-`丢失修改（Lost to modify）`: 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。
-例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
-
-`不可重复读（Unrepeatableread）`：一个事务中发生了两次读操作，第一次读操作和第二次操作之间，另外一个事务对数据进行了修改，这时候两次读取的数据是不一致的。
-
-`幻读（Phantom read）`：第一个事务对一定范围的数据进行批量修改，第二个事务在这个范围增加一条数据，这时候第一个事务就会丢失对新增数据的修改。
-
-`不可重复度和幻读区别：`
-不可重复读的重点是修改，幻读的重点在于新增或者删除。
-例1（同样的条件, 你读取过的数据, 再次读取出来发现值不一样了 ）：事务1中的A先生读取自己的工资为     1000的操作还没完成，事务2中的B先生就修改了A的工资为2000，导        致A再读自己的工资时工资变为  2000；这就是不可重复读。
-例2（同样的条件, 第1次和第2次读出来的记录数不一样 ）：假某工资单表中工资大于3000的有4人，事务1读取了所有工资大于3000的人，共查到4条记录，这时事务2 又插入了一条工资大于3000的记录，事务1再次读取时查到的记录就变为了5条，这样就导致了幻读。
-
-`总结：`
-隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大。
-大多数的数据库默认隔离级别为 Read Commited，比如 SqlServer、Oracle
-少数数据库默认隔离级别为：Repeatable Read 比如： MySQL InnoDB
-
-### 注解
-
-  ```java
-  // 指定回滚
-  @Transactional(rollbackFor=Exception.class)
-
-  //指定不回滚
-  @Transactional(noRollbackFor=Exception.class)
-
-  // 如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
-  @Transactional(propagation=Propagation.REQUIRED)
-
-  // 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
-  @Transactional(propagation=Propagation.REQUIRES_NEW)
-
-  // 必须在一个已有的事务中执行,否则抛出异常
-  @Transactional(propagation=Propagation.MANDATORY)
-
-  // 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
-  @Transactional(propagation=Propagation.NEVER)
-
-  // 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
-  @Transactional(propagation=Propagation.SUPPORTS)
-
-  // 容器不为这个方法开启事务
-  @Transactional(propagation=Propagation.NOT_SUPPORTED)
-
-  // readOnly=true只读,不能更新,删除
-  @Transactional(propagation = Propagation.REQUIRED,readOnly=true)
-
-  // 设置超时时间
-  @Transactional(propagation = Propagation.REQUIRED,timeout=30)
-
-  // 设置数据库隔离级别
-  @Transactional(propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)
-  ```
-
-### 事务的嵌套
-  通过上面的理论知识的铺垫，我们大致知道了数据库事务和spring事务的一些属性和特点，接下来我们通过分析一些嵌套事务的场景，来深入理解spring事务传播的机制。
-
-  假设外层事务 Service A 的 Method A() 调用 内层Service B 的 Method B()
-
-  `PROPAGATION_REQUIRED(spring 默认)`
-
-  如果ServiceB.methodB() 的事务级别定义为 PROPAGATION_REQUIRED，那么执行 ServiceA.methodA() 的时候spring已经起了事务，这时调用 ServiceB.methodB()，ServiceB.methodB() 看到自己已经运行在 ServiceA.methodA() 的事务内部，就不再起新的事务。
-
-  假如 ServiceB.methodB() 运行的时候发现自己没有在事务中，他就会为自己分配一个事务。
-
-  这样，在 ServiceA.methodA() 或者在 ServiceB.methodB() 内的任何地方出现异常，事务都会被回滚。
-
-  `PROPAGATION_REQUIRES_NEW`
-
-  比如我们设计 ServiceA.methodA() 的事务级别为 PROPAGATION_REQUIRED，ServiceB.methodB() 的事务级别为 PROPAGATION_REQUIRES_NEW。
-
-  那么当执行到 ServiceB.methodB() 的时候，ServiceA.methodA() 所在的事务就会挂起，ServiceB.methodB() 会起一个新的事务，等待 ServiceB.methodB() 的事务完成以后，它才继续执行。
-
-  他与 PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为 ServiceB.methodB() 是新起一个事务，那么就是存在两个不同的事务。如果 ServiceB.methodB() 已经提交，那么 ServiceA.methodA() 失败回滚，ServiceB.methodB() 是不会回滚的。如果 ServiceB.methodB() 失败回滚，如果他抛出的异常被 ServiceA.methodA() 捕获，ServiceA.methodA() 事务仍然可能提交(主要看B抛出的异常是不是A会回滚的异常)。
-
-  `PROPAGATION_SUPPORTS`
-
-  假设ServiceB.methodB() 的事务级别为 PROPAGATION_SUPPORTS，那么当执行到ServiceB.methodB()时，如果发现ServiceA.methodA()已经开启了一个事务，则加入当前的事务，如果发现ServiceA.methodA()没有开启事务，则自己也不开启事务。这种时候，内部方法的事务性完全依赖于最外层的事务。
-
-  `PROPAGATION_NESTED`
-
-  现在的情况就变得比较复杂了, ServiceB.methodB() 的事务属性被配置为 PROPAGATION_NESTED, 此时两者之间又将如何协作呢?
ServiceB#methodB 如果 rollback, 那么内部事务(即 ServiceB#methodB) 将回滚到它执行前的 SavePoint 而外部事务(即 ServiceA#methodA) 可以有以下两种处理方式:
-  a、捕获异常，执行异常分支逻辑
-  ```java
-  void methodA() {
-
-          try {
-
-              ServiceB.methodB();
-
-          } catch (SomeException) {
-
-              // 执行其他业务, 如 ServiceC.methodC();
-
-          }
-
-      }
-  ```
-  这种方式也是嵌套事务最有价值的地方, 它起到了分支执行的效果, 如果 ServiceB.methodB 失败, 那么执行 ServiceC.methodC(), 而 ServiceB.methodB 已经回滚到它执行之前的 SavePoint, 所以不会产生脏数据(相当于此方法从未执行过), 这种特性可以用在某些特殊的业务中, 而 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 都没有办法做到这一点。
-
-  b、 外部事务回滚/提交 代码不做任何修改, 那么如果内部事务(ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前的 SavePoint(在任何情况下都会如此), 外部事务(即 ServiceA#methodA) 将根据具体的配置决定自己是 commit 还是 rollback
-
-### 实现
-
-  事务是由AOP实现
-
-  定义order的大小 ，值越小，说明越先被执行
-
-
-### 只读
-  事务的只读属性是指，对事务性资源进行只读操作或者是读写操作。所谓事务性资源就是指那些被事务管理的资源，比如数据源、 JMS 资源，以及自定义的事务性资源等等。如果确定只对事务性资源进行只读操作，那么我们可以将事务标志为只读的，以提高事务处理的性能。在 TransactionDefinition 中以 boolean 类型来表示该事务是否只读。
-
-
-  如果在一个事务中所有关于数据库的操作都是只读的，也就是说，这些操作只读取数据库中的数据，而并不更新数据，那么应将事务设为只读模式（ READ_ONLY_MARKER ） , 这样更有利于数据库进行优化 。
-
-  因为只读的优化措施是事务启动后由数据库实施的，因此，只有将那些具有可能启动新事务的传播行为 (PROPAGATION_NESTED 、 PROPAGATION_REQUIRED 、 PROPAGATION_REQUIRED_NEW) 的方法的事务标记成只读才有意义。
-
-  如果使用 Hibernate 作为持久化机制，那么将事务标记为只读后，会将 Hibernate 的 flush 模式设置为 FULSH_NEVER, 以告诉 Hibernate 避免和数据库之间进行不必要的同步，并将所有更新延迟到事务结束。
-
-### 事务超时
-  如果一个事务长时间运行，这时为了尽量避免浪费系统资源，应为这个事务设置一个有效时间，使其等待数秒后自动回滚。
-  与设置“只读”属性一样，事务有效属性也需要给那些具有可能启动新事物的传播行为的方法的事务标记成只读才有意义。
-  所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。
+  Spring事务 的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。
+  真正的数据库层的事务提交和回滚是通过binlog或者redo log实现的。
+  https://blog.csdn.net/trigl/article/details/50968079  
+  https://juejin.im/post/5b00c52ef265da0b95276091
+
+  事务属性的种类：   **传播行为**、**隔离级别**、只读和事务超时
+
+### 传播行为
+  传播行为定义了被调用方法的事务边界。
+
+7种传播行为|描述
+-----|-----
+**支持当前事务** |
+`PROPAGATION_REQUIRED`(默认）| 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
+`PROPAGATION_SUPPORTS`      | 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
+`PROPAGATION_MANDATORY`     | 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
+**不支持当前事务** |
+`PROPAGATION_REQUIRES_NEW`  | 创建一个新的事务，如果当前存在事务，则把当前事务挂起。
+`PROPAGATION_NOT_SUPPORTED` | 以非事务方式运行，如果当前存在事务，则把当前事务挂起。
+`PROPAGATION_NEVER`         | 以非事务方式运行，如果当前存在事务，则抛出异常。
+**其他情况** |
+`PROPAGATION_NESTED`        | 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。
+
+###   隔离级别
+  在操作数据时可能带来 3 个副作用，分别是脏读、不可重复读、幻读。为了避免这 3 中副作用的发生，在标准的 SQL 语句中定义了 4 种隔离级别，分别是未提交读、已提交读、可重复读、可序列化。而在 spring 事务中提供了 5 种隔离级别来对应在 SQL 中定义的 4 种隔离级别，如下：
+
+5种隔离级别|描述
+-|-
+ISOLATION_ **DEFAULT**           |    使用后端数据库默认的隔离级别
+ISOLATION_ **READ_UNCOMMITTED**  |    最低的隔离级别,允许读取未提交的数据（对应`未提交读`），可能 **导致脏读、不可重复读、幻读**
+ISOLATION_ **READ_COMMITTED**    |    允许读取并发事务已经提交的数据（对应`已提交读`）。可以 **避免脏读，但是无法避免不可重复读和幻读**
+ISOLATION_ **REPEATABLE_READ**   |    对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改（对应`可重复读`）。**可以避免脏读和不可重复读，但无法避免幻读**
+ISOLATION_ **SERIALIZABLE**      |    最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰（对应`可序列化`）。**可以避免脏读、不可重复读、幻读。但是这种隔离级别效率很低，因此，除非必须，否则不建议使用。**
+
+`脏读（Dirty read） 未提交读`：一事务对数据进行了增删改，但未提交，另一事务可以读取到未提交的数据。如果第一个事务这时候回滚了，那么第二个事务就读到了脏数据。
+
+`丢失修改（Lost to modify）`: 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。
+例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
+
+`不可重复读（Unrepeatableread）`：一个事务中发生了两次读操作，第一次读操作和第二次操作之间，另外一个事务对数据进行了修改，这时候两次读取的数据是不一致的。
+
+`幻读（Phantom read）`：第一个事务对一定范围的数据进行批量修改，第二个事务在这个范围增加一条数据，这时候第一个事务就会丢失对新增数据的修改。
+
+`不可重复度和幻读区别：`
+不可重复读的重点是修改，幻读的重点在于新增或者删除。
+例1（同样的条件, 你读取过的数据, 再次读取出来发现值不一样了 ）：事务1中的A先生读取自己的工资为     1000的操作还没完成，事务2中的B先生就修改了A的工资为2000，导        致A再读自己的工资时工资变为  2000；这就是不可重复读。
+例2（同样的条件, 第1次和第2次读出来的记录数不一样 ）：假某工资单表中工资大于3000的有4人，事务1读取了所有工资大于3000的人，共查到4条记录，这时事务2 又插入了一条工资大于3000的记录，事务1再次读取时查到的记录就变为了5条，这样就导致了幻读。
+
+`总结：`
+隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大。
+大多数的数据库默认隔离级别为 Read Commited，比如 SqlServer、Oracle
+少数数据库默认隔离级别为：Repeatable Read 比如： MySQL InnoDB
+
+### 注解
+
+  ```java
+  // 指定回滚
+  @Transactional(rollbackFor=Exception.class)
+
+  //指定不回滚
+  @Transactional(noRollbackFor=Exception.class)
+
+  // 如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
+  @Transactional(propagation=Propagation.REQUIRED)
+
+  // 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
+  @Transactional(propagation=Propagation.REQUIRES_NEW)
+
+  // 必须在一个已有的事务中执行,否则抛出异常
+  @Transactional(propagation=Propagation.MANDATORY)
+
+  // 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
+  @Transactional(propagation=Propagation.NEVER)
+
+  // 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
+  @Transactional(propagation=Propagation.SUPPORTS)
+
+  // 容器不为这个方法开启事务
+  @Transactional(propagation=Propagation.NOT_SUPPORTED)
+
+  // readOnly=true只读,不能更新,删除
+  @Transactional(propagation = Propagation.REQUIRED,readOnly=true)
+
+  // 设置超时时间
+  @Transactional(propagation = Propagation.REQUIRED,timeout=30)
+
+  // 设置数据库隔离级别
+  @Transactional(propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)
+  ```
+
+### 事务的嵌套
+  通过上面的理论知识的铺垫，我们大致知道了数据库事务和spring事务的一些属性和特点，接下来我们通过分析一些嵌套事务的场景，来深入理解spring事务传播的机制。
+
+  假设外层事务 Service A 的 Method A() 调用 内层Service B 的 Method B()
+
+  `PROPAGATION_REQUIRED(spring 默认)`
+
+  如果ServiceB.methodB() 的事务级别定义为 PROPAGATION_REQUIRED，那么执行 ServiceA.methodA() 的时候spring已经起了事务，这时调用 ServiceB.methodB()，ServiceB.methodB() 看到自己已经运行在 ServiceA.methodA() 的事务内部，就不再起新的事务。
+
+  假如 ServiceB.methodB() 运行的时候发现自己没有在事务中，他就会为自己分配一个事务。
+
+  这样，在 ServiceA.methodA() 或者在 ServiceB.methodB() 内的任何地方出现异常，事务都会被回滚。
+
+  `PROPAGATION_REQUIRES_NEW`
+
+  比如我们设计 ServiceA.methodA() 的事务级别为 PROPAGATION_REQUIRED，ServiceB.methodB() 的事务级别为 PROPAGATION_REQUIRES_NEW。
+
+  那么当执行到 ServiceB.methodB() 的时候，ServiceA.methodA() 所在的事务就会挂起，ServiceB.methodB() 会起一个新的事务，等待 ServiceB.methodB() 的事务完成以后，它才继续执行。
+
+  他与 PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为 ServiceB.methodB() 是新起一个事务，那么就是存在两个不同的事务。如果 ServiceB.methodB() 已经提交，那么 ServiceA.methodA() 失败回滚，ServiceB.methodB() 是不会回滚的。如果 ServiceB.methodB() 失败回滚，如果他抛出的异常被 ServiceA.methodA() 捕获，ServiceA.methodA() 事务仍然可能提交(主要看B抛出的异常是不是A会回滚的异常)。
+
+  `PROPAGATION_SUPPORTS`
+
+  假设ServiceB.methodB() 的事务级别为 PROPAGATION_SUPPORTS，那么当执行到ServiceB.methodB()时，如果发现ServiceA.methodA()已经开启了一个事务，则加入当前的事务，如果发现ServiceA.methodA()没有开启事务，则自己也不开启事务。这种时候，内部方法的事务性完全依赖于最外层的事务。
+
+  `PROPAGATION_NESTED`
+
+  现在的情况就变得比较复杂了, ServiceB.methodB() 的事务属性被配置为 PROPAGATION_NESTED, 此时两者之间又将如何协作呢?
ServiceB#methodB 如果 rollback, 那么内部事务(即 ServiceB#methodB) 将回滚到它执行前的 SavePoint 而外部事务(即 ServiceA#methodA) 可以有以下两种处理方式:
+  a、捕获异常，执行异常分支逻辑
+  ```java
+  void methodA() {
+
+          try {
+
+              ServiceB.methodB();
+
+          } catch (SomeException) {
+
+              // 执行其他业务, 如 ServiceC.methodC();
+
+          }
+
+      }
+  ```
+  这种方式也是嵌套事务最有价值的地方, 它起到了分支执行的效果, 如果 ServiceB.methodB 失败, 那么执行 ServiceC.methodC(), 而 ServiceB.methodB 已经回滚到它执行之前的 SavePoint, 所以不会产生脏数据(相当于此方法从未执行过), 这种特性可以用在某些特殊的业务中, 而 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 都没有办法做到这一点。
+
+  b、 外部事务回滚/提交 代码不做任何修改, 那么如果内部事务(ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前的 SavePoint(在任何情况下都会如此), 外部事务(即 ServiceA#methodA) 将根据具体的配置决定自己是 commit 还是 rollback
+
+### 实现
+
+  事务是由AOP实现
+
+  定义order的大小 ，值越小，说明越先被执行
+
+
+### 只读
+  事务的只读属性是指，对事务性资源进行只读操作或者是读写操作。所谓事务性资源就是指那些被事务管理的资源，比如数据源、 JMS 资源，以及自定义的事务性资源等等。如果确定只对事务性资源进行只读操作，那么我们可以将事务标志为只读的，以提高事务处理的性能。在 TransactionDefinition 中以 boolean 类型来表示该事务是否只读。
+
+
+  如果在一个事务中所有关于数据库的操作都是只读的，也就是说，这些操作只读取数据库中的数据，而并不更新数据，那么应将事务设为只读模式（ READ_ONLY_MARKER ） , 这样更有利于数据库进行优化 。
+
+  因为只读的优化措施是事务启动后由数据库实施的，因此，只有将那些具有可能启动新事务的传播行为 (PROPAGATION_NESTED 、 PROPAGATION_REQUIRED 、 PROPAGATION_REQUIRED_NEW) 的方法的事务标记成只读才有意义。
+
+  如果使用 Hibernate 作为持久化机制，那么将事务标记为只读后，会将 Hibernate 的 flush 模式设置为 FULSH_NEVER, 以告诉 Hibernate 避免和数据库之间进行不必要的同步，并将所有更新延迟到事务结束。
+
+### 事务超时
+  如果一个事务长时间运行，这时为了尽量避免浪费系统资源，应为这个事务设置一个有效时间，使其等待数秒后自动回滚。
+  与设置“只读”属性一样，事务有效属性也需要给那些具有可能启动新事物的传播行为的方法的事务标记成只读才有意义。
+  所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。
diff --git a/03 - Framework/spring/beanFactory_life.png "b/03 - Framework \346\241\206\346\236\266/spring/beanFactory_life.png"
similarity index 100%
rename from 03 - Framework/spring/beanFactory_life.png
rename to "03 - Framework \346\241\206\346\236\266/spring/beanFactory_life.png"
diff --git a/03 - Framework/spring/bean_life.png "b/03 - Framework \346\241\206\346\236\266/spring/bean_life.png"
similarity index 100%
rename from 03 - Framework/spring/bean_life.png
rename to "03 - Framework \346\241\206\346\236\266/spring/bean_life.png"
diff --git "a/03 - Framework/spring/bean\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.png" "b/03 - Framework \346\241\206\346\236\266/spring/bean\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.png"
similarity index 100%
rename from "03 - Framework/spring/bean\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.png"
rename to "03 - Framework \346\241\206\346\236\266/spring/bean\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.png"
diff --git "a/03 - Framework/spring/bean\346\265\201\347\250\213.md" "b/03 - Framework \346\241\206\346\236\266/spring/bean\346\265\201\347\250\213.md"
similarity index 99%
rename from "03 - Framework/spring/bean\346\265\201\347\250\213.md"
rename to "03 - Framework \346\241\206\346\236\266/spring/bean\346\265\201\347\250\213.md"
index 28f0948a..9e7d5ea4 100644
--- "a/03 - Framework/spring/bean\346\265\201\347\250\213.md"	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/bean\346\265\201\347\250\213.md"	
@@ -1,31 +1,31 @@
-https://www.jianshu.com/p/3ea335c8c875
-
-1. `ResourceLoader`从存储介质中加载Spring配置信息，并使用`Resource`表示这个配置文件的资源；
-
-2. BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中每一个<bean>解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中；
-
-3. 容器扫描BeanDefinitionRegistry中的BeanDefinition，使用Java的反射机制自动识别出Bean工厂后处理后器（实现BeanFactoryPostProcessor接口）的Bean，然后调用这些Bean工厂后处理器对BeanDefinitionRegistry中的BeanDefinition进行加工处理。主要完成以下两项工作：
-
-  1）对使用到占位符的<bean>元素标签进行解析，得到最终的配置值，这意味对一些半成品式的BeanDefinition对象进行加工处理并得到成品的BeanDefinition对象；
-
-  2）对BeanDefinitionRegistry中的BeanDefinition进行扫描，通过Java反射机制找出所有属性编辑器的Bean（实现java.beans.PropertyEditor接口的Bean），并自动将它们注册到Spring容器的属性编辑器注册表中（PropertyEditorRegistry）；
-
-4. Spring容器从BeanDefinitionRegistry中取出加工后的BeanDefinition，并调用InstantiationStrategy着手进行Bean实例化的工作；
-
-5. 在实例化Bean时，Spring容器使用BeanWrapper对Bean进行封装，BeanWrapper提供了很多以Java反射机制操作Bean的方法，它将结合该Bean的BeanDefinition以及容器中属性编辑器，完成Bean属性的设置工作；
-
-6. 利用容器中注册的Bean后处理器（实现BeanPostProcessor接口的Bean）对已经完成属性设置工作的Bean进行后续加工，直接装配出一个准备就绪的Bean。
-
-Spring容器确实堪称一部设计精密的机器，其内部拥有众多的组件和装置。Spring的高明之处在于，它使用众多接口描绘出了所有装置的蓝图，构建好Spring的骨架，继而通过继承体系层层推演，不断丰富，最终让Spring成为有血有肉的完整的框架。所以查看Spring框架的源码时，有两条清晰可见的脉络：
-
-  1）接口层描述了容器的重要组件及组件间的协作关系；
-
-  2）继承体系逐步实现组件的各项功能。
-
-接口层清晰地勾勒出Spring框架的高层功能，框架脉络呼之欲出。有了接口层抽象的描述后，不但Spring自己可以提供具体的实现，任何第三方组织也可以提供不同实现， 可以说Spring完善的接口层使框架的扩展性得到了很好的保证。纵向继承体系的逐步扩展，分步骤地实现框架的功能，这种实现方案保证了框架功能不会堆积在某些类的身上，造成过重的代码逻辑负载，框架的复杂度被完美地分解开了。
-
-Spring组件按其所承担的角色可以划分为两类：
-
-  1）物料组件：Resource、BeanDefinition、PropertyEditor以及最终的Bean等，它们是加工流程中被加工、被消费的组件，就像流水线上被加工的物料；
-
-  2）加工设备组件：ResourceLoader、BeanDefinitionReader、BeanFactoryPostProcessor、InstantiationStrategy以及BeanWrapper等组件像是流水线上不同环节的加工设备，对物料组件进行加工处理。
+https://www.jianshu.com/p/3ea335c8c875
+
+1. `ResourceLoader`从存储介质中加载Spring配置信息，并使用`Resource`表示这个配置文件的资源；
+
+2. BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中每一个<bean>解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中；
+
+3. 容器扫描BeanDefinitionRegistry中的BeanDefinition，使用Java的反射机制自动识别出Bean工厂后处理后器（实现BeanFactoryPostProcessor接口）的Bean，然后调用这些Bean工厂后处理器对BeanDefinitionRegistry中的BeanDefinition进行加工处理。主要完成以下两项工作：
+
+  1）对使用到占位符的<bean>元素标签进行解析，得到最终的配置值，这意味对一些半成品式的BeanDefinition对象进行加工处理并得到成品的BeanDefinition对象；
+
+  2）对BeanDefinitionRegistry中的BeanDefinition进行扫描，通过Java反射机制找出所有属性编辑器的Bean（实现java.beans.PropertyEditor接口的Bean），并自动将它们注册到Spring容器的属性编辑器注册表中（PropertyEditorRegistry）；
+
+4. Spring容器从BeanDefinitionRegistry中取出加工后的BeanDefinition，并调用InstantiationStrategy着手进行Bean实例化的工作；
+
+5. 在实例化Bean时，Spring容器使用BeanWrapper对Bean进行封装，BeanWrapper提供了很多以Java反射机制操作Bean的方法，它将结合该Bean的BeanDefinition以及容器中属性编辑器，完成Bean属性的设置工作；
+
+6. 利用容器中注册的Bean后处理器（实现BeanPostProcessor接口的Bean）对已经完成属性设置工作的Bean进行后续加工，直接装配出一个准备就绪的Bean。
+
+Spring容器确实堪称一部设计精密的机器，其内部拥有众多的组件和装置。Spring的高明之处在于，它使用众多接口描绘出了所有装置的蓝图，构建好Spring的骨架，继而通过继承体系层层推演，不断丰富，最终让Spring成为有血有肉的完整的框架。所以查看Spring框架的源码时，有两条清晰可见的脉络：
+
+  1）接口层描述了容器的重要组件及组件间的协作关系；
+
+  2）继承体系逐步实现组件的各项功能。
+
+接口层清晰地勾勒出Spring框架的高层功能，框架脉络呼之欲出。有了接口层抽象的描述后，不但Spring自己可以提供具体的实现，任何第三方组织也可以提供不同实现， 可以说Spring完善的接口层使框架的扩展性得到了很好的保证。纵向继承体系的逐步扩展，分步骤地实现框架的功能，这种实现方案保证了框架功能不会堆积在某些类的身上，造成过重的代码逻辑负载，框架的复杂度被完美地分解开了。
+
+Spring组件按其所承担的角色可以划分为两类：
+
+  1）物料组件：Resource、BeanDefinition、PropertyEditor以及最终的Bean等，它们是加工流程中被加工、被消费的组件，就像流水线上被加工的物料；
+
+  2）加工设备组件：ResourceLoader、BeanDefinitionReader、BeanFactoryPostProcessor、InstantiationStrategy以及BeanWrapper等组件像是流水线上不同环节的加工设备，对物料组件进行加工处理。
diff --git a/03 - Framework/spring/class.png "b/03 - Framework \346\241\206\346\236\266/spring/class.png"
similarity index 100%
rename from 03 - Framework/spring/class.png
rename to "03 - Framework \346\241\206\346\236\266/spring/class.png"
diff --git a/03 - Framework/spring/createBean.jpg "b/03 - Framework \346\241\206\346\236\266/spring/createBean.jpg"
similarity index 100%
rename from 03 - Framework/spring/createBean.jpg
rename to "03 - Framework \346\241\206\346\236\266/spring/createBean.jpg"
diff --git a/03 - Framework/spring/spring bean.md "b/03 - Framework \346\241\206\346\236\266/spring/spring bean.md"
similarity index 98%
rename from 03 - Framework/spring/spring bean.md
rename to "03 - Framework \346\241\206\346\236\266/spring/spring bean.md"
index d1883dae..b51ddf3f 100644
--- a/03 - Framework/spring/spring bean.md	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/spring bean.md"	
@@ -1,30 +1,30 @@
-https://www.jianshu.com/p/3944792a5fff
-http://baijiahao.baidu.com/s?id=1596092490213053123&wfr=spider&for=pc
-
-Spring框架中，一旦把一个Bean纳入Spring IOC容器之中，这个Bean的生命周期就会交由容器进行管理，一般担当管理角色的是BeanFactory或者ApplicationContext
-
-下面以BeanFactory为例，说明一个Bean的生命周期活动
-
-包括BeanFactoryPostProcessor、BeanPostProcessor、InstantiationAwareBeanPostProcessor、BeanNameAware、BeanFactoryAware，InitializingBean等
-
-1. Bean的建立， 由BeanFactory读取Bean定义文件，并生成各个`实例化`
-2. Setter注入，执行Bean的`属性`依赖注入
-3. `BeanNameAware`的setBeanName(), 如果实现该接口，则执行其setBeanName方法
-4. `BeanFactoryAware`的setBeanFactory()，如果实现该接口，则执行其setBeanFactory方法
-5. `ApplicationContextAware`的setApplicationContext()方法，将bean所在的应用上下文的引用传入进来
-6. `BeanPostProcessor`的processBeforeInitialization()，如果有关联的processor，则在Bean初始化之前都会执行这个实例的processBeforeInitialization()方法
-7. `InitializingBean`的afterPropertiesSet()，如果实现了该接口，则执行其afterPropertiesSet()方法
-8. Bean定义文件中定义`init-method`
-9. `BeanPostProcessors`的processAfterInitialization()，如果有关联的processor，则在Bean初始化之前都会执行这个实例的processAfterInitialization()方法
-10. 此时，bean已经准备就绪了，可以被应用程序使用了，将一直驻留在应用上下文中，直到该应用上下文被销毁
-11. DisposableBean的destroy()，在容器关闭时，如果Bean类实现了该接口，则执行它的`destroy()`方法
-12. Bean定义文件中定义destroy-method，在容器关闭时，可以在Bean定义文件中使用“`destory-method`”定义的方法
-
-
-如果使用ApplicationContext来维护一个Bean的生命周期，则基本上与上边的流程相同，只不过在执行BeanNameAware的setBeanName()后，若有Bean类实现了org.springframework.context.ApplicationContextAware接口，则执行其setApplicationContext()方法，然后再进行BeanPostProcessors的processBeforeInitialization()
-实际上，ApplicationContext除了向BeanFactory那样维护容器外，还提供了更加丰富的框架功能，如Bean的消息，事件处理机制等
-
-
-scope为singleton
-VS
-scope为prototype
+https://www.jianshu.com/p/3944792a5fff
+http://baijiahao.baidu.com/s?id=1596092490213053123&wfr=spider&for=pc
+
+Spring框架中，一旦把一个Bean纳入Spring IOC容器之中，这个Bean的生命周期就会交由容器进行管理，一般担当管理角色的是BeanFactory或者ApplicationContext
+
+下面以BeanFactory为例，说明一个Bean的生命周期活动
+
+包括BeanFactoryPostProcessor、BeanPostProcessor、InstantiationAwareBeanPostProcessor、BeanNameAware、BeanFactoryAware，InitializingBean等
+
+1. Bean的建立， 由BeanFactory读取Bean定义文件，并生成各个`实例化`
+2. Setter注入，执行Bean的`属性`依赖注入
+3. `BeanNameAware`的setBeanName(), 如果实现该接口，则执行其setBeanName方法
+4. `BeanFactoryAware`的setBeanFactory()，如果实现该接口，则执行其setBeanFactory方法
+5. `ApplicationContextAware`的setApplicationContext()方法，将bean所在的应用上下文的引用传入进来
+6. `BeanPostProcessor`的processBeforeInitialization()，如果有关联的processor，则在Bean初始化之前都会执行这个实例的processBeforeInitialization()方法
+7. `InitializingBean`的afterPropertiesSet()，如果实现了该接口，则执行其afterPropertiesSet()方法
+8. Bean定义文件中定义`init-method`
+9. `BeanPostProcessors`的processAfterInitialization()，如果有关联的processor，则在Bean初始化之前都会执行这个实例的processAfterInitialization()方法
+10. 此时，bean已经准备就绪了，可以被应用程序使用了，将一直驻留在应用上下文中，直到该应用上下文被销毁
+11. DisposableBean的destroy()，在容器关闭时，如果Bean类实现了该接口，则执行它的`destroy()`方法
+12. Bean定义文件中定义destroy-method，在容器关闭时，可以在Bean定义文件中使用“`destory-method`”定义的方法
+
+
+如果使用ApplicationContext来维护一个Bean的生命周期，则基本上与上边的流程相同，只不过在执行BeanNameAware的setBeanName()后，若有Bean类实现了org.springframework.context.ApplicationContextAware接口，则执行其setApplicationContext()方法，然后再进行BeanPostProcessors的processBeforeInitialization()
+实际上，ApplicationContext除了向BeanFactory那样维护容器外，还提供了更加丰富的框架功能，如Bean的消息，事件处理机制等
+
+
+scope为singleton
+VS
+scope为prototype
diff --git a/03 - Framework/spring/spring.md "b/03 - Framework \346\241\206\346\236\266/spring/spring.md"
similarity index 99%
rename from 03 - Framework/spring/spring.md
rename to "03 - Framework \346\241\206\346\236\266/spring/spring.md"
index af9646e6..9b89c24c 100644
--- a/03 - Framework/spring/spring.md	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/spring.md"	
@@ -1,4 +1,4 @@
-## 什么是Spring
+jdbc## 什么是Spring
 Spring是一个开源的Java EE开发框架。Spring框架的核心功能可以应用在任何Java应用程序中，但对Java EE平台上的Web应用程序有更好的扩展性。Spring框架的目标是使得Java EE应用程序的开发更加简捷，通过使用POJO为基础的编程模型促进良好的编程风格。
 
 ## Spring有哪些优点
@@ -12,7 +12,7 @@ Spring是一个开源的Java EE开发框架。Spring框架的核心功能可以
 
 ## Spring框架有哪些模块
 Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成、Web、AOP（面向切面编程）、工具、消息和测试模块。
-**核心容器模块**：是spring中最核心的模块。负责Bean的创建，配置和管理。主要包括：beans,core,context,expression等模块。
+**核心jdbc容器模块**：是spring中最核心的模块。负责Bean的创建，配置和管理。主要包括：beans,core,context,expression等模块。
 **Spring的AOP模块**：主要负责对面向切面编程的支持，帮助应用对象解耦。
 **数据访问和集成模块**：包括JDBC，ORM，OXM，JMS和事务处理模块，其细节如下：
 JDBC模块提供了不再需要冗长的JDBC编码相关了JDBC的抽象层。
diff --git "a/03 - Framework/spring/spring\346\200\273\347\273\223.md" "b/03 - Framework \346\241\206\346\236\266/spring/spring\346\200\273\347\273\223.md"
similarity index 100%
rename from "03 - Framework/spring/spring\346\200\273\347\273\223.md"
rename to "03 - Framework \346\241\206\346\236\266/spring/spring\346\200\273\347\273\223.md"
diff --git "a/03 - Framework/spring/\344\272\213\345\212\241.png" "b/03 - Framework \346\241\206\346\236\266/spring/\344\272\213\345\212\241.png"
similarity index 100%
rename from "03 - Framework/spring/\344\272\213\345\212\241.png"
rename to "03 - Framework \346\241\206\346\236\266/spring/\344\272\213\345\212\241.png"
diff --git "a/03 - Framework/spring/\345\270\270\347\224\250\346\263\250\350\247\243.md" "b/03 - Framework \346\241\206\346\236\266/spring/\345\270\270\347\224\250\346\263\250\350\247\243.md"
similarity index 98%
rename from "03 - Framework/spring/\345\270\270\347\224\250\346\263\250\350\247\243.md"
rename to "03 - Framework \346\241\206\346\236\266/spring/\345\270\270\347\224\250\346\263\250\350\247\243.md"
index 9d593084..566eabfb 100644
--- "a/03 - Framework/spring/\345\270\270\347\224\250\346\263\250\350\247\243.md"	
+++ "b/03 - Framework \346\241\206\346\236\266/spring/\345\270\270\347\224\250\346\263\250\350\247\243.md"	
@@ -1,41 +1,41 @@
-http://www.cnblogs.com/loveincode/p/7118194.html
-
-@component （把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>）
-
-  @Repository、@Service和 @Controller。@Component是所有受Spring管理组件的通用形式；而@Repository、@Service和 @Controller则是@Component的细化
-
-@repository dao（实现dao访问）
-
-@service 服务（注入dao）
-
-@controller 控制器（注入服务）
-
-  @RequestBody  返回json结果数据
-
-  @RequestMapping 指定请求路径
-
-@Qualifier （指定注入Bean的名称）
-  如果容器中有一个以上匹配的Bean，则可以通过@Qualifier注解限定Bean的名称，指定哪个真正的bean将会被装配，应用于一个接口有多个实现类的情况。
-
-@Autowired
-  @Autowired顾名思义，默认采用byType自动装配策略 ，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，其作用是为了消除代码Java代码里面的getter/setter与bean属性中的property。
-
-  当然，getter看个人需求，如果私有属性需要对外提供的话，应当予以保留。
-
-  @Autowired默认按类型匹配的方式，在容器查找匹配的Bean，当有且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。
-
-  可以在 setter 方法中被用于自动连接bean
-
-@Resource
-  与@Autowired很相似 通过 by-name 方式自动注入
-
-@Configuration 把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。
-@Lazy (true)  表示延迟初始化
-@Scope 用于指定scope作用域的（用在类上）
-@PostConstruct 用于指定初始化方法（用在方法上）
-@PreDestory 用于指定销毁方法（用在方法上）
-@DependsOn 定义Bean初始化及销毁时的顺序
-@Primary 自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
-@PostConstruct 初始化注解
-@PreDestroy 摧毁注解 默认 单例  启动就加载
-@Async 异步方法调用
+http://www.cnblogs.com/loveincode/p/7118194.html
+
+@component （把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>）
+
+  @Repository、@Service和 @Controller。@Component是所有受Spring管理组件的通用形式；而@Repository、@Service和 @Controller则是@Component的细化
+
+@repository dao（实现dao访问）
+
+@service 服务（注入dao）
+
+@controller 控制器（注入服务）
+
+  @RequestBody  返回json结果数据
+
+  @RequestMapping 指定请求路径
+
+@Qualifier （指定注入Bean的名称）
+  如果容器中有一个以上匹配的Bean，则可以通过@Qualifier注解限定Bean的名称，指定哪个真正的bean将会被装配，应用于一个接口有多个实现类的情况。
+
+@Autowired
+  @Autowired顾名思义，默认采用byType自动装配策略 ，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，其作用是为了消除代码Java代码里面的getter/setter与bean属性中的property。
+
+  当然，getter看个人需求，如果私有属性需要对外提供的话，应当予以保留。
+
+  @Autowired默认按类型匹配的方式，在容器查找匹配的Bean，当有且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。
+
+  可以在 setter 方法中被用于自动连接bean
+
+@Resource
+  与@Autowired很相似 通过 by-name 方式自动注入
+
+@Configuration 把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。
+@Lazy (true)  表示延迟初始化
+@Scope 用于指定scope作用域的（用在类上）
+@PostConstruct 用于指定初始化方法（用在方法上）
+@PreDestory 用于指定销毁方法（用在方法上）
+@DependsOn 定义Bean初始化及销毁时的顺序
+@Primary 自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
+@PostConstruct 初始化注解
+@PreDestroy 摧毁注解 默认 单例  启动就加载
+@Async 异步方法调用
diff --git "a/03 - Framework \346\241\206\346\236\266/springboot/Spring Boot Loader.md" "b/03 - Framework \346\241\206\346\236\266/springboot/Spring Boot Loader.md"
new file mode 100644
index 00000000..58c671f9
--- /dev/null
+++ "b/03 - Framework \346\241\206\346\236\266/springboot/Spring Boot Loader.md"	
@@ -0,0 +1 @@
+https://www.jianshu.com/p/63a6e43e4147
diff --git "a/03 - Framework/springboot/druid\345\244\232\346\225\260\346\215\256\346\272\220\351\205\215\347\275\256.md" "b/03 - Framework \346\241\206\346\236\266/springboot/druid\345\244\232\346\225\260\346\215\256\346\272\220\351\205\215\347\275\256.md"
similarity index 100%
rename from "03 - Framework/springboot/druid\345\244\232\346\225\260\346\215\256\346\272\220\351\205\215\347\275\256.md"
rename to "03 - Framework \346\241\206\346\236\266/springboot/druid\345\244\232\346\225\260\346\215\256\346\272\220\351\205\215\347\275\256.md"
diff --git a/03 - Framework/springboot/new.txt "b/03 - Framework \346\241\206\346\236\266/springboot/new.txt"
similarity index 98%
rename from 03 - Framework/springboot/new.txt
rename to "03 - Framework \346\241\206\346\236\266/springboot/new.txt"
index a76673a7..c60ec14a 100644
--- a/03 - Framework/springboot/new.txt	
+++ "b/03 - Framework \346\241\206\346\236\266/springboot/new.txt"	
@@ -1,53 +1,53 @@
-http://blog.didispace.com/categories/Spring-Boot/
-
-简化了 配置 自动化配置 支持jar运行。
-
-在Spring Boot中多环境配置文件名需要满足application-{profile}.properties的格式，其中{profile}对应你的环境标识，比如：
-
-application-dev.properties：开发环境
-application-test.properties：测试环境
-application-prod.properties：生产环境
-
-至于哪个具体的配置文件会被加载，需要在application.properties文件中通过spring.profiles.active属性来设置，其值对应{profile}值。
-
-
-@Scheduled详解
-
-@Scheduled(fixedRate = 5000) ：上一次开始执行时间点之后5秒再执行
-@Scheduled(fixedDelay = 5000) ：上一次执行完毕时间点之后5秒再执行
-@Scheduled(initialDelay=1000, fixedRate=5000) ：第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次
-@Scheduled(cron="*/5 * * * * *") ：通过cron表达式定义规则
-
-@Async实现异步调用
-
-
-实现AOP的切面主要有以下几个要素：
-
-使用@Aspect注解将一个java类定义为切面类
-使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。
-	根据需要在切入点不同位置的切入内容
-	使用@Before在切入点开始处切入内容
-	使用@After在切入点结尾处切入内容
-	使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
-	使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容
-	使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑
-
-事务级别
-@Transactional(isolation = Isolation.DEFAULT)
-DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是：READ_COMMITTED。
-READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
-READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
-REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
-SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。
-
-传播行为
-@Transactional(propagation = Propagation.REQUIRED)
-REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
-SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
-MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
-REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
-NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
-NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
-NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于REQUIRED。
-
-cache 自动更新 删除
+http://blog.didispace.com/categories/Spring-Boot/
+
+简化了 配置 自动化配置 支持jar运行。
+
+在Spring Boot中多环境配置文件名需要满足application-{profile}.properties的格式，其中{profile}对应你的环境标识，比如：
+
+application-dev.properties：开发环境
+application-test.properties：测试环境
+application-prod.properties：生产环境
+
+至于哪个具体的配置文件会被加载，需要在application.properties文件中通过spring.profiles.active属性来设置，其值对应{profile}值。
+
+
+@Scheduled详解
+
+@Scheduled(fixedRate = 5000) ：上一次开始执行时间点之后5秒再执行
+@Scheduled(fixedDelay = 5000) ：上一次执行完毕时间点之后5秒再执行
+@Scheduled(initialDelay=1000, fixedRate=5000) ：第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次
+@Scheduled(cron="*/5 * * * * *") ：通过cron表达式定义规则
+
+@Async实现异步调用
+
+
+实现AOP的切面主要有以下几个要素：
+
+使用@Aspect注解将一个java类定义为切面类
+使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。
+	根据需要在切入点不同位置的切入内容
+	使用@Before在切入点开始处切入内容
+	使用@After在切入点结尾处切入内容
+	使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
+	使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容
+	使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑
+
+事务级别
+@Transactional(isolation = Isolation.DEFAULT)
+DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是：READ_COMMITTED。
+READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
+READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
+REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
+SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。
+
+传播行为
+@Transactional(propagation = Propagation.REQUIRED)
+REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
+SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
+MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
+REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
+NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
+NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
+NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于REQUIRED。
+
+cache 自动更新 删除
diff --git "a/03 - Framework/springboot/\345\277\253\351\200\237\345\205\245\351\227\250.md" "b/03 - Framework \346\241\206\346\236\266/springboot/\345\277\253\351\200\237\345\205\245\351\227\250.md"
similarity index 100%
rename from "03 - Framework/springboot/\345\277\253\351\200\237\345\205\245\351\227\250.md"
rename to "03 - Framework \346\241\206\346\236\266/springboot/\345\277\253\351\200\237\345\205\245\351\227\250.md"
diff --git "a/03 - Framework/springboot/\346\272\220\347\240\201.md" "b/03 - Framework \346\241\206\346\236\266/springboot/\346\272\220\347\240\201.md"
similarity index 100%
rename from "03 - Framework/springboot/\346\272\220\347\240\201.md"
rename to "03 - Framework \346\241\206\346\236\266/springboot/\346\272\220\347\240\201.md"
diff --git "a/03 - Framework/springcloud/01 Netflix Eureka \346\234\215\345\212\241\346\263\250\345\206\214\344\270\216\345\217\221\347\216\260.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/01 Netflix Eureka \346\234\215\345\212\241\346\263\250\345\206\214\344\270\216\345\217\221\347\216\260.md"
similarity index 100%
rename from "03 - Framework/springcloud/01 Netflix Eureka \346\234\215\345\212\241\346\263\250\345\206\214\344\270\216\345\217\221\347\216\260.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/01 Netflix Eureka \346\234\215\345\212\241\346\263\250\345\206\214\344\270\216\345\217\221\347\216\260.md"
diff --git "a/03 - Framework/springcloud/02 Netflix Ribbon \346\266\210\350\264\271\350\264\237\350\275\275\345\235\207\350\241\241.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/02 Netflix Ribbon \346\266\210\350\264\271\350\264\237\350\275\275\345\235\207\350\241\241.md"
similarity index 100%
rename from "03 - Framework/springcloud/02 Netflix Ribbon \346\266\210\350\264\271\350\264\237\350\275\275\345\235\207\350\241\241.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/02 Netflix Ribbon \346\266\210\350\264\271\350\264\237\350\275\275\345\235\207\350\241\241.md"
diff --git "a/03 - Framework/springcloud/03 Netflix Hystrix \346\226\255\350\267\257\345\231\250.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/03 Netflix Hystrix \346\226\255\350\267\257\345\231\250.md"
similarity index 100%
rename from "03 - Framework/springcloud/03 Netflix Hystrix \346\226\255\350\267\257\345\231\250.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/03 Netflix Hystrix \346\226\255\350\267\257\345\231\250.md"
diff --git "a/03 - Framework/springcloud/04 Config \345\210\206\345\270\203\345\274\217\351\205\215\347\275\256\344\270\255\345\277\203.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/04 Config \345\210\206\345\270\203\345\274\217\351\205\215\347\275\256\344\270\255\345\277\203.md"
similarity index 100%
rename from "03 - Framework/springcloud/04 Config \345\210\206\345\270\203\345\274\217\351\205\215\347\275\256\344\270\255\345\277\203.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/04 Config \345\210\206\345\270\203\345\274\217\351\205\215\347\275\256\344\270\255\345\277\203.md"
diff --git "a/03 - Framework/springcloud/05 Netflix Zuul \346\234\215\345\212\241\347\275\221\345\205\263.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/05 Netflix Zuul \346\234\215\345\212\241\347\275\221\345\205\263.md"
similarity index 100%
rename from "03 - Framework/springcloud/05 Netflix Zuul \346\234\215\345\212\241\347\275\221\345\205\263.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/05 Netflix Zuul \346\234\215\345\212\241\347\275\221\345\205\263.md"
diff --git "a/03 - Framework/springcloud/06 Eureka Server\351\253\230\345\217\257\347\224\250\346\234\215\345\212\241\346\263\250\345\206\214\344\270\255\345\277\203.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/06 Eureka Server\351\253\230\345\217\257\347\224\250\346\234\215\345\212\241\346\263\250\345\206\214\344\270\255\345\277\203.md"
similarity index 100%
rename from "03 - Framework/springcloud/06 Eureka Server\351\253\230\345\217\257\347\224\250\346\234\215\345\212\241\346\263\250\345\206\214\344\270\255\345\277\203.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/06 Eureka Server\351\253\230\345\217\257\347\224\250\346\234\215\345\212\241\346\263\250\345\206\214\344\270\255\345\277\203.md"
diff --git "a/03 - Framework/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Kafka.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Kafka.md"
similarity index 100%
rename from "03 - Framework/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Kafka.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Kafka.md"
diff --git "a/03 - Framework/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Rabbit.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Rabbit.md"
similarity index 100%
rename from "03 - Framework/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Rabbit.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/07 \346\266\210\346\201\257\346\200\273\347\272\277 Rabbit.md"
diff --git a/03 - Framework/springcloud/new.txt "b/03 - Framework \346\241\206\346\236\266/springcloud/new.txt"
similarity index 100%
rename from 03 - Framework/springcloud/new.txt
rename to "03 - Framework \346\241\206\346\236\266/springcloud/new.txt"
diff --git "a/03 - Framework/springcloud/\344\270\200\346\226\207\350\257\273\346\207\202 Spring Boot\343\200\201\345\276\256\346\234\215\345\212\241\346\236\266\346\236\204\345\222\214\345\244\247\346\225\260\346\215\256\346\262\273\347\220\206\344\270\211\350\200\205\344\271\213\351\227\264\347\232\204\346\225\205\344\272\213.md" "b/03 - Framework \346\241\206\346\236\266/springcloud/\344\270\200\346\226\207\350\257\273\346\207\202 Spring Boot\343\200\201\345\276\256\346\234\215\345\212\241\346\236\266\346\236\204\345\222\214\345\244\247\346\225\260\346\215\256\346\262\273\347\220\206\344\270\211\350\200\205\344\271\213\351\227\264\347\232\204\346\225\205\344\272\213.md"
similarity index 100%
rename from "03 - Framework/springcloud/\344\270\200\346\226\207\350\257\273\346\207\202 Spring Boot\343\200\201\345\276\256\346\234\215\345\212\241\346\236\266\346\236\204\345\222\214\345\244\247\346\225\260\346\215\256\346\262\273\347\220\206\344\270\211\350\200\205\344\271\213\351\227\264\347\232\204\346\225\205\344\272\213.md"
rename to "03 - Framework \346\241\206\346\236\266/springcloud/\344\270\200\346\226\207\350\257\273\346\207\202 Spring Boot\343\200\201\345\276\256\346\234\215\345\212\241\346\236\266\346\236\204\345\222\214\345\244\247\346\225\260\346\215\256\346\262\273\347\220\206\344\270\211\350\200\205\344\271\213\351\227\264\347\232\204\346\225\205\344\272\213.md"
diff --git "a/03 - Framework/springmvc/SpringMVC\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.md" "b/03 - Framework \346\241\206\346\236\266/springmvc/SpringMVC\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.md"
similarity index 97%
rename from "03 - Framework/springmvc/SpringMVC\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.md"
rename to "03 - Framework \346\241\206\346\236\266/springmvc/SpringMVC\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.md"
index c3ab194d..27fe07a3 100644
--- "a/03 - Framework/springmvc/SpringMVC\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.md"	
+++ "b/03 - Framework \346\241\206\346\236\266/springmvc/SpringMVC\345\210\235\345\247\213\345\214\226\350\277\207\347\250\213.md"	
@@ -1,40 +1,40 @@
-https://blog.csdn.net/AooMiao/article/details/77946776
-http://www.jfox.info/springmvcspringmvc%E5%90%AF%E5%8A%A8%E5%88%9D%E5%A7%8B%E5%8C%96%E8%BF%87%E7%A8%8B.html
-
-HttpServlet → HttpServletBean → FrameworkServlet → DispatcherServlet
-
-DispatcherServlet是一个Servlet
-init
-
-web应用启动时扫描web.xml文件，扫描到`DispatcherServlet`，对其进行初始化
-调用DispatcherServlet父类的父类`HttpServletBean的init()`方法，把配置DispatcherServlet的初始化参数设置到DispatcherServlet中，
-
-调用子类`FrameworkServlet的initServletBean()`方法
-initServletBean()创建springMVC容器实例并初始化容器，并且和spring父容器进行关联，使得mvc容器能访问spring容器里面的bean，
-
-`initWebApplicationContext`
-
-`createWebApplicationContext(WebApplicationContext parent)`
-
-之后调用子类DispatcherServlet的`onRefresh(ApplicationContext context)`方法
-onRefresh(ApplicationContext context)进行DispatcherServlet的策略组件初始化工作，url映射初始化，文件解析初始化，运行适配器初始化等等。
-
-```java
-
-@Override
-protected void onRefresh(ApplicationContext context) {
-    initStrategies(context);
-}
-
-protected void initStrategies(ApplicationContext context) {
-    initMultipartResolver(context);//文件上传解析
-    initLocaleResolver(context);//本地解析
-    initThemeResolver(context);//主题解析
-    initHandlerMappings(context);//url请求映射
-    initHandlerAdapters(context);//初始化真正调用controloler方法的类
-    initHandlerExceptionResolvers(context);//异常解析
-    initRequestToViewNameTranslator(context);
-    initViewResolvers(context);//视图解析
-    initFlashMapManager(context);
-}
-```
+https://blog.csdn.net/AooMiao/article/details/77946776
+http://www.jfox.info/springmvcspringmvc%E5%90%AF%E5%8A%A8%E5%88%9D%E5%A7%8B%E5%8C%96%E8%BF%87%E7%A8%8B.html
+
+HttpServlet → HttpServletBean → FrameworkServlet → DispatcherServlet
+
+DispatcherServlet是一个Servlet
+init
+
+web应用启动时扫描web.xml文件，扫描到`DispatcherServlet`，对其进行初始化
+调用DispatcherServlet父类的父类`HttpServletBean的init()`方法，把配置DispatcherServlet的初始化参数设置到DispatcherServlet中，
+
+调用子类`FrameworkServlet的initServletBean()`方法
+initServletBean()创建springMVC容器实例并初始化容器，并且和spring父容器进行关联，使得mvc容器能访问spring容器里面的bean，
+
+`initWebApplicationContext`
+
+`createWebApplicationContext(WebApplicationContext parent)`
+
+之后调用子类DispatcherServlet的`onRefresh(ApplicationContext context)`方法
+onRefresh(ApplicationContext context)进行DispatcherServlet的策略组件初始化工作，url映射初始化，文件解析初始化，运行适配器初始化等等。
+
+```java
+
+@Override
+protected void onRefresh(ApplicationContext context) {
+    initStrategies(context);
+}
+
+protected void initStrategies(ApplicationContext context) {
+    initMultipartResolver(context);//文件上传解析
+    initLocaleResolver(context);//本地解析
+    initThemeResolver(context);//主题解析
+    initHandlerMappings(context);//url请求映射
+    initHandlerAdapters(context);//初始化真正调用controloler方法的类
+    initHandlerExceptionResolvers(context);//异常解析
+    initRequestToViewNameTranslator(context);
+    initViewResolvers(context);//视图解析
+    initFlashMapManager(context);
+}
+```
diff --git "a/03 - Framework/springmvc/dispatcherServler\345\244\204\347\220\206.png" "b/03 - Framework \346\241\206\346\236\266/springmvc/dispatcherServler\345\244\204\347\220\206.png"
similarity index 100%
rename from "03 - Framework/springmvc/dispatcherServler\345\244\204\347\220\206.png"
rename to "03 - Framework \346\241\206\346\236\266/springmvc/dispatcherServler\345\244\204\347\220\206.png"
diff --git "a/03 - Framework/springmvc/springmvc\345\234\250tomcat\344\270\255\347\232\204\346\211\247\350\241\214\350\277\207\347\250\213.md" "b/03 - Framework \346\241\206\346\236\266/springmvc/springmvc\345\234\250tomcat\344\270\255\347\232\204\346\211\247\350\241\214\350\277\207\347\250\213.md"
similarity index 98%
rename from "03 - Framework/springmvc/springmvc\345\234\250tomcat\344\270\255\347\232\204\346\211\247\350\241\214\350\277\207\347\250\213.md"
rename to "03 - Framework \346\241\206\346\236\266/springmvc/springmvc\345\234\250tomcat\344\270\255\347\232\204\346\211\247\350\241\214\350\277\207\347\250\213.md"
index 416e1cda..ad6c7262 100644
--- "a/03 - Framework/springmvc/springmvc\345\234\250tomcat\344\270\255\347\232\204\346\211\247\350\241\214\350\277\207\347\250\213.md"	
+++ "b/03 - Framework \346\241\206\346\236\266/springmvc/springmvc\345\234\250tomcat\344\270\255\347\232\204\346\211\247\350\241\214\350\277\207\347\250\213.md"	
@@ -1,126 +1,126 @@
-https://www.cnblogs.com/hantalk/p/6652967.html
-
-一、WEB容器在启动时，它会为每个WEB应用程序都创建一个对应的ServletContext对象（每个web应用程序唯一），它代表当前web应用web容器提供其一个全局的上下文环境，其为后面的spring IoC容器提供宿主环境；
-
-二、读取web.xml
-
-服务器软件或容器如（tomcat）加载项目中的web.xml文件，通过其中的各种配置来启动项目，只有其中配置的各项均无误时，项目才能正确启动。web.xml有多项标签，在其加载的过程中顺序依次为：**context-param >> listener >> fileter >> servlet​**。（同类多个节点以出现顺序依次加载）
-
-1、ServletContext创建后，通过启动WebApplicationContext的Servlet（org.springframework.web.context.ContextLoaderServlet）或Web容器监听器（org.springframework.web.context.ContextLoaderListener）触发初始化WebApplicationContext事件，这个就是spring的ioc容器；(application context的初始化过程，可参考：http://www.cnblogs.com/hantalk/p/6647772.html）
-  ```xml
-  <listener>
-    <description>Spring配置(此配置在所有监听器之前加载)</description>
-    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
-  </listener>
-  ```
-  ```xml
-  <servlet>
-    <servlet-name>context</servlet-name>
-    <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
-    <load-on-startup>1</load-on-startup>
-  </servlet>
-  ```
-
-2、容器会读取context-param(springmvc中可以没有这个context-param，即WebApplicationContext不用配置具体数据)，spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，context-param为属性value对并存入servletContext；
-``` java
-servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,this.context);
-```
-例如:
-```xml
-<context-param>
-      <param-name>contextConfigLocation</param-name>
-      <param-value>
-          classpath:spring-common-config.xml,
-          classpath:spring-budget-config.xml
-      </param-value>
-</context-param>
-```
-3、读取listener创建监听，根据指定的类路径来实例化过滤器filter；
-
-4、初始化web.xml中的dispatcherservlet
-
-首先，利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE从ServletContext中获取之前的WebApplicationContext作为自己上下文的parent上下文。
-
-然后，读取/WEB-INF/[servlet名字]-servlet.xml文件，初始化自己持有的上下文。初始化完毕后，spring也将dispatcherservlet的上下文存到ServletContext中。
-
-DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，读下面代码，可以在initStrategies方法中看到主要职责如下：
-
-1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
-
-2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；
-
-3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；
-
-4、通过ViewResolver解析逻辑视图名到具体视图实现；
-
-5、本地化解析；
-
-6、渲染具体的视图等；
-
-7、如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。
-
-``` java
-public class DispatcherServlet extends FrameworkServlet {
-     //实现子类的onRefresh()方法，该方法委托为initStrategies()方法。
-    @Override
-    protected void onRefresh(ApplicationContext context) {
-       initStrategies(context);
-    }
-
-    //初始化默认的Spring Web MVC框架使用的策略（如HandlerMapping）
-    protected void initStrategies(ApplicationContext context) {
-       initMultipartResolver(context);
-       initLocaleResolver(context);
-       initThemeResolver(context);
-       initHandlerMappings(context);
-       initHandlerAdapters(context);
-       initHandlerExceptionResolvers(context);
-       initRequestToViewNameTranslator(context);
-       initViewResolvers(context);
-       initFlashMapManager(context);
-    }
-}
-```
-三、具体的请求处理
-
-  <img src="dispatcherServler处理.png">
-
-
-1、首先用户发送请求http://localhost:9080/springmvc-chapter2/hello到web容器，web容器根据“/hello”路径映射到DispatcherServlet（url-pattern为/）进行处理；
-
-2、当收到请求时，dispatcherservlet将请求交给handlerMapping，让它找出对应请求的handlerExecutionChain对象，handlerExecutionChain返回拦截器和处理器。handlerExecutionChain是一个执行链，它包含一个处理该请求的handler（处理器，就是代码中的xxxController），同时还可能包括若干个对该请求实施拦截的handlerInterceptor（拦截器）;
-
-3、SimpleControllerHandlerAdapter将HandlerExecutionChain中的处理器（xxxController）适配为SimpleControllerHandlerAdapter；
-
-4、SimpleControllerHandlerAdapter将会调用xxxController中的具体方法进行功能处理，该处理方法返回一个ModelAndView给DispatcherServlet；handlerAdapter对外有三个方法API：
-
-  ``` java
-  //判断这个adapter是否可以处理这类handler
-
-  boolean supports(Object handler);
-
-  //封装handler处理request的逻辑
-
-  ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
-
-  long getLastModified(HttpServletRequest request, Object handler);
-
-  ```
-handlermapping是把请求找到对应的处理对象，具体用什么方法处理它不管。而handlerAdapter正是调用具体的方法处理请求。
-
-5、dispatherServlet通过配置文件中的ViewResolver，把controller中的modelAndview的数据传递到前端模板freemarker/velocity；
-
-6、前端模板渲染，将在处理器传入的模型数据在视图中展示出来；
-
-7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
-
-
-参考：
-
-http://www.imooc.com/article/5385
-
-https://segmentfault.com/q/1010000000210417
-
-http://sishu ok.com/forum/blogPost/list/5188.html（去掉空格）
-
-http://sishuo k.com/forum/blogPost/list/5160.html（去掉空格）
+https://www.cnblogs.com/hantalk/p/6652967.html
+
+一、WEB容器在启动时，它会为每个WEB应用程序都创建一个对应的ServletContext对象（每个web应用程序唯一），它代表当前web应用web容器提供其一个全局的上下文环境，其为后面的spring IoC容器提供宿主环境；
+
+二、读取web.xml
+
+服务器软件或容器如（tomcat）加载项目中的web.xml文件，通过其中的各种配置来启动项目，只有其中配置的各项均无误时，项目才能正确启动。web.xml有多项标签，在其加载的过程中顺序依次为：**context-param >> listener >> fileter >> servlet​**。（同类多个节点以出现顺序依次加载）
+
+1、ServletContext创建后，通过启动WebApplicationContext的Servlet（org.springframework.web.context.ContextLoaderServlet）或Web容器监听器（org.springframework.web.context.ContextLoaderListener）触发初始化WebApplicationContext事件，这个就是spring的ioc容器；(application context的初始化过程，可参考：http://www.cnblogs.com/hantalk/p/6647772.html）
+  ```xml
+  <listener>
+    <description>Spring配置(此配置在所有监听器之前加载)</description>
+    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
+  </listener>
+  ```
+  ```xml
+  <servlet>
+    <servlet-name>context</servlet-name>
+    <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
+    <load-on-startup>1</load-on-startup>
+  </servlet>
+  ```
+
+2、容器会读取context-param(springmvc中可以没有这个context-param，即WebApplicationContext不用配置具体数据)，spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，context-param为属性value对并存入servletContext；
+``` java
+servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,this.context);
+```
+例如:
+```xml
+<context-param>
+      <param-name>contextConfigLocation</param-name>
+      <param-value>
+          classpath:spring-common-config.xml,
+          classpath:spring-budget-config.xml
+      </param-value>
+</context-param>
+```
+3、读取listener创建监听，根据指定的类路径来实例化过滤器filter；
+
+4、初始化web.xml中的dispatcherservlet
+
+首先，利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE从ServletContext中获取之前的WebApplicationContext作为自己上下文的parent上下文。
+
+然后，读取/WEB-INF/[servlet名字]-servlet.xml文件，初始化自己持有的上下文。初始化完毕后，spring也将dispatcherservlet的上下文存到ServletContext中。
+
+DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，读下面代码，可以在initStrategies方法中看到主要职责如下：
+
+1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
+
+2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；
+
+3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；
+
+4、通过ViewResolver解析逻辑视图名到具体视图实现；
+
+5、本地化解析；
+
+6、渲染具体的视图等；
+
+7、如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。
+
+``` java
+public class DispatcherServlet extends FrameworkServlet {
+     //实现子类的onRefresh()方法，该方法委托为initStrategies()方法。
+    @Override
+    protected void onRefresh(ApplicationContext context) {
+       initStrategies(context);
+    }
+
+    //初始化默认的Spring Web MVC框架使用的策略（如HandlerMapping）
+    protected void initStrategies(ApplicationContext context) {
+       initMultipartResolver(context);
+       initLocaleResolver(context);
+       initThemeResolver(context);
+       initHandlerMappings(context);
+       initHandlerAdapters(context);
+       initHandlerExceptionResolvers(context);
+       initRequestToViewNameTranslator(context);
+       initViewResolvers(context);
+       initFlashMapManager(context);
+    }
+}
+```
+三、具体的请求处理
+
+  <img src="dispatcherServler处理.png">
+
+
+1、首先用户发送请求http://localhost:9080/springmvc-chapter2/hello到web容器，web容器根据“/hello”路径映射到DispatcherServlet（url-pattern为/）进行处理；
+
+2、当收到请求时，dispatcherservlet将请求交给handlerMapping，让它找出对应请求的handlerExecutionChain对象，handlerExecutionChain返回拦截器和处理器。handlerExecutionChain是一个执行链，它包含一个处理该请求的handler（处理器，就是代码中的xxxController），同时还可能包括若干个对该请求实施拦截的handlerInterceptor（拦截器）;
+
+3、SimpleControllerHandlerAdapter将HandlerExecutionChain中的处理器（xxxController）适配为SimpleControllerHandlerAdapter；
+
+4、SimpleControllerHandlerAdapter将会调用xxxController中的具体方法进行功能处理，该处理方法返回一个ModelAndView给DispatcherServlet；handlerAdapter对外有三个方法API：
+
+  ``` java
+  //判断这个adapter是否可以处理这类handler
+
+  boolean supports(Object handler);
+
+  //封装handler处理request的逻辑
+
+  ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
+
+  long getLastModified(HttpServletRequest request, Object handler);
+
+  ```
+handlermapping是把请求找到对应的处理对象，具体用什么方法处理它不管。而handlerAdapter正是调用具体的方法处理请求。
+
+5、dispatherServlet通过配置文件中的ViewResolver，把controller中的modelAndview的数据传递到前端模板freemarker/velocity；
+
+6、前端模板渲染，将在处理器传入的模型数据在视图中展示出来；
+
+7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
+
+
+参考：
+
+http://www.imooc.com/article/5385
+
+https://segmentfault.com/q/1010000000210417
+
+http://sishu ok.com/forum/blogPost/list/5188.html（去掉空格）
+
+http://sishuo k.com/forum/blogPost/list/5160.html（去掉空格）
diff --git "a/03 - Framework/springmvc/\350\257\267\346\261\202\345\217\202\346\225\260\344\274\240\345\200\274\346\263\250\350\247\243.txt" "b/03 - Framework \346\241\206\346\236\266/springmvc/\350\257\267\346\261\202\345\217\202\346\225\260\344\274\240\345\200\274\346\263\250\350\247\243.txt"
similarity index 95%
rename from "03 - Framework/springmvc/\350\257\267\346\261\202\345\217\202\346\225\260\344\274\240\345\200\274\346\263\250\350\247\243.txt"
rename to "03 - Framework \346\241\206\346\236\266/springmvc/\350\257\267\346\261\202\345\217\202\346\225\260\344\274\240\345\200\274\346\263\250\350\247\243.txt"
index fc9ee964..cc95e5df 100644
--- "a/03 - Framework/springmvc/\350\257\267\346\261\202\345\217\202\346\225\260\344\274\240\345\200\274\346\263\250\350\247\243.txt"	
+++ "b/03 - Framework \346\241\206\346\236\266/springmvc/\350\257\267\346\261\202\345\217\202\346\225\260\344\274\240\345\200\274\346\263\250\350\247\243.txt"	
@@ -1,23 +1,23 @@
-即若客户端通过POST方法，
-
-路径变量（url）
-内容变量（http body）
-头变量（header）
-
-
-
-@PathVariable 
-路径变量（url）
-
-@RequestParam
-在http body中传递的参数为key=value表单形式，则可用@RequestParam进行解析；
-
-@ModelAttribute
-在http body中传递的参数为key=value表单形式，用@ModelAttribute组织成对象
-
-
-@RequestBody
-若传递的参数为JSON形式，则使用@RequestBody注解进行解析。
-
-简单类型不能使用@RequestBody
-
+即若客户端通过POST方法，
+
+路径变量（url）
+内容变量（http body）
+头变量（header）
+
+
+
+@PathVariable 
+路径变量（url）
+
+@RequestParam
+在http body中传递的参数为key=value表单形式，则可用@RequestParam进行解析；
+
+@ModelAttribute
+在http body中传递的参数为key=value表单形式，用@ModelAttribute组织成对象
+
+
+@RequestBody
+若传递的参数为JSON形式，则使用@RequestBody注解进行解析。
+
+简单类型不能使用@RequestBody
+
diff --git "a/03 - Framework \346\241\206\346\236\266/springsession.md/readme.md" "b/03 - Framework \346\241\206\346\236\266/springsession.md/readme.md"
new file mode 100644
index 00000000..4e5777d8
--- /dev/null
+++ "b/03 - Framework \346\241\206\346\236\266/springsession.md/readme.md"	
@@ -0,0 +1,33 @@
+
+session - cookie
+```java
+package org.springframework.session.web.http;
+DefaultCookieSerializer
+
+
+private String cookieName = "SESSION";
+private boolean useBase64Encoding = true;
+
+```
+默认name是 SESSION
+并且cookie是session经过`base64`编码后的值
+
+如
+sessionId=aa853792-4214-474c-807f-f805fbcf17cf
+则
+cookie： SESSION=YWE4NTM3OTItNDIxNC00NzRjLTgwN2YtZjgwNWZiY2YxN2Nm
+
+
+``` session的有效期
+maxInactiveIntervalInSeconds = 60 * 60 * 24
+```
+session 有效期从最后一次访问算起
+
+# session方案：
+key：sessionId:userId
+key: userId:用户信息
+
+每次更新用户只需要刷新userId对应的值即可。
+
+实现HttpSessionListener监听session创建与销毁 ，sessionId与session的对应关系。可以通过sessionId获取Session
+https://blog.csdn.net/dennis19910627/article/details/45112615?locationNum=1&fps=1
diff --git "a/03 - Framework/ssh2/SSH\346\241\206\346\236\266\351\241\271\347\233\256\345\274\200\345\217\221\345\221\275\345\220\215\350\247\204\350\214\203.txt" "b/03 - Framework \346\241\206\346\236\266/ssh2/SSH\346\241\206\346\236\266\351\241\271\347\233\256\345\274\200\345\217\221\345\221\275\345\220\215\350\247\204\350\214\203.txt"
similarity index 95%
rename from "03 - Framework/ssh2/SSH\346\241\206\346\236\266\351\241\271\347\233\256\345\274\200\345\217\221\345\221\275\345\220\215\350\247\204\350\214\203.txt"
rename to "03 - Framework \346\241\206\346\236\266/ssh2/SSH\346\241\206\346\236\266\351\241\271\347\233\256\345\274\200\345\217\221\345\221\275\345\220\215\350\247\204\350\214\203.txt"
index 715e650a..f9f76ad4 100644
--- "a/03 - Framework/ssh2/SSH\346\241\206\346\236\266\351\241\271\347\233\256\345\274\200\345\217\221\345\221\275\345\220\215\350\247\204\350\214\203.txt"	
+++ "b/03 - Framework \346\241\206\346\236\266/ssh2/SSH\346\241\206\346\236\266\351\241\271\347\233\256\345\274\200\345\217\221\345\221\275\345\220\215\350\247\204\350\214\203.txt"	
@@ -1,101 +1,101 @@
-SSH�����Ŀ���������淶 
-һ����������������淶
-
-����ԭ�򣺰���������ĸСд���������á��շ��ʶ�����������£�
-
-1.      Action�����ڰ������淶��com.xdsc.action.��ϵͳ����
-
-    ��ѧ������ϵͳ��com.xdsc.action.xsgl_system 
-
-2.      Action�������淶��ģ���� + ��׺Action ��
-
-    ��UserAction
-
-3.      DAO��ӿ������ڰ������淶��com.xdsc.dao.��ϵͳ����
-
-    ��ѧ������ϵͳ: com.xdsc.dao.xsgl_system
-
-4.      DAO��ӿ��������淶��ģ���� + ��׺DAO����ע��DAO��д��
-
-    ��UserDAO
-
-5.      DAO��ʵ�������ڰ������淶��com.xdsc.dao.��ϵͳ����.impl
-
-    ��ѧ������ϵͳ:com.xdsc.dao.xsgl_system.impl
-
-6.      DAO��ʵ���������淶��ģ����+DAOImpl��ע��Impl��һ����ĸ��д��
-
-    ��UserDAOImpl
-
-7.      model�������ڰ������淶��com.xdsc.model.��ϵͳ����
-
-    ��ѧ������ϵͳ:com.xdsc.model.xsgl_system
-
-8.      model���������淶��ģ����
-
-    ��:User
-
-9.      service��ӿ������ڰ������淶��com.xdsc.service.��ϵͳ����
-
-    ��ѧ������ϵͳ:com.xdsc.service.xsgl_system
-
-10. service��ӿ��������淶��ģ����+Manager
-
-    �磺UserManager
-
-11. service��ʵ�������ڰ������淶��com.xdsc.service.��ϵͳ����.impl
-
-    ��ѧ������ϵͳ:com.xdsc.service.xsgl_system.impl
-
-12. service��ʵ���������淶��ģ����+ManagerImpl
-
-    �磺UserManagerImpl
-
-13. util�㹫�������ڰ������淶��com.xdsc.util
-
-    �����������淶��HibernateUtil
-
-���������ļ������淶
-
-����ԭ�򣺱��������ԡ�id�Ⱦ����á��շ��ʶ����������ĸ����Сд��
-
-1.      struts.xml 
-
-    package�����淶����ϵͳ���ƣ���xsgl_system
-
-    Action�����淶������ģ��������user
-
-2.      beans.xml
-
-   bean�����淶������ģ�飬��userManager
-
-3.      hibernate.cfg.xml
-
-   ��Ĭ�Ϲ淶
-
-4.      web.xml
-
-    ��Ĭ�Ϲ淶
-
-5.model�����Ӧ�����ļ�
-
-    ��Ĭ�Ϲ淶
-
-�������������淶
-
-1.    ����������
-
-    ����������ĸ����Сд������ñ������ж��������ɣ�����ĵ�������ĸ��д�������뵥��֮�䲻Ҫʹ��"_"�����ӣ����������ʿ��Ʊ���Ϊ˽�У� ���Զ�������setter��getter������
-
-2.    ����������
-
-    ������ĸ��д������ж��������ɣ������뵥��֮���ԡ� _�����������Ҹñ��������ǹ�������̬��final����     
-
-3.    ����������
-
-    ����ĸ����Сд������ñ������ж��������ɣ�����ĵ�������ĸ��д�������뵥��֮�䲻Ҫʹ��"_"�����ӡ����ʲ�Ҫʹ������
-
-4.jsp�ļ�����
-
-    ���շ��ʶ�����ҵ����뵥��֮�䲻Ҫʹ��"_"�����ӡ�
-
+SSH�����Ŀ���������淶 
+һ����������������淶
+
+����ԭ�򣺰���������ĸСд���������á��շ��ʶ�����������£�
+
+1.      Action�����ڰ������淶��com.xdsc.action.��ϵͳ����
+
+    ��ѧ������ϵͳ��com.xdsc.action.xsgl_system 
+
+2.      Action�������淶��ģ���� + ��׺Action ��
+
+    ��UserAction
+
+3.      DAO��ӿ������ڰ������淶��com.xdsc.dao.��ϵͳ����
+
+    ��ѧ������ϵͳ: com.xdsc.dao.xsgl_system
+
+4.      DAO��ӿ��������淶��ģ���� + ��׺DAO����ע��DAO��д��
+
+    ��UserDAO
+
+5.      DAO��ʵ�������ڰ������淶��com.xdsc.dao.��ϵͳ����.impl
+
+    ��ѧ������ϵͳ:com.xdsc.dao.xsgl_system.impl
+
+6.      DAO��ʵ���������淶��ģ����+DAOImpl��ע��Impl��һ����ĸ��д��
+
+    ��UserDAOImpl
+
+7.      model�������ڰ������淶��com.xdsc.model.��ϵͳ����
+
+    ��ѧ������ϵͳ:com.xdsc.model.xsgl_system
+
+8.      model���������淶��ģ����
+
+    ��:User
+
+9.      service��ӿ������ڰ������淶��com.xdsc.service.��ϵͳ����
+
+    ��ѧ������ϵͳ:com.xdsc.service.xsgl_system
+
+10. service��ӿ��������淶��ģ����+Manager
+
+    �磺UserManager
+
+11. service��ʵ�������ڰ������淶��com.xdsc.service.��ϵͳ����.impl
+
+    ��ѧ������ϵͳ:com.xdsc.service.xsgl_system.impl
+
+12. service��ʵ���������淶��ģ����+ManagerImpl
+
+    �磺UserManagerImpl
+
+13. util�㹫�������ڰ������淶��com.xdsc.util
+
+    �����������淶��HibernateUtil
+
+���������ļ������淶
+
+����ԭ�򣺱��������ԡ�id�Ⱦ����á��շ��ʶ����������ĸ����Сд��
+
+1.      struts.xml 
+
+    package�����淶����ϵͳ���ƣ���xsgl_system
+
+    Action�����淶������ģ��������user
+
+2.      beans.xml
+
+   bean�����淶������ģ�飬��userManager
+
+3.      hibernate.cfg.xml
+
+   ��Ĭ�Ϲ淶
+
+4.      web.xml
+
+    ��Ĭ�Ϲ淶
+
+5.model�����Ӧ�����ļ�
+
+    ��Ĭ�Ϲ淶
+
+�������������淶
+
+1.    ����������
+
+    ����������ĸ����Сд������ñ������ж��������ɣ�����ĵ�������ĸ��д�������뵥��֮�䲻Ҫʹ��"_"�����ӣ����������ʿ��Ʊ���Ϊ˽�У� ���Զ�������setter��getter������
+
+2.    ����������
+
+    ������ĸ��д������ж��������ɣ������뵥��֮���ԡ� _�����������Ҹñ��������ǹ�������̬��final����     
+
+3.    ����������
+
+    ����ĸ����Сд������ñ������ж��������ɣ�����ĵ�������ĸ��д�������뵥��֮�䲻Ҫʹ��"_"�����ӡ����ʲ�Ҫʹ������
+
+4.jsp�ļ�����
+
+    ���շ��ʶ�����ҵ����뵥��֮�䲻Ҫʹ��"_"�����ӡ�
+
diff --git a/03 - Framework/ssh2/struts.md "b/03 - Framework \346\241\206\346\236\266/ssh2/struts.md"
similarity index 100%
rename from 03 - Framework/ssh2/struts.md
rename to "03 - Framework \346\241\206\346\236\266/ssh2/struts.md"
diff --git "a/03 - Framework/ssh2/\346\226\260\345\273\272 Microsoft Word \346\226\207\346\241\243.docx" "b/03 - Framework \346\241\206\346\236\266/ssh2/\346\226\260\345\273\272 Microsoft Word \346\226\207\346\241\243.docx"
similarity index 100%
rename from "03 - Framework/ssh2/\346\226\260\345\273\272 Microsoft Word \346\226\207\346\241\243.docx"
rename to "03 - Framework \346\241\206\346\236\266/ssh2/\346\226\260\345\273\272 Microsoft Word \346\226\207\346\241\243.docx"
diff --git "a/04 - Middleware/Activiti/\345\237\272\346\234\254\350\256\244\350\257\206.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Activiti/\345\237\272\346\234\254\350\256\244\350\257\206.txt"
similarity index 99%
rename from "04 - Middleware/Activiti/\345\237\272\346\234\254\350\256\244\350\257\206.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Activiti/\345\237\272\346\234\254\350\256\244\350\257\206.txt"
index c88fab00..a0f0395d 100644
--- "a/04 - Middleware/Activiti/\345\237\272\346\234\254\350\256\244\350\257\206.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Activiti/\345\237\272\346\234\254\350\256\244\350\257\206.txt"	
@@ -1,23 +1,23 @@
-工作流（Workflow），就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。
-通俗的说，流程就是多个人在一起合作完成某件事情的步骤，把步骤变成计算机能理解的形式就是工作流。
-
-
-工作流(Workflow)
-就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。
-
-工作流管理系统(Workflow Management System, WfMS)
-是一个软件系统，它完成工作量的定义和管理，并按照在系统中预先定义好的工作流规则进行工作流实例的执行。工作流管理系统不是企业的业务系统，而是为企业的业务系统的运行提供了一个软件的支撑环境。
-
-工作流管理联盟(WfMC，Workflow Management Coalition)
-给出的关于工作流管理系统的定义是：工作流管理系统是一个软件系统，它通过执行经过计算的流程定义去支持一批专门设定的业务流程。工作流管理系统被用来定义、管理、和执行工作流程。
-
-工作流管理系统的目标：管理工作的流程以确保工作在正确的时间被期望的人员所执行——在自动化进行的业务过程中插入人工的执行和干预。 
-
-
-Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理（BPM）框架，
-它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。
-Activiti基于Apache许可的开源BPM平台，创始人Tom Baeyens是JBoss jBPM的项目架构师，它特色是提供了eclipse插件，开发人员可以通过插件直接绘画出业务流程图。
-
-ProcessEngine对象，这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监控和管理流程的运行。
-
-业务流程建模与标注（Business Process Model and Notation，BPMN) ，描述流程的基本符号，包括这些图元如何组合成一个业务流程图（Business Process Diagram）
+工作流（Workflow），就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。
+通俗的说，流程就是多个人在一起合作完成某件事情的步骤，把步骤变成计算机能理解的形式就是工作流。
+
+
+工作流(Workflow)
+就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。
+
+工作流管理系统(Workflow Management System, WfMS)
+是一个软件系统，它完成工作量的定义和管理，并按照在系统中预先定义好的工作流规则进行工作流实例的执行。工作流管理系统不是企业的业务系统，而是为企业的业务系统的运行提供了一个软件的支撑环境。
+
+工作流管理联盟(WfMC，Workflow Management Coalition)
+给出的关于工作流管理系统的定义是：工作流管理系统是一个软件系统，它通过执行经过计算的流程定义去支持一批专门设定的业务流程。工作流管理系统被用来定义、管理、和执行工作流程。
+
+工作流管理系统的目标：管理工作的流程以确保工作在正确的时间被期望的人员所执行——在自动化进行的业务过程中插入人工的执行和干预。 
+
+
+Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理（BPM）框架，
+它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。
+Activiti基于Apache许可的开源BPM平台，创始人Tom Baeyens是JBoss jBPM的项目架构师，它特色是提供了eclipse插件，开发人员可以通过插件直接绘画出业务流程图。
+
+ProcessEngine对象，这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监控和管理流程的运行。
+
+业务流程建模与标注（Business Process Model and Notation，BPMN) ，描述流程的基本符号，包括这些图元如何组合成一个业务流程图（Business Process Diagram）
diff --git "a/04 - Middleware/CAS\345\215\225\347\202\271\347\231\273\345\275\225/\345\237\272\346\234\254.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/CAS\345\215\225\347\202\271\347\231\273\345\275\225/\345\237\272\346\234\254.txt"
similarity index 97%
rename from "04 - Middleware/CAS\345\215\225\347\202\271\347\231\273\345\275\225/\345\237\272\346\234\254.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/CAS\345\215\225\347\202\271\347\231\273\345\275\225/\345\237\272\346\234\254.txt"
index adc95428..cb5522e1 100644
--- "a/04 - Middleware/CAS\345\215\225\347\202\271\347\231\273\345\275\225/\345\237\272\346\234\254.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/CAS\345\215\225\347\202\271\347\231\273\345\275\225/\345\237\272\346\234\254.txt"	
@@ -1,32 +1,32 @@
-
-https://www.cnblogs.com/lihuidu/p/6495247.html
-
-
-单点登录全称Single Sign On（以下简称SSO）
-
-
-Yelu大学研发的CAS(Central Authentication Server)
-CAS框架：CAS（Central Authentication Service）是实现SSO单点登录的框架。
-
-
-访问服务： SSO 客户端发送请求访问应用系统提供的服务资源。
-
-定向认证： SSO 客户端会重定向用户请求到 SSO 服务器。
-
-用户认证：用户身份认证。
-
-发放票据： SSO 服务器会产生一个随机的 Service Ticket 。
-
-验证票据： SSO 服务器验证票据 Service Ticket 的合法性，验证通过后，允许客户端访问服务。
-
-传输用户信息： SSO 服务器验证票据通过后，传输用户认证结果信息给客户端。
-
-
-
-
-整个登出流程如下：
-
-1)、客户端向应用A发送登出Logout请求。 
-2)、应用A取消本地会话，同时通知认证中心，用户已登出。 
-3)、应用A返回客户端登出请求。 
+
+https://www.cnblogs.com/lihuidu/p/6495247.html
+
+
+单点登录全称Single Sign On（以下简称SSO）
+
+
+Yelu大学研发的CAS(Central Authentication Server)
+CAS框架：CAS（Central Authentication Service）是实现SSO单点登录的框架。
+
+
+访问服务： SSO 客户端发送请求访问应用系统提供的服务资源。
+
+定向认证： SSO 客户端会重定向用户请求到 SSO 服务器。
+
+用户认证：用户身份认证。
+
+发放票据： SSO 服务器会产生一个随机的 Service Ticket 。
+
+验证票据： SSO 服务器验证票据 Service Ticket 的合法性，验证通过后，允许客户端访问服务。
+
+传输用户信息： SSO 服务器验证票据通过后，传输用户认证结果信息给客户端。
+
+
+
+
+整个登出流程如下：
+
+1)、客户端向应用A发送登出Logout请求。 
+2)、应用A取消本地会话，同时通知认证中心，用户已登出。 
+3)、应用A返回客户端登出请求。 
 4)、认证中心通知所有用户登录访问的应用，用户已登出。
\ No newline at end of file
diff --git a/04 - Middleware/EDAS/all.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/EDAS/all.md"
similarity index 100%
rename from 04 - Middleware/EDAS/all.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/EDAS/all.md"
diff --git "a/04 - Middleware/GitHub\344\270\212\346\225\264\347\220\206\347\232\204\344\270\200\344\272\233\345\267\245\345\205\267.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/GitHub\344\270\212\346\225\264\347\220\206\347\232\204\344\270\200\344\272\233\345\267\245\345\205\267.md"
similarity index 98%
rename from "04 - Middleware/GitHub\344\270\212\346\225\264\347\220\206\347\232\204\344\270\200\344\272\233\345\267\245\345\205\267.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/GitHub\344\270\212\346\225\264\347\220\206\347\232\204\344\270\200\344\272\233\345\267\245\345\205\267.md"
index aeb64eef..8812be9d 100644
--- "a/04 - Middleware/GitHub\344\270\212\346\225\264\347\220\206\347\232\204\344\270\200\344\272\233\345\267\245\345\205\267.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/GitHub\344\270\212\346\225\264\347\220\206\347\232\204\344\270\200\344\272\233\345\267\245\345\205\267.md"	
@@ -1,261 +1,261 @@
-http://www.runoob.com/w3cnote/github-tools.html
-
-技术站点
-Hacker News：非常棒的针对编程的链接聚合网站
-Programming reddit：同上
-MSDN：微软相关的官方技术集中地，主要是文档类
-infoq：企业级应用，关注软件开发领域
-OSChina：开源技术社区，开源方面做的不错哦
-cnblogs，51cto，csdn：常见的技术社区，各有专长
-stackoverflow：IT技术问答网站
-GitHub：全球最大的源代码管理平台，很多知名开源项目都在上面，如Linux内核，
-OpenStack等免费的it电子书：http://it-ebooks.info/
-DevStore:开发者服务商店
-不错的书籍
-人件
-人月神话
-代码大全2
-计算机程序设计艺术
-程序员的自我修养
-程序员修炼之道
-高效能程序员的修炼（成为一名杰出的程序员其实跟写代码没有太大关系）
-深入理解计算机系统
-软件随想录
-算法导论（麻省理工学院出版社）
-离线数学及其应用
-设计模式
-编程之美
-黑客与画家
-编程珠玑
-C++ Prime
-Effective C++
-TCP/IP详解
-Unix 编程艺术
-《精神分析引论》弗洛伊德
-搞定：无压力工作的艺术
-平台工具（都是开源的好东东哦）
-Redmine/Trac：项目管理平台
-Jenkins/Jira(非开源)：持续集成系统（Apache Continuum，这个是Apache下的CI系统，还没来得及研究）
-Sonar：代码质量管理平台
-git，svn：源代码版本控制系统
-GitLib/Gitorious：构建自己的GitHub服务器
-gitbook：https://www.gitbook.io/写书的好东西，当然用来写文档也很不错的
-Travis-ci：开源项目持续集成必备，和GitHub相结合，https://travis-ci.org/
-开源测试工具、社区（Selenium、OpenQA.org）
-Puppet:一个自动管理引擎，可以适用于Linux、Unix以及Windows平台。所谓配置管理系统，就是管理机器里面诸如文件、用户、进程、软件包这些资源。无论是管理1台，还是上万台机器Puppet都能轻松搞定。
-Nagios：系统状态监控报警，还有个Icinga(完全兼容nagios所有的插件,工作原理,配置文件以及方法,几乎一模一样。配置简单,功能强大)
-Ganglia：分布式监控系统
-fleet：分布式init系统
-爬虫相关(好玩的工具)
-Phantomjs
-berserkJS(基于Phantomjs的改进版本)
-SlimerJS
-CasperJS
-selenium
-Web 服务器性能/压力测试工具/负载均衡器
-http_load: 程序非常小，解压后也不到100K
-webbench: 是Linux下的一个网站压力测试工具，最多可以模拟3万个并发连接去测试网站的负载能力
-ab: ab是apache自带的一款功能强大的测试工具
-Siege: 一款开源的压力测试工具，可以根据配置对一个WEB站点进行多用户的并发访问，记录每个用户所有请求过程的相应时间，并在一定数量的并发访问下重复进行。
-squid（前端缓存），nginx（负载），nodejs（没错它也可以，自己写点代码就能实现高性能的负载均衡器）：常用的负载均衡器
-Piwik：开源网站访问量统计系统
-ClickHeat：开源的网站点击情况热力图
-HAProxy：高性能TCP /HTTP负载均衡器
-ElasticSearch：搜索引擎基于Lucene
-Page Speed SDK和YSLOW
-HAR Viewer: HAR分析工具
-protractor：E2E（end to end）自动化测试工具
-Web 前端相关
-GRUNT: js task runner
-Sea.js: js模块化
-knockout.js：MVVM开发前台，绑定技术
-Angular.js: 使用超动感HTML & JS开发WEB应用！
-Highcharts.js，Flot:常用的Web图表插件
-Raw：非常不错的一款高级数据可视化工具
-Rickshaw:时序图标库，可用于构建实时图表
-JavaScript InfoVis Toolkit：另一款Web数据可视化插件
-Pdf.js，在html中展现pdf
-ACE，CodeMirror：Html代码编辑器（ACE甚好啊）
-NProcess：绚丽的加载进度条
-impress.js：让你制作出令人眩目的内容展示效果(类似的还有reveal)
-Threejs：3DWeb库
-Hightopo：基于Html5的2D、3D可视化UI库
-jQuery.dataTables.js:高度灵活的表格插件
-Raphaël：js，canvas绘图库，后来发现百度指数的图形就是用它绘出来的
-director.js：js路由模块，前端路由，Nodejs后端路由等，适合构造单页应用
-pace.js：页面加载进度条
-bower：Web包管理器
-jsnice：有趣的js反编译工具，猜压缩后的变量名 http://www.jsnice.org/
-D3.js: 是一个基于JavaScript数据展示库（类似的还有P5.js）
-Zepto.js：移动端替代jQuery的东东，当然也可以使用jquery-mobile.
-UI框架：Foundation，Boostrap，Pure，EasyUI，Polymer
-前端UI设计师必去的几个网站：Dribbble，awwwards，unmatchedstyle，UIMaker
-Mozilla 开发者中心：https://developer.mozilla.org/en-US/
-图标资源：IcoMoon（我的最爱），Themify Icons，FreePik，Glyphiconsart
-Dialog:非常漂亮的对话框
-AdminLTE：github上的一个开源项目，基于Boostrap3的后台管理页面框架
-Respond.js：让不懂爱的IE6-8支持响应式设计
-require.js: js模块加载库
-select2：比chosen具有更多特性的选择框替代库
-AngularUI：集成angular.js的UI库
-normalize.css: 采用了现代化标准让各浏览器渲染出的html保持一致的库
-CreateJS：Html5游戏引擎Less,Compass:简化CSS开发
-emojify.js:用于自动识别网页上的Emoji文字并将其显示为图像
-simditor:一个不错的开源的html编辑器，简洁高效
-Sencha: 基于html5的移动端开发框架
-SuperScrollorama+TweenMax+skrollr:打造超酷的视差滚动效果网页动画
-jquery-smooth-scroll:同上，平滑滚动插件
-Animate.css:实现了各种动画效果的css库
-Emmet:前端工程师必备，ZenCode的前身
-MagicDraw:Uml图工具
-大数据处理/数据分析/分布式工具
-Hadoop：分布式的文件系统，结合其MapReduce编程模型可以用来做海量数据的批处理（Hive，Pig，HBase啥的就不说了），值得介绍的是Cloudera的Hadoop分支CDH5，基于YARN MRv2集成了Spark可直接用于生产环境的Hadoop，对于企业快速构建数据仓库非常有用。
-Ceph:Linux分布式文件系统（特点：无中心）
-Storm：实时流数据处理，可以看下IBM的一篇介绍 （还有个Yahoo的S4，也是做流数据处理的）
-Spark：大规模流式数据处理（可以应付企业中常见的三种数据处理场景：复杂的批量数据处理（batch data processing）；基于历史数据的交互式查询（interactive query）；基于实时数据流的数据处理（streaming data processing）），CSND有篇文章介绍的不错
-Spark Streaming：基于Spark的实时计算框架
-Tachyon：分布式内存文件系统
-Mesos：计算框架一个集群管理器，提供了有效的、跨分布式应用或框架的资源隔离和共享Impala：新一代开源大数据分析引擎，提供Sql语义，比- Hive强在速度上
-SNAPPY：快速的数据压缩系统，适用于Hadoop生态系统中
-Kafka:高吞吐量的分布式消息队列系统
-ActiveMQ:是Apache出品，最流行的，能力强劲的开源消息总线
-MQTT:Message Queuing Telemetry Transport，消息队列遥测传输）是IBM开发的一个即时通讯协议，有可能成为物联网的重要组成部分
-RabbitMQ：记得OpenStack就是用的这个东西吧
-ZeroMQ：宣称是将分布式计算变得更简单，是个分布式消息队列，可以看下云风的一篇文章的介绍开源的日志收集系统：scribe、chukwa、kafka、flume。这有一篇对比文章
-Zookeeper：可靠的分布式协调的开源项目
-Databus：LinkedIn 实时低延迟数据抓取系统
-数据源获取：Flume、Google Refine、Needlebase、ScraperWiki、BloomReach
-序列化技术：JSON、BSON、Thrift、Avro、Google Protocol Buffers
-NoSql：Apache Hadoop、Apache Casandra、MongoDB、Apache CouchDB、Redis、BigTable、HBase、Hypertable、Voldemort、Neo4j
-MapReduce相关：Hive、Pig、Cascading、Cascalog、mrjob、Caffeine、S4、MapR、Acunu、Flume、Kafka、Azkaban、Oozie、Greenplum
-数据处理：R、Yahoo! Pipes、Mechanical Turk、Solr/ Lucene、ElasticSearch、Datameer、Bigsheets、TinkerpopNLP自然语言处理：Natural Language Toolkit、Apache OpenNLP、Boilerpipe、OpenCalais
-机器学习：WEKA、Mahout、scikits.learn、SkyTree
-可视化技术：GraphViz、Processing、Protovis、Google Fusion Tables、Tableau、Highcharts、EChats（百度的还不错）、Raphaël.js
-Kettle：开源的ETL工具
-Pentaho：以工作流为核心的开源BI系统
-Mondrian：开源的Rolap服务器
-Oozie：开源hadoop的工作流调度引擎
-开源的数据分析可视化工具：Weka、Orange、KNIME
-Cobar：阿里巴巴的MySql分布式中间件
-C & C++
-Thrift:用来进行可扩展且跨语言的服务的开发(类似的还有个Avro，Google protobuf)。
-libevent:是一个事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。（对了还有个libev呢）
-Boost:不多说了，准C++标准库
-Ptmalloc\Valgrind\Purify
-NetworkServer架构：acceptor->dispatcher->worker(这个不算工具哦)
-breakpad:崩溃转储和分析模块，很多crashreport会用到
-UI界面相关：MFC、BCG和QT这类的就不说了，高端一点的还有Html和DirectUI技术：libcef（基于chrome内核的，想想使用html5开发页面，还真有点小激动呢）、HtmlLayout、Duilib、Bolt，非C++的，还有node-webkit也不错，集成了node和webkit内核。
-游戏开发相关
-MINA：使用Java开发手游和页游服务器(对了还有Netty，也很猛的，都是基于NIO的)
-HP-Socket：见有有些页游服务器使用这个构建的
-云风的技术博客：http://blog.codingnow.com/
-OGRE：大名鼎鼎的3D图形渲染引擎
-OpenVDB：梦工厂C++的特效库，开源的
-cocos2d：跨平台2D游戏引擎
-unity3d：跨平台3D游戏引擎，很火的哦
-Nodejs：也有不少使用它来开发手游和也有服务器（网易的Pomelo就是哦）
-日志聚合，分布式日志收集
-Scribe：Facebook的（nodejs + scribe + inotify 同步日志）
-logstash:强大的日志收集系统，可以基于logstash+kibana+elasticsearch+redis开发强大的日志分析平台
-log.io: nodejs开发的实时日志收集系统
-RTP,实时传输协议与音视频
-RTP，RTCP，RTSP-> librtp，JRTPLIB(遵循了RFC1889标准)
-环形缓冲区，实时数据传输用
-SDL,ffmpeg,live555,Speex
-Red5:用Java开发开源的Flash流媒体服务器。它支持：把音频（MP3）和视频（FLV）转换成播放流； 录制客户端播放流（只支持FLV）；共享对象；现场直播流发布；远程调用。
-Python
-Eric,Eclipse+pydev,比较不错的Python IDE
-PyWin:Win32 api编程包
-numpy:科学计算包，主要用来处理大型矩阵计算等，此外还有SciPy，Matplotlib
-GUI相关：PyQt，PyQwt
-supervisor:进程监控工具
-Java相关
-常用的IDE：IntelliJ IDEA，Eclipse，Netbeans
-Web开发相关：Tomcat、Resin、Jetty、WebLogic等，常用的组件Struts，Spring
-HibernateNetty: 异步事件驱动网络应用编程框架，用于高并发网络编程比较好（NIO框架）
-MINA：简单地开发高性能和高可靠性的网络应用程序（也是个NIO框架），不少手游服务端是用它开发的
-jOOQ：java Orm框架Activiti:工作流引擎，类似的还有jBPM、Snaker
-Perfuse:是一个用户界面包用来把有结构与无结构数据以具有交互性的可视化图形展示出来.
-Gephi:复杂网络分析软件, 其主要用于各种网络和复杂系统，动态和分层图的交互可视化与探测开源工具
-Nutch:知名的爬虫项目，hadoop就是从这个项目中发展出来的
-web-harvest：Web数据提取工具
-POM工具：Maven+ArtifactoryNetflix
-Curator：Netflix公司开源的一个Zookeeper client library，用于简化Zookeeper客户端编程
-Akka:一款基于actor模型实现的 并发处理框架
-EclEmma：覆盖测试工具
-.net相关
-Xilium.CefGlue:基于CEF框架的.NET封装，基于.NET开发Chrome内核浏览器
-CefSharp：同上，有一款WebKit的封装，C#和Js交互会更简单
-netz:免费的 .NET 可执行文件压缩工具
-SmartAssembly:变态的.net代码优化混淆工具
-NETDeob0：.net反混淆工具，真是魔高一尺道高一丈啊(还有个de4dot，在GitHub上，都是开源的)
-ILMerge：将所有引用的DLL和exe文件打成一个exe文件
-ILSpy:开源.net程序反编译工具
-Javascript.NET：很不错的js执行引擎，对v8做了封装
-NPOI: Excel操作
-DotRAS:远程访问服务的模块
-WinHtmlEditor: Winform下的html编辑器
-SmartThreadPool:使用C#实现的，带高级特性的线程池
-Snoop: WPF Spy Utility
-Autofac: 轻量级IoC框架
-HtmlAgilityPack：Html解析利器
-Quartz.NET：Job调度
-HttpLib：@CodePlex，简化http请求
-SuperSocket：简化Socket操作，基于他的还有个SuperWebSocket，可以开发独立的WebSocket服务器了
-DocX：未安装Office的情况下操作Word文件
-Dapper：轻量级的ORM类，性能不错
-HubbleDotNet：支持接入数据库的全文搜索系统
-fastJSON：@CodeProject，高性能的json序列化类
-ZXing.NET：@CodePlex，QR，条形码相关
-Nancy：轻量级Http服务器，做个小型的Web应用可以摆脱IIS喽(Nancy.Viewengines.Razor,可以加入Razor引擎)
-AntiXSS：微软的XSS防御库Microsoft Web Protection
-LibraryJint：JavaScript解释器
-CS-Script：将C#代码文件作为脚本执行
-Jexus：Linux下 高性能、易用、免费的ASP.NET服务器
-Clay：将dynamic发挥的更加灵活，像写js一样写C#
-DynamicJSON：不必定义数据模型获取json数据
-Antlr：开源的语法分析器（归到C#不太合适，其他语言也可以去用）
-SharpPcap：C#版的WinPcap调用端，牛逼的网络包分析库（自带PacketNotNet用于包协议分析）
-Roslyn：C#，VB编译器
-ImageResizer: 服务端自由控制图片大小，真乃神器也，对手机端传小图，PC端传大图，CMS用它很方便
-UI相关：DevExpress, Fluent(Office 07风格), mui（Modern UI for WPF）
-NetSparkle：应用自动更新组件
-ConfuserEx: 开源.net混淆工具
-ServiceStack: 开源高性能Web服务框架，可用于构建高性能的REST服务Expression
-Evaluator：Eval for C#,处理字符串表达式
-http://nugetmusthaves.com/
-常用工具
-Fiddler：非常好用的Web前端调试工具，当然是针对底层http协议的，一般情况使用Chrome等自带的调试工具也足够了，特殊情况还得用它去处理
-wireshark：知名的网络数据包分析工具
-PowerCmd:替代Windows Cmd的利器
-RegexBuddy:强大的正则表达式测试工具
-Soure Insight：源代码阅读神器
-SublimeText：程序员最爱的编辑器
-Database.NET：一个通用的关系型数据库客户端，基于.NET 4.0开发的，做简单的处理还是蛮方便的
-Navicat Premium：支持MySql、PostgreSQL、Oracle、Sqlite和SQL Server的客户端，通用性上不如Database.NET，但性能方面比Database.NET好很多，自带备份功能也用于数据库定时备份。
-Synergy : 局域网内一套键盘鼠标控制多台电脑
-DameWare：远程协助工具集（我在公司主要控制大屏幕用）
-Radmin: 远程控制工具，用了一段时间的
-DameWare，还要破解，对Win7支持的不好，还是发现这个好用
-Listary：能极大幅度提高你 Windows 文件浏览与搜索速度效率的「超级神器」
-Clover：给资源管理器加上多标签
-WinLaunch：模拟Mac OS的Launch工具
-Fritzing：绘制电路图
-LICEcap：gif教程制作git，
-svn：版本控制系统Enigma Virtual Box（将exe，dll等封装成一个可执行程序）
-Open DBDiff(针对SqlServer)数据库同步
-SymmetricDS：数据库同步
-BIEE,Infomatica，SPSS，weka，R语言：数据分析
-CodeSmith，LightSwitch：代码生成
-Pandoc：Markdown转换工具，出书用的。以前玩过docbook，不过现在还是Markdown盛行啊。
-Window Magnet[Mac]：增强Mac窗口管理功能，想Win7一样具有窗口拖放到屏幕边缘自动调整的功能
-log explorer：查看SqlServer日志dependency
-walker：查询Windows应用程序dll依赖项
-Shairport4w：将iPhone，iPad，iPod上的音频通过AirPlay协议传输到PC上
-ngrok：内网穿透工具Axure:快速原型制作工具，还有个在线作图的工具国内的一个创业团队做的，用着很不错 http://www.processon.com
-tinyproxy:（Linux）小型的代理服务器支持http和https协议EaseUS Partition
-Master：超级简单的分区调整工具，速度还是蛮快的，C盘不够用了就用它从D盘划点空间吧，不用重装系统这么折腾哦。
-CheatEngine：玩游戏修改内存值必备神器（记得我在玩轩辕剑6的时候就用的它，超级方便呢）
-ApkIDE:Android反编译神器翻、墙工具（自|由|门、天行浏览器）
-设计工具：Sketch、OmniGraffle
+http://www.runoob.com/w3cnote/github-tools.html
+
+技术站点
+Hacker News：非常棒的针对编程的链接聚合网站
+Programming reddit：同上
+MSDN：微软相关的官方技术集中地，主要是文档类
+infoq：企业级应用，关注软件开发领域
+OSChina：开源技术社区，开源方面做的不错哦
+cnblogs，51cto，csdn：常见的技术社区，各有专长
+stackoverflow：IT技术问答网站
+GitHub：全球最大的源代码管理平台，很多知名开源项目都在上面，如Linux内核，
+OpenStack等免费的it电子书：http://it-ebooks.info/
+DevStore:开发者服务商店
+不错的书籍
+人件
+人月神话
+代码大全2
+计算机程序设计艺术
+程序员的自我修养
+程序员修炼之道
+高效能程序员的修炼（成为一名杰出的程序员其实跟写代码没有太大关系）
+深入理解计算机系统
+软件随想录
+算法导论（麻省理工学院出版社）
+离线数学及其应用
+设计模式
+编程之美
+黑客与画家
+编程珠玑
+C++ Prime
+Effective C++
+TCP/IP详解
+Unix 编程艺术
+《精神分析引论》弗洛伊德
+搞定：无压力工作的艺术
+平台工具（都是开源的好东东哦）
+Redmine/Trac：项目管理平台
+Jenkins/Jira(非开源)：持续集成系统（Apache Continuum，这个是Apache下的CI系统，还没来得及研究）
+Sonar：代码质量管理平台
+git，svn：源代码版本控制系统
+GitLib/Gitorious：构建自己的GitHub服务器
+gitbook：https://www.gitbook.io/写书的好东西，当然用来写文档也很不错的
+Travis-ci：开源项目持续集成必备，和GitHub相结合，https://travis-ci.org/
+开源测试工具、社区（Selenium、OpenQA.org）
+Puppet:一个自动管理引擎，可以适用于Linux、Unix以及Windows平台。所谓配置管理系统，就是管理机器里面诸如文件、用户、进程、软件包这些资源。无论是管理1台，还是上万台机器Puppet都能轻松搞定。
+Nagios：系统状态监控报警，还有个Icinga(完全兼容nagios所有的插件,工作原理,配置文件以及方法,几乎一模一样。配置简单,功能强大)
+Ganglia：分布式监控系统
+fleet：分布式init系统
+爬虫相关(好玩的工具)
+Phantomjs
+berserkJS(基于Phantomjs的改进版本)
+SlimerJS
+CasperJS
+selenium
+Web 服务器性能/压力测试工具/负载均衡器
+http_load: 程序非常小，解压后也不到100K
+webbench: 是Linux下的一个网站压力测试工具，最多可以模拟3万个并发连接去测试网站的负载能力
+ab: ab是apache自带的一款功能强大的测试工具
+Siege: 一款开源的压力测试工具，可以根据配置对一个WEB站点进行多用户的并发访问，记录每个用户所有请求过程的相应时间，并在一定数量的并发访问下重复进行。
+squid（前端缓存），nginx（负载），nodejs（没错它也可以，自己写点代码就能实现高性能的负载均衡器）：常用的负载均衡器
+Piwik：开源网站访问量统计系统
+ClickHeat：开源的网站点击情况热力图
+HAProxy：高性能TCP /HTTP负载均衡器
+ElasticSearch：搜索引擎基于Lucene
+Page Speed SDK和YSLOW
+HAR Viewer: HAR分析工具
+protractor：E2E（end to end）自动化测试工具
+Web 前端相关
+GRUNT: js task runner
+Sea.js: js模块化
+knockout.js：MVVM开发前台，绑定技术
+Angular.js: 使用超动感HTML & JS开发WEB应用！
+Highcharts.js，Flot:常用的Web图表插件
+Raw：非常不错的一款高级数据可视化工具
+Rickshaw:时序图标库，可用于构建实时图表
+JavaScript InfoVis Toolkit：另一款Web数据可视化插件
+Pdf.js，在html中展现pdf
+ACE，CodeMirror：Html代码编辑器（ACE甚好啊）
+NProcess：绚丽的加载进度条
+impress.js：让你制作出令人眩目的内容展示效果(类似的还有reveal)
+Threejs：3DWeb库
+Hightopo：基于Html5的2D、3D可视化UI库
+jQuery.dataTables.js:高度灵活的表格插件
+Raphaël：js，canvas绘图库，后来发现百度指数的图形就是用它绘出来的
+director.js：js路由模块，前端路由，Nodejs后端路由等，适合构造单页应用
+pace.js：页面加载进度条
+bower：Web包管理器
+jsnice：有趣的js反编译工具，猜压缩后的变量名 http://www.jsnice.org/
+D3.js: 是一个基于JavaScript数据展示库（类似的还有P5.js）
+Zepto.js：移动端替代jQuery的东东，当然也可以使用jquery-mobile.
+UI框架：Foundation，Boostrap，Pure，EasyUI，Polymer
+前端UI设计师必去的几个网站：Dribbble，awwwards，unmatchedstyle，UIMaker
+Mozilla 开发者中心：https://developer.mozilla.org/en-US/
+图标资源：IcoMoon（我的最爱），Themify Icons，FreePik，Glyphiconsart
+Dialog:非常漂亮的对话框
+AdminLTE：github上的一个开源项目，基于Boostrap3的后台管理页面框架
+Respond.js：让不懂爱的IE6-8支持响应式设计
+require.js: js模块加载库
+select2：比chosen具有更多特性的选择框替代库
+AngularUI：集成angular.js的UI库
+normalize.css: 采用了现代化标准让各浏览器渲染出的html保持一致的库
+CreateJS：Html5游戏引擎Less,Compass:简化CSS开发
+emojify.js:用于自动识别网页上的Emoji文字并将其显示为图像
+simditor:一个不错的开源的html编辑器，简洁高效
+Sencha: 基于html5的移动端开发框架
+SuperScrollorama+TweenMax+skrollr:打造超酷的视差滚动效果网页动画
+jquery-smooth-scroll:同上，平滑滚动插件
+Animate.css:实现了各种动画效果的css库
+Emmet:前端工程师必备，ZenCode的前身
+MagicDraw:Uml图工具
+大数据处理/数据分析/分布式工具
+Hadoop：分布式的文件系统，结合其MapReduce编程模型可以用来做海量数据的批处理（Hive，Pig，HBase啥的就不说了），值得介绍的是Cloudera的Hadoop分支CDH5，基于YARN MRv2集成了Spark可直接用于生产环境的Hadoop，对于企业快速构建数据仓库非常有用。
+Ceph:Linux分布式文件系统（特点：无中心）
+Storm：实时流数据处理，可以看下IBM的一篇介绍 （还有个Yahoo的S4，也是做流数据处理的）
+Spark：大规模流式数据处理（可以应付企业中常见的三种数据处理场景：复杂的批量数据处理（batch data processing）；基于历史数据的交互式查询（interactive query）；基于实时数据流的数据处理（streaming data processing）），CSND有篇文章介绍的不错
+Spark Streaming：基于Spark的实时计算框架
+Tachyon：分布式内存文件系统
+Mesos：计算框架一个集群管理器，提供了有效的、跨分布式应用或框架的资源隔离和共享Impala：新一代开源大数据分析引擎，提供Sql语义，比- Hive强在速度上
+SNAPPY：快速的数据压缩系统，适用于Hadoop生态系统中
+Kafka:高吞吐量的分布式消息队列系统
+ActiveMQ:是Apache出品，最流行的，能力强劲的开源消息总线
+MQTT:Message Queuing Telemetry Transport，消息队列遥测传输）是IBM开发的一个即时通讯协议，有可能成为物联网的重要组成部分
+RabbitMQ：记得OpenStack就是用的这个东西吧
+ZeroMQ：宣称是将分布式计算变得更简单，是个分布式消息队列，可以看下云风的一篇文章的介绍开源的日志收集系统：scribe、chukwa、kafka、flume。这有一篇对比文章
+Zookeeper：可靠的分布式协调的开源项目
+Databus：LinkedIn 实时低延迟数据抓取系统
+数据源获取：Flume、Google Refine、Needlebase、ScraperWiki、BloomReach
+序列化技术：JSON、BSON、Thrift、Avro、Google Protocol Buffers
+NoSql：Apache Hadoop、Apache Casandra、MongoDB、Apache CouchDB、Redis、BigTable、HBase、Hypertable、Voldemort、Neo4j
+MapReduce相关：Hive、Pig、Cascading、Cascalog、mrjob、Caffeine、S4、MapR、Acunu、Flume、Kafka、Azkaban、Oozie、Greenplum
+数据处理：R、Yahoo! Pipes、Mechanical Turk、Solr/ Lucene、ElasticSearch、Datameer、Bigsheets、TinkerpopNLP自然语言处理：Natural Language Toolkit、Apache OpenNLP、Boilerpipe、OpenCalais
+机器学习：WEKA、Mahout、scikits.learn、SkyTree
+可视化技术：GraphViz、Processing、Protovis、Google Fusion Tables、Tableau、Highcharts、EChats（百度的还不错）、Raphaël.js
+Kettle：开源的ETL工具
+Pentaho：以工作流为核心的开源BI系统
+Mondrian：开源的Rolap服务器
+Oozie：开源hadoop的工作流调度引擎
+开源的数据分析可视化工具：Weka、Orange、KNIME
+Cobar：阿里巴巴的MySql分布式中间件
+C & C++
+Thrift:用来进行可扩展且跨语言的服务的开发(类似的还有个Avro，Google protobuf)。
+libevent:是一个事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。（对了还有个libev呢）
+Boost:不多说了，准C++标准库
+Ptmalloc\Valgrind\Purify
+NetworkServer架构：acceptor->dispatcher->worker(这个不算工具哦)
+breakpad:崩溃转储和分析模块，很多crashreport会用到
+UI界面相关：MFC、BCG和QT这类的就不说了，高端一点的还有Html和DirectUI技术：libcef（基于chrome内核的，想想使用html5开发页面，还真有点小激动呢）、HtmlLayout、Duilib、Bolt，非C++的，还有node-webkit也不错，集成了node和webkit内核。
+游戏开发相关
+MINA：使用Java开发手游和页游服务器(对了还有Netty，也很猛的，都是基于NIO的)
+HP-Socket：见有有些页游服务器使用这个构建的
+云风的技术博客：http://blog.codingnow.com/
+OGRE：大名鼎鼎的3D图形渲染引擎
+OpenVDB：梦工厂C++的特效库，开源的
+cocos2d：跨平台2D游戏引擎
+unity3d：跨平台3D游戏引擎，很火的哦
+Nodejs：也有不少使用它来开发手游和也有服务器（网易的Pomelo就是哦）
+日志聚合，分布式日志收集
+Scribe：Facebook的（nodejs + scribe + inotify 同步日志）
+logstash:强大的日志收集系统，可以基于logstash+kibana+elasticsearch+redis开发强大的日志分析平台
+log.io: nodejs开发的实时日志收集系统
+RTP,实时传输协议与音视频
+RTP，RTCP，RTSP-> librtp，JRTPLIB(遵循了RFC1889标准)
+环形缓冲区，实时数据传输用
+SDL,ffmpeg,live555,Speex
+Red5:用Java开发开源的Flash流媒体服务器。它支持：把音频（MP3）和视频（FLV）转换成播放流； 录制客户端播放流（只支持FLV）；共享对象；现场直播流发布；远程调用。
+Python
+Eric,Eclipse+pydev,比较不错的Python IDE
+PyWin:Win32 api编程包
+numpy:科学计算包，主要用来处理大型矩阵计算等，此外还有SciPy，Matplotlib
+GUI相关：PyQt，PyQwt
+supervisor:进程监控工具
+Java相关
+常用的IDE：IntelliJ IDEA，Eclipse，Netbeans
+Web开发相关：Tomcat、Resin、Jetty、WebLogic等，常用的组件Struts，Spring
+HibernateNetty: 异步事件驱动网络应用编程框架，用于高并发网络编程比较好（NIO框架）
+MINA：简单地开发高性能和高可靠性的网络应用程序（也是个NIO框架），不少手游服务端是用它开发的
+jOOQ：java Orm框架Activiti:工作流引擎，类似的还有jBPM、Snaker
+Perfuse:是一个用户界面包用来把有结构与无结构数据以具有交互性的可视化图形展示出来.
+Gephi:复杂网络分析软件, 其主要用于各种网络和复杂系统，动态和分层图的交互可视化与探测开源工具
+Nutch:知名的爬虫项目，hadoop就是从这个项目中发展出来的
+web-harvest：Web数据提取工具
+POM工具：Maven+ArtifactoryNetflix
+Curator：Netflix公司开源的一个Zookeeper client library，用于简化Zookeeper客户端编程
+Akka:一款基于actor模型实现的 并发处理框架
+EclEmma：覆盖测试工具
+.net相关
+Xilium.CefGlue:基于CEF框架的.NET封装，基于.NET开发Chrome内核浏览器
+CefSharp：同上，有一款WebKit的封装，C#和Js交互会更简单
+netz:免费的 .NET 可执行文件压缩工具
+SmartAssembly:变态的.net代码优化混淆工具
+NETDeob0：.net反混淆工具，真是魔高一尺道高一丈啊(还有个de4dot，在GitHub上，都是开源的)
+ILMerge：将所有引用的DLL和exe文件打成一个exe文件
+ILSpy:开源.net程序反编译工具
+Javascript.NET：很不错的js执行引擎，对v8做了封装
+NPOI: Excel操作
+DotRAS:远程访问服务的模块
+WinHtmlEditor: Winform下的html编辑器
+SmartThreadPool:使用C#实现的，带高级特性的线程池
+Snoop: WPF Spy Utility
+Autofac: 轻量级IoC框架
+HtmlAgilityPack：Html解析利器
+Quartz.NET：Job调度
+HttpLib：@CodePlex，简化http请求
+SuperSocket：简化Socket操作，基于他的还有个SuperWebSocket，可以开发独立的WebSocket服务器了
+DocX：未安装Office的情况下操作Word文件
+Dapper：轻量级的ORM类，性能不错
+HubbleDotNet：支持接入数据库的全文搜索系统
+fastJSON：@CodeProject，高性能的json序列化类
+ZXing.NET：@CodePlex，QR，条形码相关
+Nancy：轻量级Http服务器，做个小型的Web应用可以摆脱IIS喽(Nancy.Viewengines.Razor,可以加入Razor引擎)
+AntiXSS：微软的XSS防御库Microsoft Web Protection
+LibraryJint：JavaScript解释器
+CS-Script：将C#代码文件作为脚本执行
+Jexus：Linux下 高性能、易用、免费的ASP.NET服务器
+Clay：将dynamic发挥的更加灵活，像写js一样写C#
+DynamicJSON：不必定义数据模型获取json数据
+Antlr：开源的语法分析器（归到C#不太合适，其他语言也可以去用）
+SharpPcap：C#版的WinPcap调用端，牛逼的网络包分析库（自带PacketNotNet用于包协议分析）
+Roslyn：C#，VB编译器
+ImageResizer: 服务端自由控制图片大小，真乃神器也，对手机端传小图，PC端传大图，CMS用它很方便
+UI相关：DevExpress, Fluent(Office 07风格), mui（Modern UI for WPF）
+NetSparkle：应用自动更新组件
+ConfuserEx: 开源.net混淆工具
+ServiceStack: 开源高性能Web服务框架，可用于构建高性能的REST服务Expression
+Evaluator：Eval for C#,处理字符串表达式
+http://nugetmusthaves.com/
+常用工具
+Fiddler：非常好用的Web前端调试工具，当然是针对底层http协议的，一般情况使用Chrome等自带的调试工具也足够了，特殊情况还得用它去处理
+wireshark：知名的网络数据包分析工具
+PowerCmd:替代Windows Cmd的利器
+RegexBuddy:强大的正则表达式测试工具
+Soure Insight：源代码阅读神器
+SublimeText：程序员最爱的编辑器
+Database.NET：一个通用的关系型数据库客户端，基于.NET 4.0开发的，做简单的处理还是蛮方便的
+Navicat Premium：支持MySql、PostgreSQL、Oracle、Sqlite和SQL Server的客户端，通用性上不如Database.NET，但性能方面比Database.NET好很多，自带备份功能也用于数据库定时备份。
+Synergy : 局域网内一套键盘鼠标控制多台电脑
+DameWare：远程协助工具集（我在公司主要控制大屏幕用）
+Radmin: 远程控制工具，用了一段时间的
+DameWare，还要破解，对Win7支持的不好，还是发现这个好用
+Listary：能极大幅度提高你 Windows 文件浏览与搜索速度效率的「超级神器」
+Clover：给资源管理器加上多标签
+WinLaunch：模拟Mac OS的Launch工具
+Fritzing：绘制电路图
+LICEcap：gif教程制作git，
+svn：版本控制系统Enigma Virtual Box（将exe，dll等封装成一个可执行程序）
+Open DBDiff(针对SqlServer)数据库同步
+SymmetricDS：数据库同步
+BIEE,Infomatica，SPSS，weka，R语言：数据分析
+CodeSmith，LightSwitch：代码生成
+Pandoc：Markdown转换工具，出书用的。以前玩过docbook，不过现在还是Markdown盛行啊。
+Window Magnet[Mac]：增强Mac窗口管理功能，想Win7一样具有窗口拖放到屏幕边缘自动调整的功能
+log explorer：查看SqlServer日志dependency
+walker：查询Windows应用程序dll依赖项
+Shairport4w：将iPhone，iPad，iPod上的音频通过AirPlay协议传输到PC上
+ngrok：内网穿透工具Axure:快速原型制作工具，还有个在线作图的工具国内的一个创业团队做的，用着很不错 http://www.processon.com
+tinyproxy:（Linux）小型的代理服务器支持http和https协议EaseUS Partition
+Master：超级简单的分区调整工具，速度还是蛮快的，C盘不够用了就用它从D盘划点空间吧，不用重装系统这么折腾哦。
+CheatEngine：玩游戏修改内存值必备神器（记得我在玩轩辕剑6的时候就用的它，超级方便呢）
+ApkIDE:Android反编译神器翻、墙工具（自|由|门、天行浏览器）
+设计工具：Sketch、OmniGraffle
 MindManger：思维导图
\ No newline at end of file
diff --git a/04 - Middleware/HSF/README.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/HSF/README.md"
similarity index 100%
rename from 04 - Middleware/HSF/README.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/HSF/README.md"
diff --git "a/04 - Middleware/Java\344\270\255\351\227\264\344\273\266\347\220\206\350\247\243.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Java\344\270\255\351\227\264\344\273\266\347\220\206\350\247\243.md"
similarity index 97%
rename from "04 - Middleware/Java\344\270\255\351\227\264\344\273\266\347\220\206\350\247\243.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Java\344\270\255\351\227\264\344\273\266\347\220\206\350\247\243.md"
index 723d56dc..bafb37b9 100644
--- "a/04 - Middleware/Java\344\270\255\351\227\264\344\273\266\347\220\206\350\247\243.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Java\344\270\255\351\227\264\344\273\266\347\220\206\350\247\243.md"	
@@ -1,4 +1,4 @@
-
-就是一个单独的服务，与项目独立，又与项目紧密联系
-
+
+就是一个单独的服务，与项目独立，又与项目紧密联系
+
 通过Java 端口通讯 提供服务 消费服务
\ No newline at end of file
diff --git "a/04 - Middleware/Logback/logback\350\257\246\350\247\243.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Logback/logback\350\257\246\350\247\243.md"
similarity index 98%
rename from "04 - Middleware/Logback/logback\350\257\246\350\247\243.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Logback/logback\350\257\246\350\247\243.md"
index b76ac060..5ef18ad1 100644
--- "a/04 - Middleware/Logback/logback\350\257\246\350\247\243.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Logback/logback\350\257\246\350\247\243.md"	
@@ -1,321 +1,321 @@
-https://www.cnblogs.com/xrq730/p/8628945.html
-
-### 为什么使用logback
-记得前几年工作的时候，公司使用的日志框架还是log4j，大约从16年中到现在，不管是我参与的别人已经搭建好的项目还是我自己主导的项目，日志框架基本都换成了logback，总结一下，logback大约有以下的一些优点：
-1. 内核重写、测试充分、初始化内存加载更小，这一切让logback性能和log4j相比有诸多倍的提升
-2. logback非常自然地直接实现了slf4j，这个严格来说算不上优点，只是这样，再理解slf4j的前提下会很容易理解logback，也同时很容易用其他日志框架替换logback
-3. logback有比较齐全的200多页的文档
-4. logback当配置文件修改了，支持自动重新加载配置文件，扫描过程快且安全，它并不需要另外创建一个扫描线程
-5. 支持自动去除旧的日志文件，可以控制已经产生日志文件的最大数量
-总而言之，如果大家的项目里面需要选择一个日志框架，那么我个人非常建议使用logback。
-### logback加载
-我们简单分析一下logback加载过程，当我们使用logback-classic.jar时，应用启动，那么logback会按照如下顺序进行扫描：
-1. 在系统配置文件System Properties中寻找是否有logback.configurationFile对应的value
-2. 在classpath下寻找是否有logback.groovy（即logback支持groovy与xml两种配置方式）
-3. 在classpath下寻找是否有logback-test.xml
-4. 在classpath下寻找是否有logback.xml
-以上任何一项找到了，就不进行后续扫描，按照对应的配置进行logback的初始化，具体代码实现可见ch.qos.logback.classic.util.ContextInitializer类的findURLOfDefaultConfigurationFile方法。
-当所有以上四项都找不到的情况下，logback会调用ch.qos.logback.classic.BasicConfigurator的configure方法，构造一个ConsoleAppender用于向控制台输出日志，默认日志输出格式为"%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"。
-### logback的configuration
-logback的重点应当是Appender、Logger、Pattern，在这之前先简单了解一下logback的<configuration>，<configuration>只有三个属性：
-1. scan：当scan被设置为true时，当配置文件发生改变，将会被重新加载，默认为true
-2. scanPeriod：检测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认为毫秒，当scan=true时这个值生效，默认时间间隔为1分钟
-3. debug：当被设置为true时，将打印出logback内部日志信息，实时查看logback运行信息，默认为false
-###  <logger>与<root>
-先从最基本的<logger>与<root>开始。
-<logger>用来设置某一个包或者具体某一个类的日志打印级别、以及指定<appender>。<logger>可以包含零个或者多个<appender-ref>元素，标识这个appender将会添加到这个logger。<logger>仅有一个name属性、一个可选的level属性和一个可选的additivity属性：
-1. name：用来指定受此logger约束的某一个包或者具体的某一个类
-2. level：用来设置打印级别，五个常用打印级别从低至高依次为TRACE、DEBUG、INFO、WARN、ERROR，如果未设置此级别，那么当前logger会继承上级的级别
-3. additivity：是否向上级logger传递打印信息，默认为true
-<root>也是<logger>元素，但是它是根logger，只有一个level属性，因为它的name就是root。
-接着写一段代码来测试一下：
-``` java
-public class Slf4jTest {
-    @Test
-    public void testSlf4j() {
-        Logger logger = LoggerFactory.getLogger(Object.class);
-        logger.trace("=====trace=====");  
-        logger.debug("=====debug=====");  
-        logger.info("=====info=====");  
-        logger.warn("=====warn=====");  
-        logger.error("=====error=====");  
-    }
-}
-```
-logback.xml
-``` xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<configuration scan="false" scanPeriod="60000" debug="false">
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <layout class="ch.qos.logback.classic.PatternLayout">
-            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-        </layout>
-    </appender>
-
-    <root level="info">
-        <appender-ref ref="STDOUT" />
-    </root>
-
-</configuration>
-```
-root将打印级别设置为"info"级别，<appender>暂时不管，控制台的输出为：
-```
-2018-03-26 22:57:48.779 [main] INFO  java.lang.Object - =====info=====
-2018-03-26 22:57:48.782 [main] WARN  java.lang.Object - =====warn=====
-2018-03-26 22:57:48.782 [main] ERROR java.lang.Object - =====error=====
-```
-logback.xml的意思是，当Test方法运行时，root节点将日志级别大于等于info的交给已经配置好的名为"STDOUT"的<appender>进行处理，"STDOUT"将信息打印到控制台上。
-接着理解一下<logger>节点的作用，logback.xml修改一下，加入一个只有name属性的<logger>：
-``` xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<configuration scan="false" scanPeriod="60000" debug="false">
-
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <layout class="ch.qos.logback.classic.PatternLayout">
-            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-        </layout>
-    </appender>
-
-    <logger name="java" />
-
-     <root level="debug">
-         <appender-ref ref="STDOUT" />
-     </root>
-
-</configuration>
-```
-注意这个name表示的是LoggerFactory.getLogger(XXX.class)，XXX的包路径，包路径越少越是父级，我们测试代码里面是Object.class，即name="java"是name="java.lang"的父级，root是所有<logger>的父级。看一下输出为：
-```
-2018-03-27 23:02:02.963 [main] DEBUG java.lang.Object - =====debug=====
-2018-03-27 23:02:02.965 [main] INFO  java.lang.Object - =====info=====
-2018-03-27 23:02:02.966 [main] WARN  java.lang.Object - =====warn=====
-2018-03-27 23:02:02.966 [main] ERROR java.lang.Object - =====error=====
-```
-出现这样的结果是因为：
-1. <logger>中没有配置level，即继承父级的level，<logger>的父级为<root>，那么level=debug
-2. 没有配置additivity，那么additivity=true，表示此<logger>的打印信息向父级<root>传递
-3. 没有配置<appender-ref>，表示此<logger>不会打印出任何信息
-4. 由此可知，<logger>的打印信息向<root>传递，<root>使用"STDOUT"这个<appender>打印出所有大于等于debug级别的日志。举一反三，我们将<logger>的additivity配置为false，那么控制台应该不会打印出任何日志，因为<logger>的打印信息不会向父级<root>传递且<logger>没有配置任何<appender>，大家可以自己试验一下。
-
-接着，我们再配置一个<logger>：
-``` xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<configuration scan="false" scanPeriod="60000" debug="false">
-
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <layout class="ch.qos.logback.classic.PatternLayout">
-            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-        </layout>
-    </appender>
-
-    <logger name="java" additivity="false" />
-    <logger name="java.lang" level="warn">
-        <appender-ref ref="STDOUT" />
-    </logger>
-
-    <root level="debug">
-        <appender-ref ref="STDOUT" />
-    </root>
-
-</configuration>
-```
-如果读懂了上面的例子，那么这个例子应当很好理解：
-1. LoggerFactory.getLogger(Object.class)，首先找到name="java.lang"这个<logger>，将日志级别大于等于warn的使用"STDOUT"这个<appender>打印出来
-2. name="java.lang"这个<logger>没有配置additivity，那么additivity=true，打印信息向上传递，传递给父级name="java"这个<logger>
-3. name="java"这个<logger>的additivity=false且不关联任何<appender>，那么name="java"这个<appender>不会打印任何信息
-由此分析，得出最终的打印结果为：
-```
-2018-03-27 23:12:16.147 [main] WARN  java.lang.Object - =====warn=====
-2018-03-27 23:12:16.150 [main] ERROR java.lang.Object - =====error=====
-```
-举一反三，上面的name="java"这个<appender>可以把additivity设置为true试试看是什么结果，如果对前面的分析理解的朋友应该很容易想到，有两部分日志输出，一部分是日志级别大于等于warn的、一部分是日志级别大于等于debug的。
-
-### <appender>
-接着看一下<appender>，<appender>是<configuration>的子节点，是负责写日志的组件。<appender>有两个必要属性name和class：
-
-1. name指定<appender>的名称
-2. class指定<appender>的全限定名
-<appender>有好几种，上面我们演示过的是ConsoleAppender，ConsoleAppender的作用是将日志输出到控制台，配置示例为：
-``` xml
-<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-     <encoder>
-         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-     </encoder>
-</appender>
-```
-其中，encoder表示对参数进行格式化。我们和上一部分的例子对比一下，发现这里是有所区别的，上面使用了<layout>定义<pattern>，这里使用了<encoder>定义<pattern>，简单说一下：
-1. <encoder>是0.9.19版本之后引进的，以前的版本使用<layout>，logback极力推荐的是使用<encoder>而不是<layout>
-2. 最常用的FileAppender和它的子类的期望是使用<encoder>而不再使用<layout>
-关于<encoder>中的格式下一部分再说。接着我们看一下FileAppender，FileAppender的作用是将日志写到文件中，配置示例为：
-``` xml
-<appender name="FILE" class="ch.qos.logback.core.FileAppender">  
-    <file>D:/123.log</file>  
-    <append>true</append>  
-    <encoder>  
-        <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>  
-    </encoder>  
-</appender>
-```
-它的几个节点为：
-1. <file>表示写入的文件名，可以使相对目录也可以是绝对目录，如果上级目录不存在则自动创建
-2. <appender>如果为true表示日志被追加到文件结尾，如果是false表示清空文件
-3. <encoder>表示输出格式，后面说
-4. <prudent>如果为true表示日志会被安全地写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认为false
-接着来看一下RollingFileAppender，RollingFileAppender的作用是滚动记录文件，先将日志记录到指定文件，当符合某个条件时再将日志记录到其他文件，RollingFileAppender配置比较灵活，因此使用得更多，示例为：
-``` xml
-<appender name="ROLLING-FILE-1" class="ch.qos.logback.core.rolling.RollingFileAppender">   
-    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">   
-        <fileNamePattern>rolling-file-%d{yyyy-MM-dd}.log</fileNamePattern>   
-        <maxHistory>30</maxHistory>    
-    </rollingPolicy>   
-    <encoder>   
-        <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>   
-    </encoder>   
-</appender>
-```
-这种是仅仅指定了<rollingPolicy>的写法，<rollingPolicy>的作用是当发生滚动时，定义RollingFileAppender的行为，其中上面的TimeBasedRollingPolicy是最常用的滚动策略，它根据时间指定滚动策略，既负责滚动也负责触发滚动，有以下节点：
-
-1. <fileNamePattern>，必要节点，包含文件名及"%d"转换符，"%d"可以包含一个Java.text.SimpleDateFormat指定的时间格式，如%d{yyyy-MM}，如果直接使用%d那么格式为yyyy-MM-dd。RollingFileAppender的file子节点可有可无，通过设置file可以为活动文件和归档文件指定不同的位置
-2. <maxHistory>，可选节点，控制保留的归档文件的最大数量，如果超出数量就删除旧文件，假设设置每个月滚动且<maxHistory>是6，则只保存最近6个月的文件
-向其他还有SizeBasedTriggeringPolicy，用于按照文件大小进行滚动，可以自己查阅一下资料。
-
-## 异步写日志
-
-日志通常来说都以文件形式记录到磁盘，例如使用<RollingFileAppender>，这样的话一次写日志就会发生一次磁盘IO，这对于性能是一种损耗，因此更多的，对于每次请求必打的日志（例如请求日志，记录请求API、参数、请求时间），我们会采取异步写日志的方式而不让此次写日志发生磁盘IO，阻塞线程从而造成不必要的性能损耗。（不要小看这个点，可以网上查一下服务端性能优化的文章，只是因为将日志改为异步写，整个QPS就有了大幅的提高）。
-
-接着我们看下如何使用logback进行异步写日志配置：
-``` xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<configuration scan="false" scanPeriod="60000" debug="false">
-
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <appender name="ROLLING-FILE-1" class="ch.qos.logback.core.rolling.RollingFileAppender">   
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">   
-              <fileNamePattern>D:/rolling-file-%d{yyyy-MM-dd}.log</fileNamePattern>   
-              <maxHistory>30</maxHistory>    
-        </rollingPolicy>   
-        <encoder>
-              <pattern>%-4relative [%thread] %-5level %lo{35} - %msg%n</pattern>   
-        </encoder>   
-    </appender>
-
-    <!-- 异步输出 -->  
-    <appender name ="ASYNC" class= "ch.qos.logback.classic.AsyncAppender">  
-        <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->  
-        <discardingThreshold>0</discardingThreshold>  
-        <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->  
-        <queueSize>256</queueSize>  
-        <!-- 添加附加的appender,最多只能添加一个 -->  
-        <appender-ref ref ="ROLLING-FILE-1"/>  
-    </appender>
-
-    <logger name="java" additivity="false" />
-    <logger name="java.lang" level="DEBUG">
-        <appender-ref ref="ASYNC" />
-    </logger>
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT" />
-    </root>
-
-</configuration>
-```
-
-即，我们引入了一个AsyncAppender，先说一下AsyncAppender的原理，再说一下几个参数：
-```
-当我们配置了AsyncAppender，系统启动时会初始化一条名为"AsyncAppender-Worker-ASYNC"的线程
-
-当Logging Event进入AsyncAppender后，AsyncAppender会调用appender方法，appender方法中再将event填入Buffer（使用的Buffer为BlockingQueue，具体实现为ArrayBlockingQueye）前，会先判断当前Buffer的容量以及丢弃日志特性是否开启，当消费能力不如生产能力时，AsyncAppender会将超出Buffer容量的Logging Event的级别进行丢弃，作为消费速度一旦跟不上生产速度导致Buffer溢出处理的一种方式。
-
-上面的线程的作用，就是从Buffer中取出Event，交给对应的appender进行后面的日志推送
-
-从上面的描述我们可以看出，AsyncAppender并不处理日志，只是将日志缓冲到一个BlockingQueue里面去，并在内部创建一个工作线程从队列头部获取日志，之后将获取的日志循环记录到附加的其他appender上去，从而达到不阻塞主线程的效果。因此AsyncAppender仅仅充当的是事件转发器，必须引用另外一个appender来做事。
-```
-
-从上述原理，我们就能比较清晰地理解几个参数的作用了：
-
-1. discardingThreshold，假如等于20则表示，表示当还剩20%容量时，将丢弃TRACE、DEBUG、INFO级别的Event，只保留WARN与ERROR级别的Event，为了保留所有的events，可以将这个值设置为0，默认值为queueSize/5
-2. queueSize比较好理解，BlockingQueue的最大容量，默认为256
-3. includeCallerData表示是否提取调用者数据，这个值被设置为true的代价是相当昂贵的，为了提升性能，默认当event被加入BlockingQueue时，event关联的调用者数据不会被提取，只有线程名这些比较简单的数据
-4. appender-ref表示AsyncAppender使用哪个具体的<appender>进行日志输出
-
-
-### <encoder>
-<encoder>节点负责两件事情：
-1. 把日志信息转换为字节数组
-2. 把字节数组写到输出流
-目前PatternLayoutEncoder是唯一有用的且默认的encoder，有一个<pattern>节点，就像上面演示的，用来设置日志的输入格式，使用“%+转换符"的方式，如果要输出"%"则必须使用"\%"对"%"进行转义。
-
-<encoder>的一些可用参数用表格表示一下：
-
-### Filter
-最后来看一下<filter>，<filter>是<appender>的一个子节点，表示在当前给到的日志级别下再进行一次过滤，最基本的Filter有ch.qos.logback.classic.filter.LevelFilter和ch.qos.logback.classic.filter.ThresholdFilter，首先看一下LevelFilter：
-``` xml
-<configuration scan="false" scanPeriod="60000" debug="false">
-
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-        </encoder>
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>WARN</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-    </appender>
-
-    <logger name="java" additivity="false" />
-    <logger name="java.lang" level="DEBUG">
-        <appender-ref ref="STDOUT" />
-    </logger>
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT" />
-    </root>
-
-</configuration>
-```
-看一下输出：
-```
-2018-03-31 22:22:58.843 [main] WARN  java.lang.Object - =====warn=====
-```
-看到尽管<logger>配置的是DEBUG，但是输出的只有warn，因为在<filter>中对匹配到WARN级别时做了ACCEPT（接受），对未匹配到WARN级别时做了DENY（拒绝），当然只能打印出WARN级别的日志。
-
-再看一下ThresholdFilter，配置为：
-``` xml
-<?xml version="1.0" encoding="UTF-8" ?>
-<configuration scan="false" scanPeriod="60000" debug="false">
-
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
-        </encoder>
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>INFO</level>
-        </filter>
-    </appender>
-
-    <logger name="java" additivity="false" />
-    <logger name="java.lang" level="DEBUG">
-        <appender-ref ref="STDOUT" />
-    </logger>
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT" />
-    </root>
-
-</configuration>
-```
-
-看一下输出为：
-```
-2018-03-31 22:41:32.353 [main] INFO  java.lang.Object - =====info=====
-2018-03-31 22:41:32.358 [main] WARN  java.lang.Object - =====warn=====
-2018-03-31 22:41:32.359 [main] ERROR java.lang.Object - =====error=====
-```
-因为ThresholdFilter的策略是，会将日志级别小于<level>的全部进行过滤，因此虽然指定了DEBUG级别，但是只有INFO及以上级别的才能被打印出来。
+https://www.cnblogs.com/xrq730/p/8628945.html
+
+### 为什么使用logback
+记得前几年工作的时候，公司使用的日志框架还是log4j，大约从16年中到现在，不管是我参与的别人已经搭建好的项目还是我自己主导的项目，日志框架基本都换成了logback，总结一下，logback大约有以下的一些优点：
+1. 内核重写、测试充分、初始化内存加载更小，这一切让logback性能和log4j相比有诸多倍的提升
+2. logback非常自然地直接实现了slf4j，这个严格来说算不上优点，只是这样，再理解slf4j的前提下会很容易理解logback，也同时很容易用其他日志框架替换logback
+3. logback有比较齐全的200多页的文档
+4. logback当配置文件修改了，支持自动重新加载配置文件，扫描过程快且安全，它并不需要另外创建一个扫描线程
+5. 支持自动去除旧的日志文件，可以控制已经产生日志文件的最大数量
+总而言之，如果大家的项目里面需要选择一个日志框架，那么我个人非常建议使用logback。
+### logback加载
+我们简单分析一下logback加载过程，当我们使用logback-classic.jar时，应用启动，那么logback会按照如下顺序进行扫描：
+1. 在系统配置文件System Properties中寻找是否有logback.configurationFile对应的value
+2. 在classpath下寻找是否有logback.groovy（即logback支持groovy与xml两种配置方式）
+3. 在classpath下寻找是否有logback-test.xml
+4. 在classpath下寻找是否有logback.xml
+以上任何一项找到了，就不进行后续扫描，按照对应的配置进行logback的初始化，具体代码实现可见ch.qos.logback.classic.util.ContextInitializer类的findURLOfDefaultConfigurationFile方法。
+当所有以上四项都找不到的情况下，logback会调用ch.qos.logback.classic.BasicConfigurator的configure方法，构造一个ConsoleAppender用于向控制台输出日志，默认日志输出格式为"%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"。
+### logback的configuration
+logback的重点应当是Appender、Logger、Pattern，在这之前先简单了解一下logback的<configuration>，<configuration>只有三个属性：
+1. scan：当scan被设置为true时，当配置文件发生改变，将会被重新加载，默认为true
+2. scanPeriod：检测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认为毫秒，当scan=true时这个值生效，默认时间间隔为1分钟
+3. debug：当被设置为true时，将打印出logback内部日志信息，实时查看logback运行信息，默认为false
+###  <logger>与<root>
+先从最基本的<logger>与<root>开始。
+<logger>用来设置某一个包或者具体某一个类的日志打印级别、以及指定<appender>。<logger>可以包含零个或者多个<appender-ref>元素，标识这个appender将会添加到这个logger。<logger>仅有一个name属性、一个可选的level属性和一个可选的additivity属性：
+1. name：用来指定受此logger约束的某一个包或者具体的某一个类
+2. level：用来设置打印级别，五个常用打印级别从低至高依次为TRACE、DEBUG、INFO、WARN、ERROR，如果未设置此级别，那么当前logger会继承上级的级别
+3. additivity：是否向上级logger传递打印信息，默认为true
+<root>也是<logger>元素，但是它是根logger，只有一个level属性，因为它的name就是root。
+接着写一段代码来测试一下：
+``` java
+public class Slf4jTest {
+    @Test
+    public void testSlf4j() {
+        Logger logger = LoggerFactory.getLogger(Object.class);
+        logger.trace("=====trace=====");  
+        logger.debug("=====debug=====");  
+        logger.info("=====info=====");  
+        logger.warn("=====warn=====");  
+        logger.error("=====error=====");  
+    }
+}
+```
+logback.xml
+``` xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration scan="false" scanPeriod="60000" debug="false">
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+        </layout>
+    </appender>
+
+    <root level="info">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
+```
+root将打印级别设置为"info"级别，<appender>暂时不管，控制台的输出为：
+```
+2018-03-26 22:57:48.779 [main] INFO  java.lang.Object - =====info=====
+2018-03-26 22:57:48.782 [main] WARN  java.lang.Object - =====warn=====
+2018-03-26 22:57:48.782 [main] ERROR java.lang.Object - =====error=====
+```
+logback.xml的意思是，当Test方法运行时，root节点将日志级别大于等于info的交给已经配置好的名为"STDOUT"的<appender>进行处理，"STDOUT"将信息打印到控制台上。
+接着理解一下<logger>节点的作用，logback.xml修改一下，加入一个只有name属性的<logger>：
+``` xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration scan="false" scanPeriod="60000" debug="false">
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+        </layout>
+    </appender>
+
+    <logger name="java" />
+
+     <root level="debug">
+         <appender-ref ref="STDOUT" />
+     </root>
+
+</configuration>
+```
+注意这个name表示的是LoggerFactory.getLogger(XXX.class)，XXX的包路径，包路径越少越是父级，我们测试代码里面是Object.class，即name="java"是name="java.lang"的父级，root是所有<logger>的父级。看一下输出为：
+```
+2018-03-27 23:02:02.963 [main] DEBUG java.lang.Object - =====debug=====
+2018-03-27 23:02:02.965 [main] INFO  java.lang.Object - =====info=====
+2018-03-27 23:02:02.966 [main] WARN  java.lang.Object - =====warn=====
+2018-03-27 23:02:02.966 [main] ERROR java.lang.Object - =====error=====
+```
+出现这样的结果是因为：
+1. <logger>中没有配置level，即继承父级的level，<logger>的父级为<root>，那么level=debug
+2. 没有配置additivity，那么additivity=true，表示此<logger>的打印信息向父级<root>传递
+3. 没有配置<appender-ref>，表示此<logger>不会打印出任何信息
+4. 由此可知，<logger>的打印信息向<root>传递，<root>使用"STDOUT"这个<appender>打印出所有大于等于debug级别的日志。举一反三，我们将<logger>的additivity配置为false，那么控制台应该不会打印出任何日志，因为<logger>的打印信息不会向父级<root>传递且<logger>没有配置任何<appender>，大家可以自己试验一下。
+
+接着，我们再配置一个<logger>：
+``` xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration scan="false" scanPeriod="60000" debug="false">
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+        </layout>
+    </appender>
+
+    <logger name="java" additivity="false" />
+    <logger name="java.lang" level="warn">
+        <appender-ref ref="STDOUT" />
+    </logger>
+
+    <root level="debug">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
+```
+如果读懂了上面的例子，那么这个例子应当很好理解：
+1. LoggerFactory.getLogger(Object.class)，首先找到name="java.lang"这个<logger>，将日志级别大于等于warn的使用"STDOUT"这个<appender>打印出来
+2. name="java.lang"这个<logger>没有配置additivity，那么additivity=true，打印信息向上传递，传递给父级name="java"这个<logger>
+3. name="java"这个<logger>的additivity=false且不关联任何<appender>，那么name="java"这个<appender>不会打印任何信息
+由此分析，得出最终的打印结果为：
+```
+2018-03-27 23:12:16.147 [main] WARN  java.lang.Object - =====warn=====
+2018-03-27 23:12:16.150 [main] ERROR java.lang.Object - =====error=====
+```
+举一反三，上面的name="java"这个<appender>可以把additivity设置为true试试看是什么结果，如果对前面的分析理解的朋友应该很容易想到，有两部分日志输出，一部分是日志级别大于等于warn的、一部分是日志级别大于等于debug的。
+
+### <appender>
+接着看一下<appender>，<appender>是<configuration>的子节点，是负责写日志的组件。<appender>有两个必要属性name和class：
+
+1. name指定<appender>的名称
+2. class指定<appender>的全限定名
+<appender>有好几种，上面我们演示过的是ConsoleAppender，ConsoleAppender的作用是将日志输出到控制台，配置示例为：
+``` xml
+<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+     <encoder>
+         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+     </encoder>
+</appender>
+```
+其中，encoder表示对参数进行格式化。我们和上一部分的例子对比一下，发现这里是有所区别的，上面使用了<layout>定义<pattern>，这里使用了<encoder>定义<pattern>，简单说一下：
+1. <encoder>是0.9.19版本之后引进的，以前的版本使用<layout>，logback极力推荐的是使用<encoder>而不是<layout>
+2. 最常用的FileAppender和它的子类的期望是使用<encoder>而不再使用<layout>
+关于<encoder>中的格式下一部分再说。接着我们看一下FileAppender，FileAppender的作用是将日志写到文件中，配置示例为：
+``` xml
+<appender name="FILE" class="ch.qos.logback.core.FileAppender">  
+    <file>D:/123.log</file>  
+    <append>true</append>  
+    <encoder>  
+        <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>  
+    </encoder>  
+</appender>
+```
+它的几个节点为：
+1. <file>表示写入的文件名，可以使相对目录也可以是绝对目录，如果上级目录不存在则自动创建
+2. <appender>如果为true表示日志被追加到文件结尾，如果是false表示清空文件
+3. <encoder>表示输出格式，后面说
+4. <prudent>如果为true表示日志会被安全地写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认为false
+接着来看一下RollingFileAppender，RollingFileAppender的作用是滚动记录文件，先将日志记录到指定文件，当符合某个条件时再将日志记录到其他文件，RollingFileAppender配置比较灵活，因此使用得更多，示例为：
+``` xml
+<appender name="ROLLING-FILE-1" class="ch.qos.logback.core.rolling.RollingFileAppender">   
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">   
+        <fileNamePattern>rolling-file-%d{yyyy-MM-dd}.log</fileNamePattern>   
+        <maxHistory>30</maxHistory>    
+    </rollingPolicy>   
+    <encoder>   
+        <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>   
+    </encoder>   
+</appender>
+```
+这种是仅仅指定了<rollingPolicy>的写法，<rollingPolicy>的作用是当发生滚动时，定义RollingFileAppender的行为，其中上面的TimeBasedRollingPolicy是最常用的滚动策略，它根据时间指定滚动策略，既负责滚动也负责触发滚动，有以下节点：
+
+1. <fileNamePattern>，必要节点，包含文件名及"%d"转换符，"%d"可以包含一个Java.text.SimpleDateFormat指定的时间格式，如%d{yyyy-MM}，如果直接使用%d那么格式为yyyy-MM-dd。RollingFileAppender的file子节点可有可无，通过设置file可以为活动文件和归档文件指定不同的位置
+2. <maxHistory>，可选节点，控制保留的归档文件的最大数量，如果超出数量就删除旧文件，假设设置每个月滚动且<maxHistory>是6，则只保存最近6个月的文件
+向其他还有SizeBasedTriggeringPolicy，用于按照文件大小进行滚动，可以自己查阅一下资料。
+
+## 异步写日志
+
+日志通常来说都以文件形式记录到磁盘，例如使用<RollingFileAppender>，这样的话一次写日志就会发生一次磁盘IO，这对于性能是一种损耗，因此更多的，对于每次请求必打的日志（例如请求日志，记录请求API、参数、请求时间），我们会采取异步写日志的方式而不让此次写日志发生磁盘IO，阻塞线程从而造成不必要的性能损耗。（不要小看这个点，可以网上查一下服务端性能优化的文章，只是因为将日志改为异步写，整个QPS就有了大幅的提高）。
+
+接着我们看下如何使用logback进行异步写日志配置：
+``` xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration scan="false" scanPeriod="60000" debug="false">
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <appender name="ROLLING-FILE-1" class="ch.qos.logback.core.rolling.RollingFileAppender">   
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">   
+              <fileNamePattern>D:/rolling-file-%d{yyyy-MM-dd}.log</fileNamePattern>   
+              <maxHistory>30</maxHistory>    
+        </rollingPolicy>   
+        <encoder>
+              <pattern>%-4relative [%thread] %-5level %lo{35} - %msg%n</pattern>   
+        </encoder>   
+    </appender>
+
+    <!-- 异步输出 -->  
+    <appender name ="ASYNC" class= "ch.qos.logback.classic.AsyncAppender">  
+        <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->  
+        <discardingThreshold>0</discardingThreshold>  
+        <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->  
+        <queueSize>256</queueSize>  
+        <!-- 添加附加的appender,最多只能添加一个 -->  
+        <appender-ref ref ="ROLLING-FILE-1"/>  
+    </appender>
+
+    <logger name="java" additivity="false" />
+    <logger name="java.lang" level="DEBUG">
+        <appender-ref ref="ASYNC" />
+    </logger>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
+```
+
+即，我们引入了一个AsyncAppender，先说一下AsyncAppender的原理，再说一下几个参数：
+```
+当我们配置了AsyncAppender，系统启动时会初始化一条名为"AsyncAppender-Worker-ASYNC"的线程
+
+当Logging Event进入AsyncAppender后，AsyncAppender会调用appender方法，appender方法中再将event填入Buffer（使用的Buffer为BlockingQueue，具体实现为ArrayBlockingQueye）前，会先判断当前Buffer的容量以及丢弃日志特性是否开启，当消费能力不如生产能力时，AsyncAppender会将超出Buffer容量的Logging Event的级别进行丢弃，作为消费速度一旦跟不上生产速度导致Buffer溢出处理的一种方式。
+
+上面的线程的作用，就是从Buffer中取出Event，交给对应的appender进行后面的日志推送
+
+从上面的描述我们可以看出，AsyncAppender并不处理日志，只是将日志缓冲到一个BlockingQueue里面去，并在内部创建一个工作线程从队列头部获取日志，之后将获取的日志循环记录到附加的其他appender上去，从而达到不阻塞主线程的效果。因此AsyncAppender仅仅充当的是事件转发器，必须引用另外一个appender来做事。
+```
+
+从上述原理，我们就能比较清晰地理解几个参数的作用了：
+
+1. discardingThreshold，假如等于20则表示，表示当还剩20%容量时，将丢弃TRACE、DEBUG、INFO级别的Event，只保留WARN与ERROR级别的Event，为了保留所有的events，可以将这个值设置为0，默认值为queueSize/5
+2. queueSize比较好理解，BlockingQueue的最大容量，默认为256
+3. includeCallerData表示是否提取调用者数据，这个值被设置为true的代价是相当昂贵的，为了提升性能，默认当event被加入BlockingQueue时，event关联的调用者数据不会被提取，只有线程名这些比较简单的数据
+4. appender-ref表示AsyncAppender使用哪个具体的<appender>进行日志输出
+
+
+### <encoder>
+<encoder>节点负责两件事情：
+1. 把日志信息转换为字节数组
+2. 把字节数组写到输出流
+目前PatternLayoutEncoder是唯一有用的且默认的encoder，有一个<pattern>节点，就像上面演示的，用来设置日志的输入格式，使用“%+转换符"的方式，如果要输出"%"则必须使用"\%"对"%"进行转义。
+
+<encoder>的一些可用参数用表格表示一下：
+
+### Filter
+最后来看一下<filter>，<filter>是<appender>的一个子节点，表示在当前给到的日志级别下再进行一次过滤，最基本的Filter有ch.qos.logback.classic.filter.LevelFilter和ch.qos.logback.classic.filter.ThresholdFilter，首先看一下LevelFilter：
+``` xml
+<configuration scan="false" scanPeriod="60000" debug="false">
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+        </encoder>
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>WARN</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+
+    <logger name="java" additivity="false" />
+    <logger name="java.lang" level="DEBUG">
+        <appender-ref ref="STDOUT" />
+    </logger>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
+```
+看一下输出：
+```
+2018-03-31 22:22:58.843 [main] WARN  java.lang.Object - =====warn=====
+```
+看到尽管<logger>配置的是DEBUG，但是输出的只有warn，因为在<filter>中对匹配到WARN级别时做了ACCEPT（接受），对未匹配到WARN级别时做了DENY（拒绝），当然只能打印出WARN级别的日志。
+
+再看一下ThresholdFilter，配置为：
+``` xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration scan="false" scanPeriod="60000" debug="false">
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
+        </encoder>
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>INFO</level>
+        </filter>
+    </appender>
+
+    <logger name="java" additivity="false" />
+    <logger name="java.lang" level="DEBUG">
+        <appender-ref ref="STDOUT" />
+    </logger>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
+```
+
+看一下输出为：
+```
+2018-03-31 22:41:32.353 [main] INFO  java.lang.Object - =====info=====
+2018-03-31 22:41:32.358 [main] WARN  java.lang.Object - =====warn=====
+2018-03-31 22:41:32.359 [main] ERROR java.lang.Object - =====error=====
+```
+因为ThresholdFilter的策略是，会将日志级别小于<level>的全部进行过滤，因此虽然指定了DEBUG级别，但是只有INFO及以上级别的才能被打印出来。
diff --git "a/04 - Middleware/TCC-Transaction/tcc\345\216\237\347\220\206.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/TCC-Transaction/tcc\345\216\237\347\220\206.txt"
similarity index 97%
rename from "04 - Middleware/TCC-Transaction/tcc\345\216\237\347\220\206.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/TCC-Transaction/tcc\345\216\237\347\220\206.txt"
index bd8b43ba..4e3b98a0 100644
--- "a/04 - Middleware/TCC-Transaction/tcc\345\216\237\347\220\206.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/TCC-Transaction/tcc\345\216\237\347\220\206.txt"	
@@ -1,27 +1,27 @@
-http://www.iocoder.cn/TCC-Transaction/tcc-core/?juejin&2018-02-05
-
-TCC事务
-为了解决在事务运行过程中大颗粒度资源锁定的问题，业界提出一种新的事务模型，它是基于业务层面的事务定义。锁粒度完全由业务自己控制。
-它本质是一种补偿的思路。它把事务运行过程分成 Try、Confirm / Cancel 两个阶段。
-在每个阶段的逻辑由业务代码控制。这样就事务的锁粒度可以完全自由控制。业务可以在牺牲隔离性的情况下，获取更高的性能。
-
-Try 阶段
-	Try ：尝试执行业务
-		  完成所有业务检查( 一致性 )
-		  预留必须业务资源( 准隔离性 )
-Confirm / Cancel 阶段：
-	Confirm ：确认执行业务
-		真正执行业务
-		不做任务业务检查
-		Confirm 操作满足幂等性
-	Cancel ：取消执行业务
-		释放 Try 阶段预留的业务资源
-		Cancel 操作满足幂等性
-	Confirm 与 Cancel 互斥
-
-与 2PC协议 比较：
-
-	位于业务服务层而非自愿层
-	没有单独的准备( Prepare )阶段，Try 操作兼备自愿操作与准备能力
-	Try 操作可以灵活选择业务资源的锁定粒度
-	较高开发成本
+http://www.iocoder.cn/TCC-Transaction/tcc-core/?juejin&2018-02-05
+
+TCC事务
+为了解决在事务运行过程中大颗粒度资源锁定的问题，业界提出一种新的事务模型，它是基于业务层面的事务定义。锁粒度完全由业务自己控制。
+它本质是一种补偿的思路。它把事务运行过程分成 Try、Confirm / Cancel 两个阶段。
+在每个阶段的逻辑由业务代码控制。这样就事务的锁粒度可以完全自由控制。业务可以在牺牲隔离性的情况下，获取更高的性能。
+
+Try 阶段
+	Try ：尝试执行业务
+		  完成所有业务检查( 一致性 )
+		  预留必须业务资源( 准隔离性 )
+Confirm / Cancel 阶段：
+	Confirm ：确认执行业务
+		真正执行业务
+		不做任务业务检查
+		Confirm 操作满足幂等性
+	Cancel ：取消执行业务
+		释放 Try 阶段预留的业务资源
+		Cancel 操作满足幂等性
+	Confirm 与 Cancel 互斥
+
+与 2PC协议 比较：
+
+	位于业务服务层而非自愿层
+	没有单独的准备( Prepare )阶段，Try 操作兼备自愿操作与准备能力
+	Try 操作可以灵活选择业务资源的锁定粒度
+	较高开发成本
diff --git a/04 - Middleware/Zookeeper/ZooKeeper API.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/ZooKeeper API.md"
similarity index 95%
rename from 04 - Middleware/Zookeeper/ZooKeeper API.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/ZooKeeper API.md"
index 140f88c9..158f5ce1 100644
--- a/04 - Middleware/Zookeeper/ZooKeeper API.md	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/ZooKeeper API.md"	
@@ -1,16 +1,16 @@
-
-connect - 连接到ZooKeeper集合
-
-create- 创建znode
-
-exists- 检查znode是否存在及其信息
-
-getData - 从特定的znode获取数据
-
-setData - 在特定的znode中设置数据
-
-getChildren - 获取特定znode中的所有子节点
-
-delete - 删除特定的znode及其所有子项
-
-close - 关闭连接
+
+connect - 连接到ZooKeeper集合
+
+create- 创建znode
+
+exists- 检查znode是否存在及其信息
+
+getData - 从特定的znode获取数据
+
+setData - 在特定的znode中设置数据
+
+getChildren - 获取特定znode中的所有子节点
+
+delete - 删除特定的znode及其所有子项
+
+close - 关闭连接
diff --git a/04 - Middleware/Zookeeper/Zookeeper CLI.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper CLI.md"
similarity index 94%
rename from 04 - Middleware/Zookeeper/Zookeeper CLI.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper CLI.md"
index 46ef5380..0d75976d 100644
--- a/04 - Middleware/Zookeeper/Zookeeper CLI.md	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper CLI.md"	
@@ -1,10 +1,10 @@
-Zookeeper CLI
-
-1、创建znode
-2、获取数据
-3、监视znode的变化
-4、设置数据
-5、创建znode的子节点
-6、列出znode的子节点
-7、检查状态
-8、移除/删除znode
+Zookeeper CLI
+
+1、创建znode
+2、获取数据
+3、监视znode的变化
+4、设置数据
+5、创建znode的子节点
+6、列出znode的子节点
+7、检查状态
+8、移除/删除znode
diff --git "a/04 - Middleware/Zookeeper/Zookeeper leader\351\200\211\344\270\276.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper leader\351\200\211\344\270\276.md"
similarity index 98%
rename from "04 - Middleware/Zookeeper/Zookeeper leader\351\200\211\344\270\276.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper leader\351\200\211\344\270\276.md"
index 6c4964ed..8cc3cd7e 100644
--- "a/04 - Middleware/Zookeeper/Zookeeper leader\351\200\211\344\270\276.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper leader\351\200\211\344\270\276.md"	
@@ -1,17 +1,17 @@
-让我们分析如何在ZooKeeper集合中选举leader节点。考虑一个集群中有N个节点。leader选举的过程如下：
-
-  * 所有节点创建具有相同路径 `/app/leader_election/guid_` 的顺序、临时节点。
-  * ZooKeeper集合将附加10位序列号到路径
-    创建的znode将是 `/app/leader_election/guid_0000000001`，`/app/leader_election/guid_0000000002`等。
-  * 对于给定的实例，在znode中创建`最小数字`的节点成为`leader`，而所有其他节点是`follower`。
-  * 每个`follower节点`监视下一个具有`最小数字的znode`。例如，
-    创建znode/app/leader_election/guid_000000000`8`的节点将监视znode/app/leader_election/guid_000000000`7`，
-    创建znode/app/leader_election/guid_000000000`7`的节点将监视znode/app/leader_election/guid_000000000`6`。
-  * 如果leader关闭，则其相应的`znode/app/leader_electionN`会被删除。
-  * 下一个在线follower节点将通过监视器获得关于leader移除的通知。
-  * 下一个在线follower节点将检查是否存在其他具有最小数字的znode。
-    如果没有，那么它将承担leader的角色。
-    否则，它找到的创建具有最小数字的znode的节点将作为leader。
-  * 类似地，所有其他follower节点选举创建具有最小数字的znode的节点作为leader。
-
-  leader选举是一个复杂的过程，但ZooKeeper服务使它非常简单。
+让我们分析如何在ZooKeeper集合中选举leader节点。考虑一个集群中有N个节点。leader选举的过程如下：
+
+  * 所有节点创建具有相同路径 `/app/leader_election/guid_` 的顺序、临时节点。
+  * ZooKeeper集合将附加10位序列号到路径
+    创建的znode将是 `/app/leader_election/guid_0000000001`，`/app/leader_election/guid_0000000002`等。
+  * 对于给定的实例，在znode中创建`最小数字`的节点成为`leader`，而所有其他节点是`follower`。
+  * 每个`follower节点`监视下一个具有`最小数字的znode`。例如，
+    创建znode/app/leader_election/guid_000000000`8`的节点将监视znode/app/leader_election/guid_000000000`7`，
+    创建znode/app/leader_election/guid_000000000`7`的节点将监视znode/app/leader_election/guid_000000000`6`。
+  * 如果leader关闭，则其相应的`znode/app/leader_electionN`会被删除。
+  * 下一个在线follower节点将通过监视器获得关于leader移除的通知。
+  * 下一个在线follower节点将检查是否存在其他具有最小数字的znode。
+    如果没有，那么它将承担leader的角色。
+    否则，它找到的创建具有最小数字的znode的节点将作为leader。
+  * 类似地，所有其他follower节点选举创建具有最小数字的znode的节点作为leader。
+
+  leader选举是一个复杂的过程，但ZooKeeper服务使它非常简单。
diff --git "a/04 - Middleware/Zookeeper/Zookeeper \345\237\272\347\241\200.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper \345\237\272\347\241\200.md"
similarity index 98%
rename from "04 - Middleware/Zookeeper/Zookeeper \345\237\272\347\241\200.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper \345\237\272\347\241\200.md"
index a18d636b..4516c1ce 100644
--- "a/04 - Middleware/Zookeeper/Zookeeper \345\237\272\347\241\200.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper \345\237\272\347\241\200.md"	
@@ -1,67 +1,67 @@
-在深入了解ZooKeeper的运作之前，让我们来看看ZooKeeper的基本概念。本章中讨论以下主题：
-  1. Architecture（架构）
-  2. Hierarchical namespace（层次命名空间）
-  3. Session（会话）
-  4. Watches（监视）
-
-### 1. ZooKeeper的架构
-  看看下面的图表。它描述了ZooKeeper的“客户端-服务器架构”。
-  <img src="jiagou.jpg">
-
-  作为ZooKeeper架构的一部分的每个组件在下表中进行了说明。
-
-  部分	描述
-  **Client（客户端）**
-  客户端，我们的分布式应用集群中的一个节点，从服务器访问信息。对于特定的时间间隔，每个客户端向服务器发送消息以使服务器知道客户端是活跃的。
-  类似地，当客户端连接时，服务器发送确认码。如果连接的服务器没有响应，客户端会自动将消息重定向到另一个服务器。
-  **Server（服务器）**
-  服务器，我们的ZooKeeper总体中的一个节点，为客户端提供所有的服务。向客户端发送确认码以告知服务器是活跃的。
-  **Ensemble**
-  ZooKeeper服务器组。形成ensemble所需的最小节点数为3。
-  **Leader**
-  服务器节点，如果任何连接的节点失败，则执行自动恢复。Leader在服务启动时被选举。
-  **Follower**
-  跟随leader指令的服务器节点。
-
-### 2. 层次命名空间
-  下图描述了用于内存表示的ZooKeeper文件系统的树结构。ZooKeeper节点称为 `znode` 。每个znode由一个名称标识，并用路径(/)序列分隔。
-
-  <img src = "shuju.jpg">
-
-  在图中，首先有一个由“/”分隔的znode。在根目录下，你有两个逻辑命名空间 `config` 和 `workers` 。
-
-  `config` 命名空间用于`集中式配置管理`，`workers` 命名空间`用于命名`。
-
-  在 `config` 命名空间下，每个znode最多可存储1MB的数据。这与UNIX文件系统相类似，除了父znode也可以存储数据。这种结构的主要目的是存储同步数据并描述znode的元数据。此结构称为 `ZooKeeper数据模型`。
-
-  ZooKeeper数据模型中的每个znode都维护着一个 `stat` 结构。一个stat仅提供一个znode的元数据。它由版本号，操作控制列表(ACL)，时间戳和数据长度组成。
-
-  * **版本号** - 每个znode都有版本号，这意味着每当与znode相关联的数据发生变化时，其对应的版本号也会增加。当多个zookeeper客户端尝试在同一znode上执行操作时，版本号的使用就很重要。
-
-  * **操作控制列表(ACL)** - ACL基本上是访问znode的认证机制。它管理所有znode读取和写入操作。
-
-  * **时间戳** - 时间戳表示创建和修改znode所经过的时间。它通常以毫秒为单位。ZooKeeper从“事务ID"(zxid)标识znode的每个更改。Zxid 是唯一的，并且为每个事务保留时间，以便你可以轻松地确定从一个请求到另一个请求所经过的时间。
-
-  * **数据长度** - 存储在znode中的数据总量是数据长度。你最多可以存储1MB的数据。
-
-#### Znode的类型
-
-  Znode被分为持久（persistent）节点，顺序（sequential）节点和临时（ephemeral）节点。
-
-  `持久节点`  - 即使在创建该特定znode的客户端断开连接后，持久节点仍然存在。默认情况下，除非另有说明，否则所有znode都是持久的。
-
-  `临时节点` - 客户端活跃时，临时节点就是有效的。当客户端与ZooKeeper集合断开连接时，临时节点会自动删除。因此，只有临时节点不允许有子节点。如果临时节点被删除，则下一个合适的节点将填充其位置。临时节点在leader选举中起着重要作用。
-
-  `顺序节点` - 顺序节点可以是持久的或临时的。当一个新的znode被创建为一个顺序节点时，ZooKeeper通过将10位的序列号附加到原始名称来设置znode的路径。例如，如果将具有路径 /myapp 的znode创建为顺序节点，则ZooKeeper会将路径更改为 /myapp0000000001 ，并将下一个序列号设置为0000000002。如果两个顺序节点是同时创建的，那么ZooKeeper不会对每个znode使用相同的数字。顺序节点在锁定和同步中起重要作用。
-
-### 3. Sessions（会话）
-  会话对于ZooKeeper的操作非常重要。会话中的请求按FIFO顺序执行。一旦客户端连接到服务器，将建立会话并向客户端分配 **会话ID** 。
-
-  客户端以特定的时间间隔发送 **心跳** 以保持会话有效。如果ZooKeeper集合在超过服务器开启时指定的期间（会话超时）都没有从客户端接收到心跳，则它会判定客户端死机。
-
-  会话超时通常以毫秒为单位。当会话由于任何原因结束时，在该会话期间创建的临时节点也会被删除。
-
-### 4. Watches（监视）
-  监视是一种简单的机制，使客户端收到关于ZooKeeper集合中的更改的通知。客户端可以在读取特定znode时设置Watches。Watches会向注册的客户端发送任何znode（客户端注册表）更改的通知。
-
-  Znode更改是与znode相关的数据的修改或znode的子项中的更改。只触发一次watches。如果客户端想要再次通知，则必须通过另一个读取操作来完成。当连接会话过期时，客户端将与服务器断开连接，相关的watches也将被删除。
+在深入了解ZooKeeper的运作之前，让我们来看看ZooKeeper的基本概念。本章中讨论以下主题：
+  1. Architecture（架构）
+  2. Hierarchical namespace（层次命名空间）
+  3. Session（会话）
+  4. Watches（监视）
+
+### 1. ZooKeeper的架构
+  看看下面的图表。它描述了ZooKeeper的“客户端-服务器架构”。
+  <img src="jiagou.jpg">
+
+  作为ZooKeeper架构的一部分的每个组件在下表中进行了说明。
+
+  部分	描述
+  **Client（客户端）**
+  客户端，我们的分布式应用集群中的一个节点，从服务器访问信息。对于特定的时间间隔，每个客户端向服务器发送消息以使服务器知道客户端是活跃的。
+  类似地，当客户端连接时，服务器发送确认码。如果连接的服务器没有响应，客户端会自动将消息重定向到另一个服务器。
+  **Server（服务器）**
+  服务器，我们的ZooKeeper总体中的一个节点，为客户端提供所有的服务。向客户端发送确认码以告知服务器是活跃的。
+  **Ensemble**
+  ZooKeeper服务器组。形成ensemble所需的最小节点数为3。
+  **Leader**
+  服务器节点，如果任何连接的节点失败，则执行自动恢复。Leader在服务启动时被选举。
+  **Follower**
+  跟随leader指令的服务器节点。
+
+### 2. 层次命名空间
+  下图描述了用于内存表示的ZooKeeper文件系统的树结构。ZooKeeper节点称为 `znode` 。每个znode由一个名称标识，并用路径(/)序列分隔。
+
+  <img src = "shuju.jpg">
+
+  在图中，首先有一个由“/”分隔的znode。在根目录下，你有两个逻辑命名空间 `config` 和 `workers` 。
+
+  `config` 命名空间用于`集中式配置管理`，`workers` 命名空间`用于命名`。
+
+  在 `config` 命名空间下，每个znode最多可存储1MB的数据。这与UNIX文件系统相类似，除了父znode也可以存储数据。这种结构的主要目的是存储同步数据并描述znode的元数据。此结构称为 `ZooKeeper数据模型`。
+
+  ZooKeeper数据模型中的每个znode都维护着一个 `stat` 结构。一个stat仅提供一个znode的元数据。它由版本号，操作控制列表(ACL)，时间戳和数据长度组成。
+
+  * **版本号** - 每个znode都有版本号，这意味着每当与znode相关联的数据发生变化时，其对应的版本号也会增加。当多个zookeeper客户端尝试在同一znode上执行操作时，版本号的使用就很重要。
+
+  * **操作控制列表(ACL)** - ACL基本上是访问znode的认证机制。它管理所有znode读取和写入操作。
+
+  * **时间戳** - 时间戳表示创建和修改znode所经过的时间。它通常以毫秒为单位。ZooKeeper从“事务ID"(zxid)标识znode的每个更改。Zxid 是唯一的，并且为每个事务保留时间，以便你可以轻松地确定从一个请求到另一个请求所经过的时间。
+
+  * **数据长度** - 存储在znode中的数据总量是数据长度。你最多可以存储1MB的数据。
+
+#### Znode的类型
+
+  Znode被分为持久（persistent）节点，顺序（sequential）节点和临时（ephemeral）节点。
+
+  `持久节点`  - 即使在创建该特定znode的客户端断开连接后，持久节点仍然存在。默认情况下，除非另有说明，否则所有znode都是持久的。
+
+  `临时节点` - 客户端活跃时，临时节点就是有效的。当客户端与ZooKeeper集合断开连接时，临时节点会自动删除。因此，只有临时节点不允许有子节点。如果临时节点被删除，则下一个合适的节点将填充其位置。临时节点在leader选举中起着重要作用。
+
+  `顺序节点` - 顺序节点可以是持久的或临时的。当一个新的znode被创建为一个顺序节点时，ZooKeeper通过将10位的序列号附加到原始名称来设置znode的路径。例如，如果将具有路径 /myapp 的znode创建为顺序节点，则ZooKeeper会将路径更改为 /myapp0000000001 ，并将下一个序列号设置为0000000002。如果两个顺序节点是同时创建的，那么ZooKeeper不会对每个znode使用相同的数字。顺序节点在锁定和同步中起重要作用。
+
+### 3. Sessions（会话）
+  会话对于ZooKeeper的操作非常重要。会话中的请求按FIFO顺序执行。一旦客户端连接到服务器，将建立会话并向客户端分配 **会话ID** 。
+
+  客户端以特定的时间间隔发送 **心跳** 以保持会话有效。如果ZooKeeper集合在超过服务器开启时指定的期间（会话超时）都没有从客户端接收到心跳，则它会判定客户端死机。
+
+  会话超时通常以毫秒为单位。当会话由于任何原因结束时，在该会话期间创建的临时节点也会被删除。
+
+### 4. Watches（监视）
+  监视是一种简单的机制，使客户端收到关于ZooKeeper集合中的更改的通知。客户端可以在读取特定znode时设置Watches。Watches会向注册的客户端发送任何znode（客户端注册表）更改的通知。
+
+  Znode更改是与znode相关的数据的修改或znode的子项中的更改。只触发一次watches。如果客户端想要再次通知，则必须通过另一个读取操作来完成。当连接会话过期时，客户端将与服务器断开连接，相关的watches也将被删除。
diff --git "a/04 - Middleware/Zookeeper/Zookeeper \345\267\245\344\275\234\346\265\201.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper \345\267\245\344\275\234\346\265\201.md"
similarity index 99%
rename from "04 - Middleware/Zookeeper/Zookeeper \345\267\245\344\275\234\346\265\201.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper \345\267\245\344\275\234\346\265\201.md"
index d7ea86a9..bea14584 100644
--- "a/04 - Middleware/Zookeeper/Zookeeper \345\267\245\344\275\234\346\265\201.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/Zookeeper \345\267\245\344\275\234\346\265\201.md"	
@@ -1,31 +1,31 @@
-  一旦 **ZooKeeper集合** 启动，它将等待客户端连接。客户端将连接到ZooKeeper集合中的一个节点。它可以是leader或follower节点。
-  一旦 **客户端被连接**，节点将向特定客户端分配会话ID并向该客户端发送确认。
-  如果客户端没有收到确认，它将尝试连接ZooKeeper集合中的另一个节点。 一旦连接到节点，客户端将以有规律的间隔向节点发送心跳，以确保连接不会丢失。
-
-  * **如果客户端想要读取特定的znode**，它将会向具有znode路径的节点发送读取请求，并且节点通过从其自己的数据库获取来返回所请求的znode。为此，在ZooKeeper集合中读取速度很快。
-  * **如果客户端想要将数据存储在ZooKeeper集合中**，则会将znode路径和数据发送到服务器。连接的服务器将该请求转发给leader，然后leader将向所有的follower重新发出写入请求。如果只有大部分节点成功响应，而写入请求成功，则成功返回代码将被发送到客户端。 否则，写入请求失败。绝大多数节点被称为 **Quorum** 。
-
-**ZooKeeper集合中的节点**
-  让我们分析在ZooKeeper集合中拥有不同数量的节点的效果。
-
-  如果我们有 **单个节点**，则当该节点故障时，ZooKeeper集合将故障。它有助于“单点故障"，不建议在生产环境中使用。
-
-  如果我们有 **两个节点** 而一个节点故障，我们没有占多数，因为两个中的一个不是多数。
-
-  如果我们有 **三个节点** 而一个节点故障，那么我们有大多数，因此，这是最低要求。ZooKeeper集合在实际生产环境中必须至少有三个节点。
-
-  如果我们有 **四个节点** 而两个节点故障，它将再次故障。类似于有三个节点，额外节点不用于任何目的，因此，最好添加奇数的节点，例如3，5，7。
-
-  我们知道写入过程比ZooKeeper集合中的读取过程要贵，因为所有节点都需要在数据库中写入相同的数据。因此，对于平衡的环境拥有较少数量（例如3，5，7）的节点比拥有大量的节点要好。
-
-  下图描述了ZooKeeper工作流，后面的表说明了它的不同组件。
-  <img src="zujian.png">
-
-      组件	                                       描述
-  **写入（write）**	                        写入过程由leader节点处理。leader将写入请求转发到所有znode，并等待znode的回复。如果一半的znode回复，则写入过程完成。
-  **读取（read）**	                        读取由特定连接的znode在内部执行，因此不需要与集群进行交互。
-  **复制数据库（replicated database）**	   它用于在zookeeper中存储数据。每个znode都有自己的数据库，每个znode在一致性的帮助下每次都有相同的数据。
-  **Leader**                               Leader是负责处理写入请求的Znode。
-  **Follower**	                           follower从客户端接收写入请求，并将它们转发到leader znode。
-  **请求处理器（request processor）**     	 只存在于leader节点。它管理来自follower节点的写入请求。
-  **原子广播（atomic broadcasts）**        	负责广播从leader节点到follower节点的变化。
+  一旦 **ZooKeeper集合** 启动，它将等待客户端连接。客户端将连接到ZooKeeper集合中的一个节点。它可以是leader或follower节点。
+  一旦 **客户端被连接**，节点将向特定客户端分配会话ID并向该客户端发送确认。
+  如果客户端没有收到确认，它将尝试连接ZooKeeper集合中的另一个节点。 一旦连接到节点，客户端将以有规律的间隔向节点发送心跳，以确保连接不会丢失。
+
+  * **如果客户端想要读取特定的znode**，它将会向具有znode路径的节点发送读取请求，并且节点通过从其自己的数据库获取来返回所请求的znode。为此，在ZooKeeper集合中读取速度很快。
+  * **如果客户端想要将数据存储在ZooKeeper集合中**，则会将znode路径和数据发送到服务器。连接的服务器将该请求转发给leader，然后leader将向所有的follower重新发出写入请求。如果只有大部分节点成功响应，而写入请求成功，则成功返回代码将被发送到客户端。 否则，写入请求失败。绝大多数节点被称为 **Quorum** 。
+
+**ZooKeeper集合中的节点**
+  让我们分析在ZooKeeper集合中拥有不同数量的节点的效果。
+
+  如果我们有 **单个节点**，则当该节点故障时，ZooKeeper集合将故障。它有助于“单点故障"，不建议在生产环境中使用。
+
+  如果我们有 **两个节点** 而一个节点故障，我们没有占多数，因为两个中的一个不是多数。
+
+  如果我们有 **三个节点** 而一个节点故障，那么我们有大多数，因此，这是最低要求。ZooKeeper集合在实际生产环境中必须至少有三个节点。
+
+  如果我们有 **四个节点** 而两个节点故障，它将再次故障。类似于有三个节点，额外节点不用于任何目的，因此，最好添加奇数的节点，例如3，5，7。
+
+  我们知道写入过程比ZooKeeper集合中的读取过程要贵，因为所有节点都需要在数据库中写入相同的数据。因此，对于平衡的环境拥有较少数量（例如3，5，7）的节点比拥有大量的节点要好。
+
+  下图描述了ZooKeeper工作流，后面的表说明了它的不同组件。
+  <img src="zujian.png">
+
+      组件	                                       描述
+  **写入（write）**	                        写入过程由leader节点处理。leader将写入请求转发到所有znode，并等待znode的回复。如果一半的znode回复，则写入过程完成。
+  **读取（read）**	                        读取由特定连接的znode在内部执行，因此不需要与集群进行交互。
+  **复制数据库（replicated database）**	   它用于在zookeeper中存储数据。每个znode都有自己的数据库，每个znode在一致性的帮助下每次都有相同的数据。
+  **Leader**                               Leader是负责处理写入请求的Znode。
+  **Follower**	                           follower从客户端接收写入请求，并将它们转发到leader znode。
+  **请求处理器（request processor）**     	 只存在于leader节点。它管理来自follower节点的写入请求。
+  **原子广播（atomic broadcasts）**        	负责广播从leader节点到follower节点的变化。
diff --git a/04 - Middleware/Zookeeper/jiagou.jpg "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/jiagou.jpg"
similarity index 100%
rename from 04 - Middleware/Zookeeper/jiagou.jpg
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/jiagou.jpg"
diff --git a/04 - Middleware/Zookeeper/shuju.jpg "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/shuju.jpg"
similarity index 100%
rename from 04 - Middleware/Zookeeper/shuju.jpg
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/shuju.jpg"
diff --git a/04 - Middleware/Zookeeper/what.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/what.md"
similarity index 98%
rename from 04 - Middleware/Zookeeper/what.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/what.md"
index c3492bef..e4f1522c 100644
--- a/04 - Middleware/Zookeeper/what.md	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/what.md"	
@@ -1,102 +1,102 @@
-### Zookeeper的数据模型
-
-它很像数据结构当中的树，也很像文件系统的目录。
-树是由节点所组成，Zookeeper的数据存储也同样是基于节点，这种节点叫做 **Znode**。
-但是，不同于树的节点，Znode的引用方式是路径引用，类似于文件路径：
-/ 动物 / 仓鼠
-/ 植物 / 荷花
-这样的层级结构，让每一个Znode节点拥有唯一的路径，就像命名空间一样对不同信息作出清晰的隔离。
-
-### Znode
-data：
-Znode存储的数据信息。
-
-ACL：
-记录Znode的访问权限，即哪些人或哪些IP可以访问本节点。
-
-stat：
-包含Znode的各种元数据，比如事务ID、版本号、时间戳、大小等等。
-
-child：
-当前节点的子节点引用，类似于二叉树的左孩子右孩子。
-
-这里需要注意一点，Zookeeper是为读多写少的场景所设计。
-Znode并不是用来存储大规模业务数据，而是用于存储少量的状态和配置信息，每个节点的数据最大不能超过1MB。
-
-Zookeeper的基本操作 和事件通知Zookeeper 基本操作
-这里列举出比较常用的API：
-`create`创建节点
-`delete`删除节点
-`exists`判断节点是否存在
-`getData`获得一个节点的数据
-`setData`设置一个节点的数据
-`getChildren`获取节点下的所有子节点
-这其中，`exists`，`getData`，`getChildren`属于读操作。
-`Zookeeper`客户端在请求读操作的时候，可以选择是否设置`Watch`。
-Watch是什么意思呢？
-我们可以理解成是注册在特定Znode上的触发器。当这个Znode发生改变，也就是调用了`create`，`delete`，`setData`方法的时候，将会触发Znode上注册的对应事件，请求`Watch`的客户端会接收到异步通知。
-具体交互过程如下：
-1.客户端调用`getData`方法，`watch`参数是true。服务端接到请求，返回节点数据，并且在对应的哈希表里插入被Watch的Znode路径，以及Watcher列表。
-
-2.当被Watch的Znode已删除，服务端会查找哈希表，找到该Znode对应的所有Watcher，异步通知客户端，并且删除哈希表中对应的Key-Value。
-
-### Zookeeper的一致性
-Zookeeper的集群
-Zookeeper Service集群是一主多从结构。
-在更新数据时，首先更新到主节点（这里的节点是指服务器，不是Znode），再同步到从节点。
-在读取数据时，直接读取任意从节点。
-为了保证主从节点的数据一致性，Zookeeper采用了 **ZAB协议**，这种协议非常类似于一致性算法Paxos和Raft。
-ZAB Zookeeper Atomic Broadcast
-
-ZAB协议所定义的三种节点状态：
-`Looking` ：选举状态。
-`Following` ：Follower节点（从节点）所处的状态。
-`Leading` ：Leader节点（主节点）所处状态。
-
-我们还需要知道`最大ZXID`的概念：最大ZXID也就是节点本地的最新事务编号，包含`epoch`和计数两部分。
-`epoch`是纪元的意思，相当于Raft算法选主时候的term。
-假如Zookeeper当前的主节点挂掉了，集群会进行崩溃恢复。
-**ZAB的崩溃恢复分成** 三个阶段：
-1. Leader election
-
-选举阶段，此时集群中的节点处于Looking状态。它们会各自向其他节点发起投票，投票当中包含自己的服务器ID和最新事务ID（ZXID）。
-
-接下来，节点会用自身的ZXID和从其他节点接收到的ZXID做比较，如果发现别人家的ZXID比自己大，也就是数据比自己新，那么就重新发起投票，投票给目前已知最大的ZXID所属节点。
-
-每次投票后，服务器都会统计投票数量，判断是否有某个节点得到半数以上的投票。如果存在这样的节点，该节点将会成为准Leader，状态变为Leading。其他节点的状态变为Following。
-
-这就相当于，一群武林高手经过激烈的竞争，选出了武林盟主。
-
-2. Discovery
-发现阶段，用于在从节点中发现最新的ZXID和事务日志。或许有人会问：既然Leader被选为主节点，已经是集群里数据最新的了，为什么还要从节点中寻找最新事务呢？
-
-这是为了防止某些意外情况，比如因网络原因在上一阶段产生多个Leader的情况。
-
-所以这一阶段，Leader集思广益，接收所有Follower发来各自的最新epoch值。Leader从中选出最大的epoch，基于此值加1，生成新的epoch分发给各个Follower。
-
-各个Follower收到全新的epoch后，返回ACK给Leader，带上各自最大的ZXID和历史事务日志。Leader选出最大的ZXID，并更新自身历史日志。
-
-3. Synchronization
-同步阶段，把Leader刚才收集得到的最新历史事务日志，同步给集群中所有的Follower。
-只有当半数Follower同步成功，这个准Leader才能成为正式的Leader。自此，故障恢复正式完成。
-
-Broadcast就是Zookeeper常规情况下更新数据的时候，由Leader广播到所有的Follower。
-其过程如下：
-1. 客户端发出写入数据请求给任意Follower。
-2. Follower把写入数据请求转发给Leader。
-3. Leader采用二阶段提交方式，先发送Propose广播给Follower。
-4. Follower接到Propose消息，写入日志成功后，返回ACK消息给Leader。
-5. Leader接到半数以上ACK消息，返回成功给客户端，并且广播Commit请求给Follower。
-
-Zab协议既不是强一致性，也不是弱一致性，而是处于两者之间的单调一致性。它依靠事务ID和版本号，保证了数据的更新和读取是有序的。
-
-
-### Zookeeper的应用
-`1.分布式锁`
-这是雅虎研究员设计Zookeeper的初衷。利用Zookeeper的临时顺序节点，可以轻松实现分布式锁。
-`2.服务注册和发现`
-利用Znode和Watcher，可以实现分布式服务的注册和发现。最著名的应用就是阿里的分布式RPC框架Dubbo。
-`3.共享配置和状态信息`
-Redis的分布式解决方案Codis，就利用了Zookeeper来存放数据路由表和 codis-proxy 节点的元信息。
-同时 codis-config 发起的命令都会通过 ZooKeeper 同步到各个存活的 codis-proxy。
-此外，Kafka、HBase、Hadoop，也都依靠Zookeeper同步节点信息，实现高可用。
+### Zookeeper的数据模型
+
+它很像数据结构当中的树，也很像文件系统的目录。
+树是由节点所组成，Zookeeper的数据存储也同样是基于节点，这种节点叫做 **Znode**。
+但是，不同于树的节点，Znode的引用方式是路径引用，类似于文件路径：
+/ 动物 / 仓鼠
+/ 植物 / 荷花
+这样的层级结构，让每一个Znode节点拥有唯一的路径，就像命名空间一样对不同信息作出清晰的隔离。
+
+### Znode
+data：
+Znode存储的数据信息。
+
+ACL：
+记录Znode的访问权限，即哪些人或哪些IP可以访问本节点。
+
+stat：
+包含Znode的各种元数据，比如事务ID、版本号、时间戳、大小等等。
+
+child：
+当前节点的子节点引用，类似于二叉树的左孩子右孩子。
+
+这里需要注意一点，Zookeeper是为读多写少的场景所设计。
+Znode并不是用来存储大规模业务数据，而是用于存储少量的状态和配置信息，每个节点的数据最大不能超过1MB。
+
+Zookeeper的基本操作 和事件通知Zookeeper 基本操作
+这里列举出比较常用的API：
+`create`创建节点
+`delete`删除节点
+`exists`判断节点是否存在
+`getData`获得一个节点的数据
+`setData`设置一个节点的数据
+`getChildren`获取节点下的所有子节点
+这其中，`exists`，`getData`，`getChildren`属于读操作。
+`Zookeeper`客户端在请求读操作的时候，可以选择是否设置`Watch`。
+Watch是什么意思呢？
+我们可以理解成是注册在特定Znode上的触发器。当这个Znode发生改变，也就是调用了`create`，`delete`，`setData`方法的时候，将会触发Znode上注册的对应事件，请求`Watch`的客户端会接收到异步通知。
+具体交互过程如下：
+1.客户端调用`getData`方法，`watch`参数是true。服务端接到请求，返回节点数据，并且在对应的哈希表里插入被Watch的Znode路径，以及Watcher列表。
+
+2.当被Watch的Znode已删除，服务端会查找哈希表，找到该Znode对应的所有Watcher，异步通知客户端，并且删除哈希表中对应的Key-Value。
+
+### Zookeeper的一致性
+Zookeeper的集群
+Zookeeper Service集群是一主多从结构。
+在更新数据时，首先更新到主节点（这里的节点是指服务器，不是Znode），再同步到从节点。
+在读取数据时，直接读取任意从节点。
+为了保证主从节点的数据一致性，Zookeeper采用了 **ZAB协议**，这种协议非常类似于一致性算法Paxos和Raft。
+ZAB Zookeeper Atomic Broadcast
+
+ZAB协议所定义的三种节点状态：
+`Looking` ：选举状态。
+`Following` ：Follower节点（从节点）所处的状态。
+`Leading` ：Leader节点（主节点）所处状态。
+
+我们还需要知道`最大ZXID`的概念：最大ZXID也就是节点本地的最新事务编号，包含`epoch`和计数两部分。
+`epoch`是纪元的意思，相当于Raft算法选主时候的term。
+假如Zookeeper当前的主节点挂掉了，集群会进行崩溃恢复。
+**ZAB的崩溃恢复分成** 三个阶段：
+1. Leader election
+
+选举阶段，此时集群中的节点处于Looking状态。它们会各自向其他节点发起投票，投票当中包含自己的服务器ID和最新事务ID（ZXID）。
+
+接下来，节点会用自身的ZXID和从其他节点接收到的ZXID做比较，如果发现别人家的ZXID比自己大，也就是数据比自己新，那么就重新发起投票，投票给目前已知最大的ZXID所属节点。
+
+每次投票后，服务器都会统计投票数量，判断是否有某个节点得到半数以上的投票。如果存在这样的节点，该节点将会成为准Leader，状态变为Leading。其他节点的状态变为Following。
+
+这就相当于，一群武林高手经过激烈的竞争，选出了武林盟主。
+
+2. Discovery
+发现阶段，用于在从节点中发现最新的ZXID和事务日志。或许有人会问：既然Leader被选为主节点，已经是集群里数据最新的了，为什么还要从节点中寻找最新事务呢？
+
+这是为了防止某些意外情况，比如因网络原因在上一阶段产生多个Leader的情况。
+
+所以这一阶段，Leader集思广益，接收所有Follower发来各自的最新epoch值。Leader从中选出最大的epoch，基于此值加1，生成新的epoch分发给各个Follower。
+
+各个Follower收到全新的epoch后，返回ACK给Leader，带上各自最大的ZXID和历史事务日志。Leader选出最大的ZXID，并更新自身历史日志。
+
+3. Synchronization
+同步阶段，把Leader刚才收集得到的最新历史事务日志，同步给集群中所有的Follower。
+只有当半数Follower同步成功，这个准Leader才能成为正式的Leader。自此，故障恢复正式完成。
+
+Broadcast就是Zookeeper常规情况下更新数据的时候，由Leader广播到所有的Follower。
+其过程如下：
+1. 客户端发出写入数据请求给任意Follower。
+2. Follower把写入数据请求转发给Leader。
+3. Leader采用二阶段提交方式，先发送Propose广播给Follower。
+4. Follower接到Propose消息，写入日志成功后，返回ACK消息给Leader。
+5. Leader接到半数以上ACK消息，返回成功给客户端，并且广播Commit请求给Follower。
+
+Zab协议既不是强一致性，也不是弱一致性，而是处于两者之间的单调一致性。它依靠事务ID和版本号，保证了数据的更新和读取是有序的。
+
+
+### Zookeeper的应用
+`1.分布式锁`
+这是雅虎研究员设计Zookeeper的初衷。利用Zookeeper的临时顺序节点，可以轻松实现分布式锁。
+`2.服务注册和发现`
+利用Znode和Watcher，可以实现分布式服务的注册和发现。最著名的应用就是阿里的分布式RPC框架Dubbo。
+`3.共享配置和状态信息`
+Redis的分布式解决方案Codis，就利用了Zookeeper来存放数据路由表和 codis-proxy 节点的元信息。
+同时 codis-config 发起的命令都会通过 ZooKeeper 同步到各个存活的 codis-proxy。
+此外，Kafka、HBase、Hadoop，也都依靠Zookeeper同步节点信息，实现高可用。
diff --git a/04 - Middleware/Zookeeper/zujian.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/zujian.png"
similarity index 100%
rename from 04 - Middleware/Zookeeper/zujian.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/zujian.png"
diff --git "a/04 - Middleware/Zookeeper/\345\256\211\350\243\205.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/\345\256\211\350\243\205.md"
similarity index 96%
rename from "04 - Middleware/Zookeeper/\345\256\211\350\243\205.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/\345\256\211\350\243\205.md"
index abf2e2b4..699f8d39 100644
--- "a/04 - Middleware/Zookeeper/\345\256\211\350\243\205.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/\345\256\211\350\243\205.md"	
@@ -1,76 +1,76 @@
-ZooKeeper框架安装
-
-### 1 下载ZooKeeper
-
-  要在你的计算机上安装ZooKeeper框架，请访问以下链接并下载最新版本的ZooKeeper。http://zookeeper.apache.org/releases.html
-  到目前为止，zookeeper-3.4.12.tar.gz
-
-### 2 提取tar文件
-  使用以下命令提取tar文件
-
-      $ cd opt/
-      $ tar -zxf zookeeper-3.4.12.tar.gz
-      $ cd zookeeper-3.4.12
-      $ mkdir data
-
-### 3 创建配置文件
-
-  使用命令 vi conf/zoo.cfg 和所有以下参数设置为起点，打开名为 conf/zoo.cfg 的配置文件。
-
-      $ vi conf/zoo.cfg
-
-      tickTime = 2000
-      dataDir = /opt/tool/zookeeper-3.4.12/data
-      clientPort = 2181
-      initLimit = 5
-      syncLimit = 2
-
-      server.1=****:2888:3888
-      server.2=****:2888:3888
-
-
-  一旦成功保存配置文件，再次返回终端。你现在可以启动zookeeper服务器。
-
-环境变量
-
-集群：https://www.cnblogs.com/LUA123/p/7222216.html
-问题：https://blog.csdn.net/qzqanzc/article/details/78641122
-vim /etc/profile
-# zookeeper
-export ZK_HOME=/opt/tool/zookeeper-3.4.12
-export PATH=$ZK_HOME/bin:$PATH
-
-source /etc/profile
-### 4 启动ZooKeeper服务器
-
-  执行以下命令
-      $ bin/zkServer.sh start
-
-  执行此命令后，你将收到以下响应
-
-      $ ZooKeeper JMX enabled by default
-      $ Using config: /opt/tool/zookeeper-3.4.12/bin/../conf/zoo.cfg
-      $ Starting zookeeper ... STARTED
-
-
-### 5 启动CLI
-  键入以下命令
-      $ bin/zkCli.sh
-
-  键入上述命令后，将连接到ZooKeeper服务器，你应该得到以下响应。
-
-      Connecting to localhost:2181
-      ................
-      ................
-      ................
-      Welcome to ZooKeeper!
-      ................
-      ................
-      WATCHER::
-      WatchedEvent state:SyncConnected type: None path:null
-      [zk: localhost:2181(CONNECTED) 0]
-
-  停止ZooKeeper服务器
-  连接服务器并执行所有操作后，可以使用以下命令停止zookeeper服务器。
-
-      $ bin/zkServer.sh stop
+ZooKeeper框架安装
+
+### 1 下载ZooKeeper
+
+  要在你的计算机上安装ZooKeeper框架，请访问以下链接并下载最新版本的ZooKeeper。http://zookeeper.apache.org/releases.html
+  到目前为止，zookeeper-3.4.12.tar.gz
+
+### 2 提取tar文件
+  使用以下命令提取tar文件
+
+      $ cd opt/
+      $ tar -zxf zookeeper-3.4.12.tar.gz
+      $ cd zookeeper-3.4.12
+      $ mkdir data
+
+### 3 创建配置文件
+
+  使用命令 vi conf/zoo.cfg 和所有以下参数设置为起点，打开名为 conf/zoo.cfg 的配置文件。
+
+      $ vi conf/zoo.cfg
+
+      tickTime = 2000
+      dataDir = /opt/tool/zookeeper-3.4.12/data
+      clientPort = 2181
+      initLimit = 5
+      syncLimit = 2
+
+      server.1=****:2888:3888
+      server.2=****:2888:3888
+
+
+  一旦成功保存配置文件，再次返回终端。你现在可以启动zookeeper服务器。
+
+环境变量
+
+集群：https://www.cnblogs.com/LUA123/p/7222216.html
+问题：https://blog.csdn.net/qzqanzc/article/details/78641122
+vim /etc/profile
+# zookeeper
+export ZK_HOME=/opt/tool/zookeeper-3.4.12
+export PATH=$ZK_HOME/bin:$PATH
+
+source /etc/profile
+### 4 启动ZooKeeper服务器
+
+  执行以下命令
+      $ bin/zkServer.sh start
+
+  执行此命令后，你将收到以下响应
+
+      $ ZooKeeper JMX enabled by default
+      $ Using config: /opt/tool/zookeeper-3.4.12/bin/../conf/zoo.cfg
+      $ Starting zookeeper ... STARTED
+
+
+### 5 启动CLI
+  键入以下命令
+      $ bin/zkCli.sh
+
+  键入上述命令后，将连接到ZooKeeper服务器，你应该得到以下响应。
+
+      Connecting to localhost:2181
+      ................
+      ................
+      ................
+      Welcome to ZooKeeper!
+      ................
+      ................
+      WATCHER::
+      WatchedEvent state:SyncConnected type: None path:null
+      [zk: localhost:2181(CONNECTED) 0]
+
+  停止ZooKeeper服务器
+  连接服务器并执行所有操作后，可以使用以下命令停止zookeeper服务器。
+
+      $ bin/zkServer.sh stop
diff --git "a/04 - Middleware/Zookeeper/\345\267\245\344\275\234\345\216\237\347\220\206.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/\345\267\245\344\275\234\345\216\237\347\220\206.md"
similarity index 99%
rename from "04 - Middleware/Zookeeper/\345\267\245\344\275\234\345\216\237\347\220\206.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/\345\267\245\344\275\234\345\216\237\347\220\206.md"
index 0d8977ef..bf8c2ecf 100644
--- "a/04 - Middleware/Zookeeper/\345\267\245\344\275\234\345\216\237\347\220\206.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/Zookeeper/\345\267\245\344\275\234\345\216\237\347\220\206.md"	
@@ -1,7 +1,7 @@
-ZooKeeper 的核心是原子广播，这个机制保证了各个 Server 之间的同步。实现这个机制的协议叫做 `Zab 协议`。
-Zab 协议有两种模式，它们分别是`恢复模式（选主）`和`广播模式（同步）`。
-当服务启动或者在领导者崩溃后，Zab 就进入了恢复模式，当领导者被选举出来，且大多数 Server 完成了和 leader 的状态同步以后，恢复模式就结束了。
-状态同步保证了 leader 和 Server 具有相同的系统状态。
-
-为了保证事务的顺序一致性，ZooKeeper 采用了`递增的事务 id 号（zxid）`来标识事务。
-所有的提议（proposal）都在被提出的时候加上了 zxid。实现中 zxid 是一个 64 位的数字，它高 32 位是 epoch 用来标识 leader 关系是否改变，每次一个 leader 被选出来，它都会有一个新的 epoch，标识当前属于那个 leader 的统治时期。低 32 位用于递增计数。
+ZooKeeper 的核心是原子广播，这个机制保证了各个 Server 之间的同步。实现这个机制的协议叫做 `Zab 协议`。
+Zab 协议有两种模式，它们分别是`恢复模式（选主）`和`广播模式（同步）`。
+当服务启动或者在领导者崩溃后，Zab 就进入了恢复模式，当领导者被选举出来，且大多数 Server 完成了和 leader 的状态同步以后，恢复模式就结束了。
+状态同步保证了 leader 和 Server 具有相同的系统状态。
+
+为了保证事务的顺序一致性，ZooKeeper 采用了`递增的事务 id 号（zxid）`来标识事务。
+所有的提议（proposal）都在被提出的时候加上了 zxid。实现中 zxid 是一个 64 位的数字，它高 32 位是 epoch 用来标识 leader 关系是否改变，每次一个 leader 被选出来，它都会有一个新的 epoch，标识当前属于那个 leader 的统治时期。低 32 位用于递增计数。
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/docker/why.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/docker/why.md"
new file mode 100644
index 00000000..9fbb1738
--- /dev/null
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/docker/why.md"	
@@ -0,0 +1 @@
+https://yeasy.gitbooks.io/docker_practice/content/introduction/why.html
diff --git "a/04 - Middleware/docker/\345\270\270\347\224\250\345\221\275\344\273\244.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/docker/\345\270\270\347\224\250\345\221\275\344\273\244.md"
similarity index 100%
rename from "04 - Middleware/docker/\345\270\270\347\224\250\345\221\275\344\273\244.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/docker/\345\270\270\347\224\250\345\221\275\344\273\244.md"
diff --git a/04 - Middleware/dubbo/dubbo-architecture.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/dubbo-architecture.png"
similarity index 100%
rename from 04 - Middleware/dubbo/dubbo-architecture.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/dubbo-architecture.png"
diff --git "a/04 - Middleware/dubbo/zookeeper\345\234\250dubbo\344\270\255\347\232\204\344\275\234\347\224\250.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/zookeeper\345\234\250dubbo\344\270\255\347\232\204\344\275\234\347\224\250.md"
similarity index 99%
rename from "04 - Middleware/dubbo/zookeeper\345\234\250dubbo\344\270\255\347\232\204\344\275\234\347\224\250.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/zookeeper\345\234\250dubbo\344\270\255\347\232\204\344\275\234\347\224\250.md"
index 460385f0..e84b02b7 100644
--- "a/04 - Middleware/dubbo/zookeeper\345\234\250dubbo\344\270\255\347\232\204\344\275\234\347\224\250.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/zookeeper\345\234\250dubbo\344\270\255\347\232\204\344\275\234\347\224\250.md"	
@@ -1,26 +1,26 @@
-zookeeper是dubbo推荐的注册中心。
-![](https://github.com/loveincode/notes/blob/master/image/04/dubbo/1.jpg)
- 1. 服务提供者启动时向/dubbo/com.foo.BarService/providers目录下写入URL
- 2. 服务消费者启动时订阅/dubbo/com.foo.BarService/providers目录下的URL向/dubbo/com.foo.BarService/consumers目录下写入自己的URL
- 3. 监控中心启动时订阅/dubbo/com.foo.BarService目录下的所有提供者和消费者URL
-
-支持以下功能：
-
- 1. 当提供者出现断电等异常停机时，注册中心能自动删除提供者信息。
- 2. 当注册中心重启时，能自动恢复注册数据，以及订阅请求。
- 3. 当会话过期时，能自动恢复注册数据，以及订阅请求。
- 4. 当设置<dubbo:registry check="false" />时，记录失败注册和订阅请求，后台定时重试。
- 5. 可通过<dubbo:registry username="admin" password="1234" />设置zookeeper登录信息。
- 6. 可通过<dubbo:registry group="dubbo" />设置zookeeper的根节点，不设置将使用无根树。
- 7. 支持*号通配符<dubbo:reference group="*" version="*" />，可订阅服务的所有分组和所有版本的提供者。
-
-注意的是阿里内部并没有采用Zookeeper做为注册中心，而是使用自己实现的基于数据库的注册中心，即：Zookeeper注册中心并没有在阿里内部长时间运行的可靠性保障，此Zookeeper桥接实现只为开源版本提供，其可靠性依赖于Zookeeper本身的可靠性。
-
-dubbo是**动物**..zookeeper是**动物园的管理员**！
-
-按我的理解，您可以把dubbo服务想象成学校里的一个学生，并且对应有一个学号，zookeeper则是想象成一个教务网管理系统。我们可以通过教务网管理系统，查找到对应的学生。我们首先通过注册入学，将学生和学号对应绑定。          
-
-比方说项目是一个分布式的项目，web层与 service层被拆分了开来， 部署在不同的tomcat中， 我在web层 需要调用 service层的接口，但是两个运行在不同tomcat下的服务无法直接互调接口，那么就可以通过zookeeper和dubbo实现。 我们通过dubbo 建立ItemService这个服务，并且到zookeeper上面注册，填写对应的zookeeper服务所在 的IP及端口号。【按照我上面的比喻就是，学生注册入学（接口是学号，学生本人是impl实现），填写学校教务网网址（就是zookeeper）】
-![](https://github.com/loveincode/notes/blob/master/image/04/dubbo/2.jpg)
-下面我们的 web层需要来调用 service接口了，由于在不同的工程中，它是无法直接找到service接口的，我们使用dubbo再来引用注册进入的dubbo服务。我们先填写zookeeper服务所在 的IP及端口号，再填写我们需要调用的接口名字。【按照我上面的比喻，就是填写学校的教务网网址，我们在教务网中，通过学号（接口名），查询到对应的学生】
-![](https://github.com/loveincode/notes/blob/master/image/04/dubbo/3.jpg)
+zookeeper是dubbo推荐的注册中心。
+![](https://github.com/loveincode/notes/blob/master/image/04/dubbo/1.jpg)
+ 1. 服务提供者启动时向/dubbo/com.foo.BarService/providers目录下写入URL
+ 2. 服务消费者启动时订阅/dubbo/com.foo.BarService/providers目录下的URL向/dubbo/com.foo.BarService/consumers目录下写入自己的URL
+ 3. 监控中心启动时订阅/dubbo/com.foo.BarService目录下的所有提供者和消费者URL
+
+支持以下功能：
+
+ 1. 当提供者出现断电等异常停机时，注册中心能自动删除提供者信息。
+ 2. 当注册中心重启时，能自动恢复注册数据，以及订阅请求。
+ 3. 当会话过期时，能自动恢复注册数据，以及订阅请求。
+ 4. 当设置<dubbo:registry check="false" />时，记录失败注册和订阅请求，后台定时重试。
+ 5. 可通过<dubbo:registry username="admin" password="1234" />设置zookeeper登录信息。
+ 6. 可通过<dubbo:registry group="dubbo" />设置zookeeper的根节点，不设置将使用无根树。
+ 7. 支持*号通配符<dubbo:reference group="*" version="*" />，可订阅服务的所有分组和所有版本的提供者。
+
+注意的是阿里内部并没有采用Zookeeper做为注册中心，而是使用自己实现的基于数据库的注册中心，即：Zookeeper注册中心并没有在阿里内部长时间运行的可靠性保障，此Zookeeper桥接实现只为开源版本提供，其可靠性依赖于Zookeeper本身的可靠性。
+
+dubbo是**动物**..zookeeper是**动物园的管理员**！
+
+按我的理解，您可以把dubbo服务想象成学校里的一个学生，并且对应有一个学号，zookeeper则是想象成一个教务网管理系统。我们可以通过教务网管理系统，查找到对应的学生。我们首先通过注册入学，将学生和学号对应绑定。          
+
+比方说项目是一个分布式的项目，web层与 service层被拆分了开来， 部署在不同的tomcat中， 我在web层 需要调用 service层的接口，但是两个运行在不同tomcat下的服务无法直接互调接口，那么就可以通过zookeeper和dubbo实现。 我们通过dubbo 建立ItemService这个服务，并且到zookeeper上面注册，填写对应的zookeeper服务所在 的IP及端口号。【按照我上面的比喻就是，学生注册入学（接口是学号，学生本人是impl实现），填写学校教务网网址（就是zookeeper）】
+![](https://github.com/loveincode/notes/blob/master/image/04/dubbo/2.jpg)
+下面我们的 web层需要来调用 service接口了，由于在不同的工程中，它是无法直接找到service接口的，我们使用dubbo再来引用注册进入的dubbo服务。我们先填写zookeeper服务所在 的IP及端口号，再填写我们需要调用的接口名字。【按照我上面的比喻，就是填写学校的教务网网址，我们在教务网中，通过学号（接口名），查询到对应的学生】
+![](https://github.com/loveincode/notes/blob/master/image/04/dubbo/3.jpg)
diff --git "a/04 - Middleware/dubbo/\345\256\230\347\275\221\351\246\226\351\241\265 \347\277\273\350\257\221.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/\345\256\230\347\275\221\351\246\226\351\241\265 \347\277\273\350\257\221.md"
similarity index 97%
rename from "04 - Middleware/dubbo/\345\256\230\347\275\221\351\246\226\351\241\265 \347\277\273\350\257\221.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/\345\256\230\347\275\221\351\246\226\351\241\265 \347\277\273\350\257\221.md"
index 2e00f42f..62b8be32 100644
--- "a/04 - Middleware/dubbo/\345\256\230\347\275\221\351\246\226\351\241\265 \347\277\273\350\257\221.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/\345\256\230\347\275\221\351\246\226\351\241\265 \347\277\273\350\257\221.md"	
@@ -1,169 +1,169 @@
-
-DUBBO
-
-	a high-performance, java based, open source RPC framework
-	一个高性能的，基于java的开源RPC框架
-
-Overview 	概述
-	Dubbo |ˈdʌbəʊ| is a high-performance, java based RPC framework open-sourced by Alibaba. As in many RPC systems, dubbo is based around the idea of defining a service, specifying the methods that can be called remotely with their parameters and return types. On the server side, the server implements this interface and runs a dubbo server to handle client calls. On the client side, the client has a stub that provides the same methods as the server.
-	
-	Dubbo |ˈdʌbəʊ| is a high-performance, java based RPC framework open-sourced by Alibaba. 
-	在许多的RPC系统，dubbo是基于定义的服务理念，指定可与他们的参数和返回类型的方法调用。
-	在服务器端，服务器实现此接口，并运行一个dubbo服务器处理客户端调用。
-	在客户端，客户端有一个存根，它提供与服务器相同的方法。
-	
-	
-Dubbo 架构
-
-
-   Provider 生产者 		→→→(1.register)登记     Registry 注册表
-   ↑(0.start)启动									↓2.subscribe 订阅
-													↑3.notify  通知
-   Container 容器		→→→(4.invoke) 援引		Consumer 消费者
-
-				↓5.count					↓5.count
-						  Monitor 监控
-
-Dubbo offers three key functionalities, which include interface based remote call, fault tolerance & load balancing, and automatic service registration & discovery. Dubbo framework is widely adopted inside Alibaba and outside by other companies including jingdong, dangdang, qunar, kaola, and many others.						  
-
-Dubbo提供了三个关键功能，包括远程调用接口、容错和负载平衡，和自动服务注册与发现。
-Dubbo框架被广泛采用阿里巴巴内部和外部的其他公司包括京东、当当网、去哪儿、考拉，和许多其他。
-
-Quick start
-This guide gets you started with dubbo in Java with a simple working example. You could find the complete working samples from directory ‘dubbo-demo’ in dubbo project on github.
-
-快速启动
-
-本指南让你开始用Dubbo在java用一个简单的例子。你可以从目录“Dubbo演示“ Dubbo项目GitHub上找到完整的工作样本。
-
-Prerequisites
-JDK: version 6 or higher
-Maven: version 3 or higher
-
-先决条件
-JDK：版本6或更高版本
-Maven：版本3或更高版本
-
-Maven dependency
-You may need to use the latest release  to build your dubbo application.
-您可能需要使用最新版本的应用程序来建立您的Dubbo。
-
-<dependency>
-    <groupId>com.alibaba</groupId>
-    <artifactId>dubbo</artifactId>
-    <version>${dubbo.version}</version>
-</dependency>
-
-Define service interface
-Since both service provider and service consumer rely on the same interface, it is strongly recommended to put the interface definition below in one separated module which could be shared by both provider module and consumer module.
-
-定义服务接口
-
-由于服务提供者和服务使用者都依赖同一接口，所以强烈建议将下面的接口定义放在一个单独的模块中，该模块可以由提供者模块和消费模块共享。
-
-package com.alibaba.dubbo.demo;
-
-public interface DemoService {
-    String sayHello(String name);
-}
-
-
-Implement service provider
-
-package com.alibaba.dubbo.demo.provider;
-import com.alibaba.dubbo.demo.DemoService;
-
-public class DemoServiceImpl implements DemoService {
-    public String sayHello(String name) {
-        return "Hello " + name;
-    }
-}
-
-Configure service provider
-The code snippet below shows how a dubbo service provider is configured with spring framework, which is recommended, however you could also use API configuration if it’s preferred.
-配置服务提供商
-
-下面的代码片断显示了Dubbo服务提供商配置Spring框架，这是推荐的，不过你也可以如果是优先使用的API配置。
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
-    <dubbo:application name="demo-provider"/>
-    <dubbo:registry address="multicast://224.5.6.7:1234"/>
-    <dubbo:protocol name="dubbo" port="20880"/>
-    <dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoService"/>
-    <bean id="demoService" class="com.alibaba.dubbo.demo.provider.DemoServiceImpl"/>
-</beans>
-
-Start service provider
-
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-
-public class Provider {
-    public static void main(String[] args) throws Exception {
-        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
-                new String[] {"META-INF/spring/dubbo-demo-provider.xml"});
-        context.start();
-        // press any key to exit
-        System.in.read();
-    }
-}
-
-Configure service consumer
-Again, the code below demonstrates spring integration
-配置服务消费者
-
-同样，下面的代码演示了Spring集成
-
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
-    <dubbo:application name="demo-consumer"/>
-    <dubbo:registry address="multicast://224.5.6.7:1234"/>
-    <dubbo:reference id="demoService" interface="com.alibaba.dubbo.demo.DemoService"/>
-</beans>
-
-Run service consumer
-
-import com.alibaba.dubbo.demo.DemoService;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-
-public class Consumer {
-    public static void main(String[] args) throws Exception {
-        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
-                new String[]{"META-INF/spring/dubbo-demo-consumer.xml"});
-        context.start();
-        // obtain proxy object for remote invocation
-        DemoService demoService = (DemoService) context.getBean("demoService");
-        // execute remote invocation
-        String hello = demoService.sayHello("world");
-        // show the result
-        System.out.println(hello);
-    }
-}
-
-What’s next
-Read this excellent article Introduction to Dubbo to learn more on dubbo’s basic features.
-Dive deep into dubbo user guide (English, Chinese) to find more details.
-Read dubbo admin guide (English, Chinese) for dubbo application administration topics.
-Interested in how dubbo is designed, or want to contribute? Read dubbo developer guide (English, Chinese), and start to hack the code.
- to discuss with dubbo core team.
-Explore more side projects you may interested from github dubbo group.
-
-下一步是什么
-
-读这篇优秀的文章介绍到Dubbo去学习更多的Dubbo的基本特征。	http://www.baeldung.com/dubbo
-
-深入到Dubbo用户指南（英文，中文）找到更多的细节。 详细说明 	http://dubbo.io/books/dubbo-user-book/
-
-读Dubbo管理员指南（英文，中文）为Dubbo应用管理主题。 安装运维手册	http://dubbo.io/books/dubbo-admin-book/
-
-感兴趣的Dubbo设计，或想做出贡献？读Dubbo开发指南（英文，中文），并开始修改代码。 开发指南	http://dubbo.io/books/dubbo-dev-book/
-
-与Dubbo核心团队讨论。
-
-探索更多的项目你会感兴趣的从GitHubDubbo集团。	https://github.com/dubbo
-	
+
+DUBBO
+
+	a high-performance, java based, open source RPC framework
+	一个高性能的，基于java的开源RPC框架
+
+Overview 	概述
+	Dubbo |ˈdʌbəʊ| is a high-performance, java based RPC framework open-sourced by Alibaba. As in many RPC systems, dubbo is based around the idea of defining a service, specifying the methods that can be called remotely with their parameters and return types. On the server side, the server implements this interface and runs a dubbo server to handle client calls. On the client side, the client has a stub that provides the same methods as the server.
+	
+	Dubbo |ˈdʌbəʊ| is a high-performance, java based RPC framework open-sourced by Alibaba. 
+	在许多的RPC系统，dubbo是基于定义的服务理念，指定可与他们的参数和返回类型的方法调用。
+	在服务器端，服务器实现此接口，并运行一个dubbo服务器处理客户端调用。
+	在客户端，客户端有一个存根，它提供与服务器相同的方法。
+	
+	
+Dubbo 架构
+
+
+   Provider 生产者 		→→→(1.register)登记     Registry 注册表
+   ↑(0.start)启动									↓2.subscribe 订阅
+													↑3.notify  通知
+   Container 容器		→→→(4.invoke) 援引		Consumer 消费者
+
+				↓5.count					↓5.count
+						  Monitor 监控
+
+Dubbo offers three key functionalities, which include interface based remote call, fault tolerance & load balancing, and automatic service registration & discovery. Dubbo framework is widely adopted inside Alibaba and outside by other companies including jingdong, dangdang, qunar, kaola, and many others.						  
+
+Dubbo提供了三个关键功能，包括远程调用接口、容错和负载平衡，和自动服务注册与发现。
+Dubbo框架被广泛采用阿里巴巴内部和外部的其他公司包括京东、当当网、去哪儿、考拉，和许多其他。
+
+Quick start
+This guide gets you started with dubbo in Java with a simple working example. You could find the complete working samples from directory ‘dubbo-demo’ in dubbo project on github.
+
+快速启动
+
+本指南让你开始用Dubbo在java用一个简单的例子。你可以从目录“Dubbo演示“ Dubbo项目GitHub上找到完整的工作样本。
+
+Prerequisites
+JDK: version 6 or higher
+Maven: version 3 or higher
+
+先决条件
+JDK：版本6或更高版本
+Maven：版本3或更高版本
+
+Maven dependency
+You may need to use the latest release  to build your dubbo application.
+您可能需要使用最新版本的应用程序来建立您的Dubbo。
+
+<dependency>
+    <groupId>com.alibaba</groupId>
+    <artifactId>dubbo</artifactId>
+    <version>${dubbo.version}</version>
+</dependency>
+
+Define service interface
+Since both service provider and service consumer rely on the same interface, it is strongly recommended to put the interface definition below in one separated module which could be shared by both provider module and consumer module.
+
+定义服务接口
+
+由于服务提供者和服务使用者都依赖同一接口，所以强烈建议将下面的接口定义放在一个单独的模块中，该模块可以由提供者模块和消费模块共享。
+
+package com.alibaba.dubbo.demo;
+
+public interface DemoService {
+    String sayHello(String name);
+}
+
+
+Implement service provider
+
+package com.alibaba.dubbo.demo.provider;
+import com.alibaba.dubbo.demo.DemoService;
+
+public class DemoServiceImpl implements DemoService {
+    public String sayHello(String name) {
+        return "Hello " + name;
+    }
+}
+
+Configure service provider
+The code snippet below shows how a dubbo service provider is configured with spring framework, which is recommended, however you could also use API configuration if it’s preferred.
+配置服务提供商
+
+下面的代码片断显示了Dubbo服务提供商配置Spring框架，这是推荐的，不过你也可以如果是优先使用的API配置。
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+    <dubbo:application name="demo-provider"/>
+    <dubbo:registry address="multicast://224.5.6.7:1234"/>
+    <dubbo:protocol name="dubbo" port="20880"/>
+    <dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoService"/>
+    <bean id="demoService" class="com.alibaba.dubbo.demo.provider.DemoServiceImpl"/>
+</beans>
+
+Start service provider
+
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class Provider {
+    public static void main(String[] args) throws Exception {
+        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
+                new String[] {"META-INF/spring/dubbo-demo-provider.xml"});
+        context.start();
+        // press any key to exit
+        System.in.read();
+    }
+}
+
+Configure service consumer
+Again, the code below demonstrates spring integration
+配置服务消费者
+
+同样，下面的代码演示了Spring集成
+
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+    <dubbo:application name="demo-consumer"/>
+    <dubbo:registry address="multicast://224.5.6.7:1234"/>
+    <dubbo:reference id="demoService" interface="com.alibaba.dubbo.demo.DemoService"/>
+</beans>
+
+Run service consumer
+
+import com.alibaba.dubbo.demo.DemoService;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class Consumer {
+    public static void main(String[] args) throws Exception {
+        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
+                new String[]{"META-INF/spring/dubbo-demo-consumer.xml"});
+        context.start();
+        // obtain proxy object for remote invocation
+        DemoService demoService = (DemoService) context.getBean("demoService");
+        // execute remote invocation
+        String hello = demoService.sayHello("world");
+        // show the result
+        System.out.println(hello);
+    }
+}
+
+What’s next
+Read this excellent article Introduction to Dubbo to learn more on dubbo’s basic features.
+Dive deep into dubbo user guide (English, Chinese) to find more details.
+Read dubbo admin guide (English, Chinese) for dubbo application administration topics.
+Interested in how dubbo is designed, or want to contribute? Read dubbo developer guide (English, Chinese), and start to hack the code.
+ to discuss with dubbo core team.
+Explore more side projects you may interested from github dubbo group.
+
+下一步是什么
+
+读这篇优秀的文章介绍到Dubbo去学习更多的Dubbo的基本特征。	http://www.baeldung.com/dubbo
+
+深入到Dubbo用户指南（英文，中文）找到更多的细节。 详细说明 	http://dubbo.io/books/dubbo-user-book/
+
+读Dubbo管理员指南（英文，中文）为Dubbo应用管理主题。 安装运维手册	http://dubbo.io/books/dubbo-admin-book/
+
+感兴趣的Dubbo设计，或想做出贡献？读Dubbo开发指南（英文，中文），并开始修改代码。 开发指南	http://dubbo.io/books/dubbo-dev-book/
+
+与Dubbo核心团队讨论。
+
+探索更多的项目你会感兴趣的从GitHubDubbo集团。	https://github.com/dubbo
+	
diff --git "a/04 - Middleware/dubbo/\351\205\215\347\275\256.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/\351\205\215\347\275\256.txt"
similarity index 98%
rename from "04 - Middleware/dubbo/\351\205\215\347\275\256.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/\351\205\215\347\275\256.txt"
index 9ad0bbf3..2691a1b1 100644
--- "a/04 - Middleware/dubbo/\351\205\215\347\275\256.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/dubbo/\351\205\215\347\275\256.txt"	
@@ -1,49 +1,49 @@
-XML配置
-http://dubbo.io/books/dubbo-user-book/configuration/xml.html
-
-provider.xml 示例
-
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
-    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
-	
-	<!-- 应用配置 用于配置当前应用信息，不管该应用是提供者还是消费者 -->
-    <dubbo:application name="hello-world-app"  />  
-	
-	<!-- 注册中心配置 用于配置连接注册中心相关信息 -->
-    <dubbo:registry address="multicast://224.5.6.7:1234" />  
-	
-	<!-- 协议配置 用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受 -->
-    <dubbo:protocol name="dubbo" port="20880" />  
-	
-	<!-- 服务配置 用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心 -->
-    <dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoServiceLocal" />  
-	
-	<!-- 引用配置 用于创建一个远程服务代理，一个引用可以指向多个注册中心 -->
-    <dubbo:reference id="demoServiceRemote" interface="com.alibaba.dubbo.demo.DemoService" />  
-</beans>
-
-consumer.xml
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
-    xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
-
-    <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
-    <dubbo:application name="consumer-of-helloworld-app"  />
-
-    <!-- 使用multicast广播注册中心暴露发现服务地址 -->
-    <dubbo:registry address="multicast://224.5.6.7:1234" />
-
-    <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
-    <dubbo:reference id="demoService" interface="com.alibaba.dubbo.demo.DemoService" />
-</beans>
-
-属性配置
-
-API配置
-
+XML配置
+http://dubbo.io/books/dubbo-user-book/configuration/xml.html
+
+provider.xml 示例
+
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
+	
+	<!-- 应用配置 用于配置当前应用信息，不管该应用是提供者还是消费者 -->
+    <dubbo:application name="hello-world-app"  />  
+	
+	<!-- 注册中心配置 用于配置连接注册中心相关信息 -->
+    <dubbo:registry address="multicast://224.5.6.7:1234" />  
+	
+	<!-- 协议配置 用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受 -->
+    <dubbo:protocol name="dubbo" port="20880" />  
+	
+	<!-- 服务配置 用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心 -->
+    <dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoServiceLocal" />  
+	
+	<!-- 引用配置 用于创建一个远程服务代理，一个引用可以指向多个注册中心 -->
+    <dubbo:reference id="demoServiceRemote" interface="com.alibaba.dubbo.demo.DemoService" />  
+</beans>
+
+consumer.xml
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
+    <dubbo:application name="consumer-of-helloworld-app"  />
+
+    <!-- 使用multicast广播注册中心暴露发现服务地址 -->
+    <dubbo:registry address="multicast://224.5.6.7:1234" />
+
+    <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
+    <dubbo:reference id="demoService" interface="com.alibaba.dubbo.demo.DemoService" />
+</beans>
+
+属性配置
+
+API配置
+
 注释配置
\ No newline at end of file
diff --git "a/04 - Middleware/elasticsearch/5.x windows\346\217\222\344\273\266\345\256\211\350\243\205.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/5.x windows\346\217\222\344\273\266\345\256\211\350\243\205.txt"
similarity index 99%
rename from "04 - Middleware/elasticsearch/5.x windows\346\217\222\344\273\266\345\256\211\350\243\205.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/5.x windows\346\217\222\344\273\266\345\256\211\350\243\205.txt"
index b3d13f67..a60c7b96 100644
--- "a/04 - Middleware/elasticsearch/5.x windows\346\217\222\344\273\266\345\256\211\350\243\205.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/5.x windows\346\217\222\344\273\266\345\256\211\350\243\205.txt"	
@@ -1,2 +1,2 @@
-ElasticSearch5.x踩坑记录(一):windows系统下的ElasticSearch5.6.3及head插件安装 - CSDN博客
+ElasticSearch5.x踩坑记录(一):windows系统下的ElasticSearch5.6.3及head插件安装 - CSDN博客
 http://blog.csdn.net/blq4411568/article/details/78453735
\ No newline at end of file
diff --git "a/04 - Middleware/elasticsearch/ES url\347\273\223\346\236\204.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES url\347\273\223\346\236\204.md"
similarity index 76%
rename from "04 - Middleware/elasticsearch/ES url\347\273\223\346\236\204.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES url\347\273\223\346\236\204.md"
index f6f5e1bc..668b9bdd 100644
--- "a/04 - Middleware/elasticsearch/ES url\347\273\223\346\236\204.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES url\347\273\223\346\236\204.md"	
@@ -1,7 +1,7 @@
-Index 
-
-
-Type 
-
-
+Index 
+
+
+Type 
+
+
 Id
\ No newline at end of file
diff --git "a/04 - Middleware/elasticsearch/ES \345\270\270\347\224\250\346\216\245\345\217\243.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES \345\270\270\347\224\250\346\216\245\345\217\243.md"
similarity index 95%
rename from "04 - Middleware/elasticsearch/ES \345\270\270\347\224\250\346\216\245\345\217\243.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES \345\270\270\347\224\250\346\216\245\345\217\243.md"
index 54ac4a56..29105093 100644
--- "a/04 - Middleware/elasticsearch/ES \345\270\270\347\224\250\346\216\245\345\217\243.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES \345\270\270\347\224\250\346\216\245\345\217\243.md"	
@@ -1,53 +1,53 @@
-[elasticsearch官方Api](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices.html?spm=5176.100239.blogcont46639.5.HE1RSU)
-
-[中文博客整理API](http://www.cnblogs.com/yjf512/p/4862992.html)
-
-PUT 创建Index localhost:9200/indexname
-例子：localhost:9200/data
-
-
-POST 创建Type localhost:9200/indexname/typename
-例子：localhost:9200/data/person
-会自动创建id
-{
-	"name":"loveincode",
-	"age":20
-}
-
-POST 创建type 及ID localhost:9200/indexname/typename
-例子：localhost:9200/data/person/1
-
-{
-	"name":"loveincode",
-	"age":20
-}
-
-PUT 修改 localhost:9200/data/person/1
-{
-	"name":"loveincode_update",
-	"age":20
-}
-POST 更新 localhost:9200/data/person/1/_update?pretty
-{
-	"name": "Jane Doe"
-}
-
-DELETE localhost:9200/data/person/1?pretty
-
-Get localhost:9200/_cat/indices?v
-查询所有index
-
-GET localhost:9200/indexname
-例子：localhost:9200/data
-获得index的属性
-
-GET by ID
-localhost:9200/indexname/typename/{id}
-取到ID=id的信息
-
-GET 搜索Index localhost:9200/indexname/_search
-例子：localhost:9200/data/_search
-
-
-GET 搜索Index localhost:9200/indexname/typename/_search
+[elasticsearch官方Api](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices.html?spm=5176.100239.blogcont46639.5.HE1RSU)
+
+[中文博客整理API](http://www.cnblogs.com/yjf512/p/4862992.html)
+
+PUT 创建Index localhost:9200/indexname
+例子：localhost:9200/data
+
+
+POST 创建Type localhost:9200/indexname/typename
+例子：localhost:9200/data/person
+会自动创建id
+{
+	"name":"loveincode",
+	"age":20
+}
+
+POST 创建type 及ID localhost:9200/indexname/typename
+例子：localhost:9200/data/person/1
+
+{
+	"name":"loveincode",
+	"age":20
+}
+
+PUT 修改 localhost:9200/data/person/1
+{
+	"name":"loveincode_update",
+	"age":20
+}
+POST 更新 localhost:9200/data/person/1/_update?pretty
+{
+	"name": "Jane Doe"
+}
+
+DELETE localhost:9200/data/person/1?pretty
+
+Get localhost:9200/_cat/indices?v
+查询所有index
+
+GET localhost:9200/indexname
+例子：localhost:9200/data
+获得index的属性
+
+GET by ID
+localhost:9200/indexname/typename/{id}
+取到ID=id的信息
+
+GET 搜索Index localhost:9200/indexname/_search
+例子：localhost:9200/data/_search
+
+
+GET 搜索Index localhost:9200/indexname/typename/_search
 例子：localhost:9200/data/person/_search
\ No newline at end of file
diff --git "a/04 - Middleware/elasticsearch/ES\345\272\224\347\224\250\345\234\272\346\231\257.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\345\272\224\347\224\250\345\234\272\346\231\257.md"
similarity index 100%
rename from "04 - Middleware/elasticsearch/ES\345\272\224\347\224\250\345\234\272\346\231\257.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\345\272\224\347\224\250\345\234\272\346\231\257.md"
diff --git "a/04 - Middleware/elasticsearch/ES\346\220\234\347\264\242.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\346\220\234\347\264\242.txt"
similarity index 94%
rename from "04 - Middleware/elasticsearch/ES\346\220\234\347\264\242.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\346\220\234\347\264\242.txt"
index fc36c53f..0181baa4 100644
--- "a/04 - Middleware/elasticsearch/ES\346\220\234\347\264\242.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\346\220\234\347\264\242.txt"	
@@ -1,100 +1,100 @@
-
-url : 
-http://localhost:9200/index/_search			get post  可对index查询			替换为对应的名字 indexname
-http://localhost:9200/index/type/_search	get post  可对index type 查询 							typename
-
-拿total 得到总数 根据总数计算页数 	GridData
-
-json:	
-{
-    "query": {
-        "bool": {
-            "must": [
-                {
-                    "range": {
-                        "age": {
-                            "gt": "10"
-                        }
-                    }
-                },
-                {
-                    "term": {
-                        "age":"20"
-                    }
-                }
-            ],
-            "must_not": [],
-            "should": []
-        }
-    },
-    "from": 0,
-    "size": 1,
-    "sort": {
-        "age": {
-            "order": "desc"
-        }
-    },
-    "aggs": {}
-}
-
-bool查询 
-	bool查询，可以把很多小的查询组成一个更为复杂的查询
-filter查询
-	filter过滤可以嵌套在bool查询内部使用
-
-must：查询结果必须符合该查询条件（列表）。
-should：类似于in的查询条件。如果bool查询中不包含must查询，那么should默认表示必须符合查询列表中的一个或多个查询条件。
-must_not：查询结果必须不符合查询条件（列表）。
-
-from 从第几个开始 index 0
-size 多少个
-
-"sort": { "age": { "order": "asc" }} 根据什么排序？ 正序 反序
-aggs 聚合查询
-
-
-组合查询 and
-or
-
-1 term 精确搜索
-
-"term": {
-	"age": "20"
-}
-
-
-2 range 范围查询
-range
-"range": {
-	"age": {
-		"gt": "10",
-		"lt": "22"
-	}
-}
-gt 大于
-lt 小于 也可只写一个
-
-3 prefix 前缀查询
-"prefix": {
-	"name": "love"
-}
-
-4 Terms 多词语查询
-"terms": {
-	"_id": [
-    "1",
-    "2"
-	]
-}
-
-5 Wildcard  通配符查询
-
-"wildcard": {
-"name": "*"
-}
-
-6 Regexp  正则表达式查询
-
-7 Exists 
-
+
+url : 
+http://localhost:9200/index/_search			get post  可对index查询			替换为对应的名字 indexname
+http://localhost:9200/index/type/_search	get post  可对index type 查询 							typename
+
+拿total 得到总数 根据总数计算页数 	GridData
+
+json:	
+{
+    "query": {
+        "bool": {
+            "must": [
+                {
+                    "range": {
+                        "age": {
+                            "gt": "10"
+                        }
+                    }
+                },
+                {
+                    "term": {
+                        "age":"20"
+                    }
+                }
+            ],
+            "must_not": [],
+            "should": []
+        }
+    },
+    "from": 0,
+    "size": 1,
+    "sort": {
+        "age": {
+            "order": "desc"
+        }
+    },
+    "aggs": {}
+}
+
+bool查询 
+	bool查询，可以把很多小的查询组成一个更为复杂的查询
+filter查询
+	filter过滤可以嵌套在bool查询内部使用
+
+must：查询结果必须符合该查询条件（列表）。
+should：类似于in的查询条件。如果bool查询中不包含must查询，那么should默认表示必须符合查询列表中的一个或多个查询条件。
+must_not：查询结果必须不符合查询条件（列表）。
+
+from 从第几个开始 index 0
+size 多少个
+
+"sort": { "age": { "order": "asc" }} 根据什么排序？ 正序 反序
+aggs 聚合查询
+
+
+组合查询 and
+or
+
+1 term 精确搜索
+
+"term": {
+	"age": "20"
+}
+
+
+2 range 范围查询
+range
+"range": {
+	"age": {
+		"gt": "10",
+		"lt": "22"
+	}
+}
+gt 大于
+lt 小于 也可只写一个
+
+3 prefix 前缀查询
+"prefix": {
+	"name": "love"
+}
+
+4 Terms 多词语查询
+"terms": {
+	"_id": [
+    "1",
+    "2"
+	]
+}
+
+5 Wildcard  通配符查询
+
+"wildcard": {
+"name": "*"
+}
+
+6 Regexp  正则表达式查询
+
+7 Exists 
+
 8 Missing 
\ No newline at end of file
diff --git "a/04 - Middleware/elasticsearch/ES\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
similarity index 99%
rename from "04 - Middleware/elasticsearch/ES\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
index fef6adc5..5cc367a5 100644
--- "a/04 - Middleware/elasticsearch/ES\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/ES\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"	
@@ -1,19 +1,19 @@
-### 索引(Index)
-ES将数据存储于一个或多个索引中，索引是具有类似特性的文档的集合。类比传统的关系型数据库领域来说，索引相当于SQL中的一个数据库，或者一个数据存储方案(schema)。索引由其名称(必须为全小写字符)进行标识，并通过引用此名称完成文档的创建、搜索、更新及删除操作。一个ES集群中可以按需创建任意数目的索引。
-### 类型(Type)
-类型是索引内部的逻辑分区(category/partition)，然而其意义完全取决于用户需求。因此，一个索引内部可定义一个或多个类型(type)。一般来说，类型就是为那些拥有相同的域的文档做的预定义。例如，在索引中，可以定义一个用于存储用户数据的类型，一个存储日志数据的类，以及一个存储评论数据的类型。类比传统的关系型数据库领域来说，类型相当于“表”。
-### 文档(Document)
-文档是Lucene索引和搜索的原子单位，它是包含了一个或多个域的容器，基于JSON格式进行表示。文档由一个或多个域组成，每个域拥有一个名字及一个或多个值，有多个值的域通常称为“多值域”。每个文档可以存储不同的域集，但同一类型下的文档至应该有某种程度上的相似之处。
-### 映射(Mapping)
-ES中，所有的文档在存储之前都要首先进行分析。用户可根据需要定义如何将文本分割成token、哪些token应该被过滤掉，以及哪些文本需要进行额外处理等等。另外，ES还提供了额外功能，例如将域中的内容按需排序。事实上，ES也能自动根据其值确定域的类型。
-### 节点(Node)
-运行了单个实例的ES主机称为节点，它是集群的一个成员，可以存储数据、参与集群索引及搜索操作。类似于集群，节点靠其名称进行标识，默认为启动时自动生成的随机Marvel字符名称。用户可以按需要自定义任何希望使用的名称，但出于管理的目的，此名称应该尽可能有较好的识别性。节点通过为其配置的ES集群名称确定其所要加入的集群。
-### 分片(Shard)和副本(Replica)
-ES的“分片(shard)”机制可将一个索引内部的数据分布地存储于多个节点，它通过将一个索引切分为多个底层物理的Lucene索引完成索引数据的分割存储功能，这每一个物理的Lucene索引称为一个分片(shard)。每个分片其内部都是一个全功能且独立的索引，因此可由集群中的任何主机存储。创建索引时，用户可指定其分片的数量，默认数量为5个。 
-  
-Shard有两种类型：primary和replica，即主shard及副本shard。Primary shard用于文档存储，每个新的索引会自动创建5个Primary shard，当然此数量可在索引创建之前通过配置自行定义，不过，一旦创建完成，其Primary shard的数量将不可更改。Replica shard是Primary Shard的副本，用于冗余数据及提高搜索性能。每个Primary shard默认配置了一个Replica shard，但也可以配置多个，且其数量可动态更改。ES会根据需要自动增加或减少这些Replica shard的数量。
-
-ES集群可由多个节点组成，各Shard分布式地存储于这些节点上。
-ES可自动在节点间按需要移动shard，例如增加节点或节点故障时。简而言之，分片实现了集群的分布式存储，而副本实现了其分布式处理及冗余功能。
-
+### 索引(Index)
+ES将数据存储于一个或多个索引中，索引是具有类似特性的文档的集合。类比传统的关系型数据库领域来说，索引相当于SQL中的一个数据库，或者一个数据存储方案(schema)。索引由其名称(必须为全小写字符)进行标识，并通过引用此名称完成文档的创建、搜索、更新及删除操作。一个ES集群中可以按需创建任意数目的索引。
+### 类型(Type)
+类型是索引内部的逻辑分区(category/partition)，然而其意义完全取决于用户需求。因此，一个索引内部可定义一个或多个类型(type)。一般来说，类型就是为那些拥有相同的域的文档做的预定义。例如，在索引中，可以定义一个用于存储用户数据的类型，一个存储日志数据的类，以及一个存储评论数据的类型。类比传统的关系型数据库领域来说，类型相当于“表”。
+### 文档(Document)
+文档是Lucene索引和搜索的原子单位，它是包含了一个或多个域的容器，基于JSON格式进行表示。文档由一个或多个域组成，每个域拥有一个名字及一个或多个值，有多个值的域通常称为“多值域”。每个文档可以存储不同的域集，但同一类型下的文档至应该有某种程度上的相似之处。
+### 映射(Mapping)
+ES中，所有的文档在存储之前都要首先进行分析。用户可根据需要定义如何将文本分割成token、哪些token应该被过滤掉，以及哪些文本需要进行额外处理等等。另外，ES还提供了额外功能，例如将域中的内容按需排序。事实上，ES也能自动根据其值确定域的类型。
+### 节点(Node)
+运行了单个实例的ES主机称为节点，它是集群的一个成员，可以存储数据、参与集群索引及搜索操作。类似于集群，节点靠其名称进行标识，默认为启动时自动生成的随机Marvel字符名称。用户可以按需要自定义任何希望使用的名称，但出于管理的目的，此名称应该尽可能有较好的识别性。节点通过为其配置的ES集群名称确定其所要加入的集群。
+### 分片(Shard)和副本(Replica)
+ES的“分片(shard)”机制可将一个索引内部的数据分布地存储于多个节点，它通过将一个索引切分为多个底层物理的Lucene索引完成索引数据的分割存储功能，这每一个物理的Lucene索引称为一个分片(shard)。每个分片其内部都是一个全功能且独立的索引，因此可由集群中的任何主机存储。创建索引时，用户可指定其分片的数量，默认数量为5个。 
+  
+Shard有两种类型：primary和replica，即主shard及副本shard。Primary shard用于文档存储，每个新的索引会自动创建5个Primary shard，当然此数量可在索引创建之前通过配置自行定义，不过，一旦创建完成，其Primary shard的数量将不可更改。Replica shard是Primary Shard的副本，用于冗余数据及提高搜索性能。每个Primary shard默认配置了一个Replica shard，但也可以配置多个，且其数量可动态更改。ES会根据需要自动增加或减少这些Replica shard的数量。
+
+ES集群可由多个节点组成，各Shard分布式地存储于这些节点上。
+ES可自动在节点间按需要移动shard，例如增加节点或节点故障时。简而言之，分片实现了集群的分布式存储，而副本实现了其分布式处理及冗余功能。
+
 可视化插件：head插件
\ No newline at end of file
diff --git a/04 - Middleware/elasticsearch/can not run elasticsearch as root.txt "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/can not run elasticsearch as root.txt"
similarity index 100%
rename from 04 - Middleware/elasticsearch/can not run elasticsearch as root.txt
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/can not run elasticsearch as root.txt"
diff --git "a/04 - Middleware/elasticsearch/elasticsearch.yml\345\237\272\346\234\254\351\205\215\347\275\256\350\257\264\346\230\216.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/elasticsearch.yml\345\237\272\346\234\254\351\205\215\347\275\256\350\257\264\346\230\216.txt"
similarity index 100%
rename from "04 - Middleware/elasticsearch/elasticsearch.yml\345\237\272\346\234\254\351\205\215\347\275\256\350\257\264\346\230\216.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/elasticsearch.yml\345\237\272\346\234\254\351\205\215\347\275\256\350\257\264\346\230\216.txt"
diff --git "a/04 - Middleware/elasticsearch/es\350\201\232\345\220\210 java api.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/es\350\201\232\345\220\210 java api.txt"
similarity index 97%
rename from "04 - Middleware/elasticsearch/es\350\201\232\345\220\210 java api.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/es\350\201\232\345\220\210 java api.txt"
index 639679b1..0792449d 100644
--- "a/04 - Middleware/elasticsearch/es\350\201\232\345\220\210 java api.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/es\350\201\232\345\220\210 java api.txt"	
@@ -1,14 +1,14 @@
-https://elasticsearch.cn/article/102
-
-
-
-max/min/sum/avg
-例如要计算每个球队年龄最大/最小/总/平均的球员年龄，如果使用SQL语句，应表达如下：
-select team, max(age) as max_age from player group by team;
-
-ES的java api：
-
-TermsBuilder teamAgg= AggregationBuilders.terms("player_count ").field("team");
-MaxBuilder ageAgg= AggregationBuilders.max("max_age").field("age");
-sbuilder.addAggregation(teamAgg.subAggregation(ageAgg));
+https://elasticsearch.cn/article/102
+
+
+
+max/min/sum/avg
+例如要计算每个球队年龄最大/最小/总/平均的球员年龄，如果使用SQL语句，应表达如下：
+select team, max(age) as max_age from player group by team;
+
+ES的java api：
+
+TermsBuilder teamAgg= AggregationBuilders.terms("player_count ").field("team");
+MaxBuilder ageAgg= AggregationBuilders.max("max_age").field("age");
+sbuilder.addAggregation(teamAgg.subAggregation(ageAgg));
 SearchResponse response = sbuilder.execute().actionGet();
\ No newline at end of file
diff --git a/04 - Middleware/elasticsearch/img/1.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/1.png"
similarity index 100%
rename from 04 - Middleware/elasticsearch/img/1.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/1.png"
diff --git a/04 - Middleware/elasticsearch/img/2.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/2.png"
similarity index 100%
rename from 04 - Middleware/elasticsearch/img/2.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/2.png"
diff --git a/04 - Middleware/elasticsearch/img/3.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/3.png"
similarity index 100%
rename from 04 - Middleware/elasticsearch/img/3.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/3.png"
diff --git a/04 - Middleware/elasticsearch/img/4.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/4.png"
similarity index 100%
rename from 04 - Middleware/elasticsearch/img/4.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/4.png"
diff --git a/04 - Middleware/elasticsearch/img/5.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/5.png"
similarity index 100%
rename from 04 - Middleware/elasticsearch/img/5.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/5.png"
diff --git a/04 - Middleware/elasticsearch/img/6.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/6.png"
similarity index 100%
rename from 04 - Middleware/elasticsearch/img/6.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/img/6.png"
diff --git a/04 - Middleware/elasticsearch/logstash/elk.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/logstash/elk.md"
similarity index 100%
rename from 04 - Middleware/elasticsearch/logstash/elk.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/logstash/elk.md"
diff --git a/04 - Middleware/elasticsearch/problem.txt "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/problem.txt"
similarity index 100%
rename from 04 - Middleware/elasticsearch/problem.txt
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/problem.txt"
diff --git "a/04 - Middleware/elasticsearch/python\346\224\257\346\214\201.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/python\346\224\257\346\214\201.txt"
similarity index 100%
rename from "04 - Middleware/elasticsearch/python\346\224\257\346\214\201.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/elasticsearch/python\346\224\257\346\214\201.txt"
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/img/10115652-d1465ce8ff6e0218.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/img/10115652-d1465ce8ff6e0218.png"
new file mode 100644
index 00000000..615e67f7
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/img/10115652-d1465ce8ff6e0218.png" differ
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/img/seata(fescar)\345\210\206\345\270\203\345\274\217\344\272\213\345\212\2411.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/img/seata(fescar)\345\210\206\345\270\203\345\274\217\344\272\213\345\212\2411.png"
new file mode 100644
index 00000000..2c239444
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/img/seata(fescar)\345\210\206\345\270\203\345\274\217\344\272\213\345\212\2411.png" differ
diff --git "a/04 - Middleware/lucene/lucence\347\256\200\344\273\213.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/lucene/lucence\347\256\200\344\273\213.txt"
similarity index 98%
rename from "04 - Middleware/lucene/lucence\347\256\200\344\273\213.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/lucene/lucence\347\256\200\344\273\213.txt"
index 1672c31c..48f03003 100644
--- "a/04 - Middleware/lucene/lucence\347\256\200\344\273\213.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/lucene/lucence\347\256\200\344\273\213.txt"	
@@ -1,57 +1,57 @@
-
-什么是Lucene
-
-Lucene是apache软件基金会发布的一个开放源代码的全文检索引擎工具包，由资深全文检索专家Doug Cutting所撰写,它是一个全文检索引擎的架构，
-提供了完整的创建索引和查询索引，以及部分文本分析的引擎，Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便在目标系统中实
-现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎，Lucene在全文检索领域是一个经典的祖先，现在很多检索引擎都是在其基础上创
-建的，思想是相通的。
-
-即：Lucene是根据关健字来搜索的文本搜索工具，只能在某个网站内部搜索文本内容，不能跨网站搜索
-
-
-Lucene通常用在什么地方
-Lucece不能用在互联网搜索（即像百度那样），只能用在网站内部的文本搜索（即只能在CRM，RAX，ERP内部使用），但思想是相通的。
-
-
-Lucene中存的什么内容
-Lucene中存的就是一系列的二进制压缩文件和一些控制文件，它们位于计算机的硬盘上，
-这些内容统称为索引库，索引库有二部份组成：
-（1）原始记录 
-     存入到索引库中的原始文本，
-（2）词汇表
-     按照一定的拆分策略（即分词器）将原始记录中的每个字符拆开后，存入一个供将来搜索的表
-
-为什么网站内部有些地方要用Lucene来索搜，而不全用SQL来搜索
-（1）SQL只能针对数据库表搜索，不能直接针对硬盘上的文本搜索
-（2）SQL没有相关度排名
-（3）SQL搜索结果没有关健字高亮显示
-（4）SQL需要数据库的支持，数据库本身需要内存开销较大，例如：Oracle
-（5）SQL搜索有时较慢，尤其是数据库不在本地时，超慢，例如：Oracle
-
-书写代码使用Lucene的流程图
-创建索引库：
-1）	创建JavaBean对象
-2）	创建Docment对象
-3）	将JavaBean对象所有的属性值，均放到Document对象中去，属性名可以和JavaBean相同或不同
-4）	创建IndexWriter对象
-5）	将Document对象通过IndexWriter对象写入索引库中
-6）	关闭IndexWriter对象
-根据关键字查询索引库中的内容：
-1）	创建IndexSearcher对象
-2）	创建QueryParser对象
-3）	创建Query对象来封装关键字
-4）	用IndexSearcher对象去索引库中查询符合条件的前100条记录，不足100条记录的以实际为准
-5）	获取符合条件的编号
-6）	用indexSearcher对象去索引库中查询编号对应的Document对象
-7）	将Document对象中的所有属性取出，再封装回JavaBean对象中去，并加入到集合中保存，以备将之用
-
-
-Lucene快速入门
-
-Lucene相关的jar包
-  lucene-core-3.0.2.jar【Lucene核心】
-  lucene-analyzers-3.0.2.jar【分词器】
-  lucene-highlighter-3.0.2.jar【Lucene会将搜索出来的字，高亮显示，提示用户】
-  lucene-memory-3.0.2.jar【索引库优化策略】
-
-  
+
+什么是Lucene
+
+Lucene是apache软件基金会发布的一个开放源代码的全文检索引擎工具包，由资深全文检索专家Doug Cutting所撰写,它是一个全文检索引擎的架构，
+提供了完整的创建索引和查询索引，以及部分文本分析的引擎，Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便在目标系统中实
+现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎，Lucene在全文检索领域是一个经典的祖先，现在很多检索引擎都是在其基础上创
+建的，思想是相通的。
+
+即：Lucene是根据关健字来搜索的文本搜索工具，只能在某个网站内部搜索文本内容，不能跨网站搜索
+
+
+Lucene通常用在什么地方
+Lucece不能用在互联网搜索（即像百度那样），只能用在网站内部的文本搜索（即只能在CRM，RAX，ERP内部使用），但思想是相通的。
+
+
+Lucene中存的什么内容
+Lucene中存的就是一系列的二进制压缩文件和一些控制文件，它们位于计算机的硬盘上，
+这些内容统称为索引库，索引库有二部份组成：
+（1）原始记录 
+     存入到索引库中的原始文本，
+（2）词汇表
+     按照一定的拆分策略（即分词器）将原始记录中的每个字符拆开后，存入一个供将来搜索的表
+
+为什么网站内部有些地方要用Lucene来索搜，而不全用SQL来搜索
+（1）SQL只能针对数据库表搜索，不能直接针对硬盘上的文本搜索
+（2）SQL没有相关度排名
+（3）SQL搜索结果没有关健字高亮显示
+（4）SQL需要数据库的支持，数据库本身需要内存开销较大，例如：Oracle
+（5）SQL搜索有时较慢，尤其是数据库不在本地时，超慢，例如：Oracle
+
+书写代码使用Lucene的流程图
+创建索引库：
+1）	创建JavaBean对象
+2）	创建Docment对象
+3）	将JavaBean对象所有的属性值，均放到Document对象中去，属性名可以和JavaBean相同或不同
+4）	创建IndexWriter对象
+5）	将Document对象通过IndexWriter对象写入索引库中
+6）	关闭IndexWriter对象
+根据关键字查询索引库中的内容：
+1）	创建IndexSearcher对象
+2）	创建QueryParser对象
+3）	创建Query对象来封装关键字
+4）	用IndexSearcher对象去索引库中查询符合条件的前100条记录，不足100条记录的以实际为准
+5）	获取符合条件的编号
+6）	用indexSearcher对象去索引库中查询编号对应的Document对象
+7）	将Document对象中的所有属性取出，再封装回JavaBean对象中去，并加入到集合中保存，以备将之用
+
+
+Lucene快速入门
+
+Lucene相关的jar包
+  lucene-core-3.0.2.jar【Lucene核心】
+  lucene-analyzers-3.0.2.jar【分词器】
+  lucene-highlighter-3.0.2.jar【Lucene会将搜索出来的字，高亮显示，提示用户】
+  lucene-memory-3.0.2.jar【索引库优化策略】
+
+  
diff --git "a/04 - Middleware/lucene/\345\205\263\351\224\256\347\202\271.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/lucene/\345\205\263\351\224\256\347\202\271.txt"
similarity index 98%
rename from "04 - Middleware/lucene/\345\205\263\351\224\256\347\202\271.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/lucene/\345\205\263\351\224\256\347\202\271.txt"
index 7820dd49..324ce119 100644
--- "a/04 - Middleware/lucene/\345\205\263\351\224\256\347\202\271.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/lucene/\345\205\263\351\224\256\347\202\271.txt"	
@@ -1,86 +1,86 @@
-索引库
-1．1什么是索引库
-     索引库是Lucene的重要的存储结构，它包括二部份：原始记录表，词汇表
-     原始记录表：存放的是原始记录信息，Lucene为存入的内容分配一个唯一的编号
-     词汇表：存放的是经过分词器拆分出来的词汇和该词汇在原始记录表中的编号
-1．2为什么要将索引库进行优化
-     在默认情况下，向索引库中增加一个Document对象时，索引库自动会添加一个扩展名叫*.cfs的二进制压缩文件，如果向索引库中存Document对象过多，那么*.cfs也会不断增加，同时索引库的容量也会不断增加，影响索引库的大小。
-1．3索引库优化方案
-     1．3．1合并cfs文件，合并后的cfs文件是二进制压缩字符，能解决是的文件大小和数量的问题 
-		indexWriter.addDocument(document);
-		indexWriter.optimize();
-		indexWriter.close();
-
-     1．3．2设定合并因子，自动合并cfs文件，默认10个cfs文件合并成一个cfs文件
-		indexWriter.addDocument(document);
-		indexWriter.setMergeFactor(3);
-		indexWriter.close();
-
-     1．3．3使用RAMDirectory，类似于内存索引库，能解决是的读取索引库文件的速度问题，
-             它能以空换时，提高速度快，但不能持久保存，因此启动时加载硬盘中的索引库到内存中的索引库，退出时将内存中的索引库保存到硬盘中的索引库，且内容不能重复。
-	思考：项目中，什么地方能运用这个内存索引库解决速度的思想
-
-	
-分词器
-2．1什么是分词器
-    采用一种算法，将中英文本中的字符拆分开来，形成词汇，以待用户输入关健字后搜索
-2．2为什么要分词器
-     因为用户输入的搜索的内容是一段文本中的一个关健字，和原始表中的内容有差别，
-     但作为搜索引擎来讲，又得将相关的内容搜索出来，此时就得采用分词器来最大限度
-     匹配原始表中的内容
-2．3分词器工作流程
-     步一：按分词器拆分出词汇
-     步二：去除停用词和禁用词
-     步三：如果有英文，把英文字母转为小写，即搜索不分大小写
-2．4分词器例子图解：“我们的首都是北京呀”
-2．5演示常用分词器测试，只观查结果
-2．6使用第三方IKAnalyzer分词器--------中文首选
-     步一：导入IKAnalyzer分词器核心jar包，IKAnalyzer3.2.0Stable.jar
-     步二：将IKAnalyzer.cfg.xml和stopword.dic和xxx.dic文件复制到MyEclipse的src目录下，
-			再进行配置，在配置时，首行需要一个空行
-			
-
-搜索结果高亮
-3．1什么是搜索结果高亮
-    在搜索结果中，将与关健字相同的字符用红色显示
-	
-搜索结果摘要
-4．1什么是搜索结果搞要
-    如果搜索结果内容太多，我们只想显示前几个字符， 必须与高亮一起使用
-
-	搜索结果排序
-5．1什么是搜索结果排序
-    搜索结果是按某个或某些字段高低排序来显示的结果
-5．2影响网站排名的先后的有多种
-     head/meta/
-     网页的标签整洁
-     网页执行速度
-     采用div+css
-     。。。。。。
-5．3Lucene中的显示结果次序与相关度得分有关
-    ScoreDoc.score;
-    默认情况下，Lucene是按相关度得分排序的，得分高排在前，得分低排在后
-    如果相关度得分相同，按插入索引库的先后次序排序
-5．4Lucene中的设置相关度得分
-IndexWriter indexWriter = new IndexWriter(LuceneUtil.getDirectory(),LuceneUtil.getAnalyzer(),LuceneUtil.getMaxFieldLength());
-		document.setBoost(20F);
-		indexWriter.addDocument(document);
-		indexWriter.close();
- 5．5Lucene中按单个字段排序
-	Sort sort = new Sort(new SortField("id",SortField.INT,true));
-	TopDocs topDocs = indexSearcher.search(query,null,1000000,sort);
- 5．6Lucene中按多个字段排序
-		Sort sort = new Sort(new SortField("count",SortField.INT,true),new SortField("id",SortField.INT,true));
-		TopDocs topDocs = indexSearcher.search(query,null,1000000,sort);
-
-     在多字段排序中，只有第一个字段排序结果相同时，第二个字段排序才有作用
-    提倡用数值型排序
-
-
-条件搜索
-6．1什么是条件搜索
-    用关健字与指定的单列或多例进行匹配的搜索
-6．2单字段条件搜索
-QueryParser queryParser = new QueryParser(LuceneUtil.getVersion(),"content",LuceneUtil.getAnalyzer());
-6．3多字段条件搜索，项目中提倡多字段搜索
-QueryParser queryParser = new MultiFieldQueryParser(LuceneUtil.getVersion(),new String[]{"content","title"},LuceneUtil.getAnalyzer());
+索引库
+1．1什么是索引库
+     索引库是Lucene的重要的存储结构，它包括二部份：原始记录表，词汇表
+     原始记录表：存放的是原始记录信息，Lucene为存入的内容分配一个唯一的编号
+     词汇表：存放的是经过分词器拆分出来的词汇和该词汇在原始记录表中的编号
+1．2为什么要将索引库进行优化
+     在默认情况下，向索引库中增加一个Document对象时，索引库自动会添加一个扩展名叫*.cfs的二进制压缩文件，如果向索引库中存Document对象过多，那么*.cfs也会不断增加，同时索引库的容量也会不断增加，影响索引库的大小。
+1．3索引库优化方案
+     1．3．1合并cfs文件，合并后的cfs文件是二进制压缩字符，能解决是的文件大小和数量的问题 
+		indexWriter.addDocument(document);
+		indexWriter.optimize();
+		indexWriter.close();
+
+     1．3．2设定合并因子，自动合并cfs文件，默认10个cfs文件合并成一个cfs文件
+		indexWriter.addDocument(document);
+		indexWriter.setMergeFactor(3);
+		indexWriter.close();
+
+     1．3．3使用RAMDirectory，类似于内存索引库，能解决是的读取索引库文件的速度问题，
+             它能以空换时，提高速度快，但不能持久保存，因此启动时加载硬盘中的索引库到内存中的索引库，退出时将内存中的索引库保存到硬盘中的索引库，且内容不能重复。
+	思考：项目中，什么地方能运用这个内存索引库解决速度的思想
+
+	
+分词器
+2．1什么是分词器
+    采用一种算法，将中英文本中的字符拆分开来，形成词汇，以待用户输入关健字后搜索
+2．2为什么要分词器
+     因为用户输入的搜索的内容是一段文本中的一个关健字，和原始表中的内容有差别，
+     但作为搜索引擎来讲，又得将相关的内容搜索出来，此时就得采用分词器来最大限度
+     匹配原始表中的内容
+2．3分词器工作流程
+     步一：按分词器拆分出词汇
+     步二：去除停用词和禁用词
+     步三：如果有英文，把英文字母转为小写，即搜索不分大小写
+2．4分词器例子图解：“我们的首都是北京呀”
+2．5演示常用分词器测试，只观查结果
+2．6使用第三方IKAnalyzer分词器--------中文首选
+     步一：导入IKAnalyzer分词器核心jar包，IKAnalyzer3.2.0Stable.jar
+     步二：将IKAnalyzer.cfg.xml和stopword.dic和xxx.dic文件复制到MyEclipse的src目录下，
+			再进行配置，在配置时，首行需要一个空行
+			
+
+搜索结果高亮
+3．1什么是搜索结果高亮
+    在搜索结果中，将与关健字相同的字符用红色显示
+	
+搜索结果摘要
+4．1什么是搜索结果搞要
+    如果搜索结果内容太多，我们只想显示前几个字符， 必须与高亮一起使用
+
+	搜索结果排序
+5．1什么是搜索结果排序
+    搜索结果是按某个或某些字段高低排序来显示的结果
+5．2影响网站排名的先后的有多种
+     head/meta/
+     网页的标签整洁
+     网页执行速度
+     采用div+css
+     。。。。。。
+5．3Lucene中的显示结果次序与相关度得分有关
+    ScoreDoc.score;
+    默认情况下，Lucene是按相关度得分排序的，得分高排在前，得分低排在后
+    如果相关度得分相同，按插入索引库的先后次序排序
+5．4Lucene中的设置相关度得分
+IndexWriter indexWriter = new IndexWriter(LuceneUtil.getDirectory(),LuceneUtil.getAnalyzer(),LuceneUtil.getMaxFieldLength());
+		document.setBoost(20F);
+		indexWriter.addDocument(document);
+		indexWriter.close();
+ 5．5Lucene中按单个字段排序
+	Sort sort = new Sort(new SortField("id",SortField.INT,true));
+	TopDocs topDocs = indexSearcher.search(query,null,1000000,sort);
+ 5．6Lucene中按多个字段排序
+		Sort sort = new Sort(new SortField("count",SortField.INT,true),new SortField("id",SortField.INT,true));
+		TopDocs topDocs = indexSearcher.search(query,null,1000000,sort);
+
+     在多字段排序中，只有第一个字段排序结果相同时，第二个字段排序才有作用
+    提倡用数值型排序
+
+
+条件搜索
+6．1什么是条件搜索
+    用关健字与指定的单列或多例进行匹配的搜索
+6．2单字段条件搜索
+QueryParser queryParser = new QueryParser(LuceneUtil.getVersion(),"content",LuceneUtil.getAnalyzer());
+6．3多字段条件搜索，项目中提倡多字段搜索
+QueryParser queryParser = new MultiFieldQueryParser(LuceneUtil.getVersion(),new String[]{"content","title"},LuceneUtil.getAnalyzer());
diff --git "a/04 - Middleware/netty/Netty\346\230\257\344\273\200\344\271\210\357\274\237.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/Netty\346\230\257\344\273\200\344\271\210\357\274\237.txt"
similarity index 98%
rename from "04 - Middleware/netty/Netty\346\230\257\344\273\200\344\271\210\357\274\237.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/Netty\346\230\257\344\273\200\344\271\210\357\274\237.txt"
index 6cbc614f..56494437 100644
--- "a/04 - Middleware/netty/Netty\346\230\257\344\273\200\344\271\210\357\274\237.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/Netty\346\230\257\344\273\200\344\271\210\357\274\237.txt"	
@@ -1,42 +1,42 @@
-
-1）本质：JBoss做的一个Jar包
-2）目的：快速开发高性能、高可靠性的网络服务器和客户端程序
-3）优点：提供异步的、事件驱动的网络应用程序框架和工具
-
-
-Netty的特性
-1）设计
-统一的API，适用于不同的协议（阻塞和非阻塞）基于灵活、可扩展的事件驱动模型高度可定制的线程模型可靠的无连接数据Socket支持（UDP）
-2）性能
-更好的吞吐量，低延迟更省资源尽量减少不必要的内存拷贝
-3）安全
-完整的SSL/TLS和STARTTLS的支持能在Applet与Android的限制环境运行良好
-4）健壮性
-不再因过快、过慢或超负载连接导致OutOfMemoryError不再有在高速网络环境下NIO读写频率不一致的问题
-5）易用
-完善的JavaDoc，用户指南和样例简洁简单仅信赖于JDK1.5
-
-Netty 在哪些行业得到了应用？
-
-互联网行业：
-	随着网站规模的不断扩大，系统并发访问量也越来越高，传统基于 Tomcat 等 Web 容器的垂直架构已经无法满足需求，需要拆分应用进行服务化，以提高开发和维护效率。
-	从组网情况看，垂直的架构拆分之后，系统采用分布式部署，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。
-
-	典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信。
-	除了 Dubbo 之外，淘宝的消息中间件 RocketMQ 的消息生产者和消息消费者之间，也采用 Netty 进行高性能、异步通信。　　除了阿里系和淘宝系之外，很多其它的大型互联网公司或者电商内部也已经大量使用 Netty 构建高性能、分布式的网络服务器。
-
-游戏行业：
-	无论是手游服务端、还是大型的网络游戏，Java 语言得到了越来越广泛的应用。Netty 作为高性能的基础通信组件，它本身提供了 TCP/UDP 和 HTTP 协议栈，非常方便定制和开发私有协议栈。
-	账号登陆服务器、地图服务器之间可以方便的通过 Netty 进行高性能的通信
-
-大数据领域：
-	经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨节点通信，它的 Netty Service 基于 Netty 框架二次封装实现。　　
-	大数据计算往往采用多个计算节点和一个/N个汇总节点进行分布式部署，各节点之间存在海量的数据交换。由于 Netty 的综合性能是目前各个成熟 NIO 框架中最高的，
-	因此，往往会被选中用作大数据各节点间的通信。
-
-企业软件：
-	企业和 IT 集成需要 ESB，Netty 对多协议支持、私有协议定制的简洁性和高性能是 ESB RPC 框架的首选通信组件。
-	事实上，很多企业总线厂商会选择 Netty 作为基础通信组件，于企业的 IT 集成。
-
-通信行业：
-	Netty 的异步高性能、高可靠性和高成熟度的优点，使它在通信行业得到了大量的应用。
+
+1）本质：JBoss做的一个Jar包
+2）目的：快速开发高性能、高可靠性的网络服务器和客户端程序
+3）优点：提供异步的、事件驱动的网络应用程序框架和工具
+
+
+Netty的特性
+1）设计
+统一的API，适用于不同的协议（阻塞和非阻塞）基于灵活、可扩展的事件驱动模型高度可定制的线程模型可靠的无连接数据Socket支持（UDP）
+2）性能
+更好的吞吐量，低延迟更省资源尽量减少不必要的内存拷贝
+3）安全
+完整的SSL/TLS和STARTTLS的支持能在Applet与Android的限制环境运行良好
+4）健壮性
+不再因过快、过慢或超负载连接导致OutOfMemoryError不再有在高速网络环境下NIO读写频率不一致的问题
+5）易用
+完善的JavaDoc，用户指南和样例简洁简单仅信赖于JDK1.5
+
+Netty 在哪些行业得到了应用？
+
+互联网行业：
+	随着网站规模的不断扩大，系统并发访问量也越来越高，传统基于 Tomcat 等 Web 容器的垂直架构已经无法满足需求，需要拆分应用进行服务化，以提高开发和维护效率。
+	从组网情况看，垂直的架构拆分之后，系统采用分布式部署，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。
+
+	典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信。
+	除了 Dubbo 之外，淘宝的消息中间件 RocketMQ 的消息生产者和消息消费者之间，也采用 Netty 进行高性能、异步通信。　　除了阿里系和淘宝系之外，很多其它的大型互联网公司或者电商内部也已经大量使用 Netty 构建高性能、分布式的网络服务器。
+
+游戏行业：
+	无论是手游服务端、还是大型的网络游戏，Java 语言得到了越来越广泛的应用。Netty 作为高性能的基础通信组件，它本身提供了 TCP/UDP 和 HTTP 协议栈，非常方便定制和开发私有协议栈。
+	账号登陆服务器、地图服务器之间可以方便的通过 Netty 进行高性能的通信
+
+大数据领域：
+	经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨节点通信，它的 Netty Service 基于 Netty 框架二次封装实现。　　
+	大数据计算往往采用多个计算节点和一个/N个汇总节点进行分布式部署，各节点之间存在海量的数据交换。由于 Netty 的综合性能是目前各个成熟 NIO 框架中最高的，
+	因此，往往会被选中用作大数据各节点间的通信。
+
+企业软件：
+	企业和 IT 集成需要 ESB，Netty 对多协议支持、私有协议定制的简洁性和高性能是 ESB RPC 框架的首选通信组件。
+	事实上，很多企业总线厂商会选择 Netty 作为基础通信组件，于企业的 IT 集成。
+
+通信行业：
+	Netty 的异步高性能、高可靠性和高成熟度的优点，使它在通信行业得到了大量的应用。
diff --git "a/04 - Middleware/netty/Netty\347\232\204\346\240\270\345\277\203\347\273\204\344\273\266.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/Netty\347\232\204\346\240\270\345\277\203\347\273\204\344\273\266.md"
similarity index 98%
rename from "04 - Middleware/netty/Netty\347\232\204\346\240\270\345\277\203\347\273\204\344\273\266.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/Netty\347\232\204\346\240\270\345\277\203\347\273\204\344\273\266.md"
index d0bb41f1..a9415866 100644
--- "a/04 - Middleware/netty/Netty\347\232\204\346\240\270\345\277\203\347\273\204\344\273\266.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/Netty\347\232\204\346\240\270\345\277\203\347\273\204\344\273\266.md"	
@@ -1,100 +1,100 @@
-原文出处http://cmsblogs.com/ 『chenssy』
-
-什么是 Netty？
-
-    Netty 是一款提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序
-
-    也就是说，Netty 是一个基于 NIO 的客户、服务器端编程框架，使用 Netty 可以确保你快速和简单地开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty 相当简化和流线化了网络应用的编程开发过程，例如，TCP 和 UDP 的 socket 服务开发。（以上摘自百度百科）。
-
-Netty具有如下特性（摘自《Netty in Action》）
-
-`设计`
-  * 统一的API，支持多种传输类型，阻塞和非阻塞的
-  * 简单而强大的线程模型
-  * 真正的无连接数据报套接字支持
-  * 链接逻辑组件以支持复用
-
-`易于使用`
-  * 详实的 Javadoc 和大量的示例集
-  * 不需要超过JdK 1.6+的依赖
-
-`性能`
-  * 拥有比 Java 的核心 API 更高的吞吐量以及更低的延迟
-  * 得益于池化和复用，拥有更低的资源消耗
-  * 最少的内存复制
-
-`健壮性`
-  * 不会因为慢速、快速或者超载的连接而导致 OutOfMemoryError
-  * 消除在高速网络中 NIO 应用程序常见的不公平读/写比率
-
-`安全性`
-  * 完整的 SSL/TLS 以及 StartTLs 支持
-  * 可用于受限环境下，如 Applet 和 OSGI
-
-`社区驱动`
-  * 发布快速而且频繁
-
-### Netty核心组件
-
-  为了后期更好地理解和进一步深入 Netty，有必要总体认识一下 Netty 所用到的核心组件以及他们在整个 Netty 架构中是如何协调工作的。Nettty 有如下几个核心组件：
-
-  * Channel
-  * ChannelFuture
-  * EventLoop
-  * ChannelHandler
-  * ChannelPipeline
-
-### Channel
-  Channel 是 Netty 网络操作抽象类，它除了包括基本的 I/O 操作，如 `bind`、`connect`、`read`、`write` 之外，还包括了 Netty 框架相关的一些功能，如获取该 Channel 的 `EventLoop`。
-
-  在传统的网络编程中，作为核心类的 Socket ，它对程序员来说并不是那么友好，直接使用其成本还是稍微高了点。而Netty 的 Channel 则提供的一系列的 API ，它大大降低了直接与 Socket 进行操作的复杂性。而相对于原生 NIO 的 Channel，Netty 的 Channel 具有如下优势（摘自《Netty权威指南（第二版）》）：
-
-  * 在 Channel 接口层，采用 `Facade` 模式进行统一封装，将网络 I/O 操作、网络 I/O 相关联的其他操作封装起来，统一对外提供。
-  * Channel 接口的定义尽量大而全，为 `SocketChannel` 和 `ServerSocketChannel` 提供统一的视图，由不同子类实现不同的功能，公共功能在抽象父类中实现，最大程度地实现功能和接口的重用。
-  * 具体实现采用聚合而非包含的方式，将相关的功能类聚合在 Channel 中，有 Channel 统一负责和调度，功能实现更加灵活。
-
-### EventLoop
-  Netty 基于事件驱动模型，使用不同的事件来通知我们状态的改变或者操作状态的改变。它定义了在整个连接的生命周期里当有事件发生的时候处理的核心抽象。
-
-  `Channel` 为Netty `网络操作抽象类`，`EventLoop` 主要是`为Channel 处理 I/O 操作`，两者配合参与 I/O 操作。
-
-  下图是Channel、EventLoop、Thread、EventLoopGroup之间的关系（摘自《Netty In Action》）：
-
-  <div align="center"><img src="img/2251324-eb649f88013c075d.png"></div>
-
-  * 一个 EventLoopGroup 包含一个或多个 EventLoop。
-  * 一个 EventLoop 在它的生命周期内只能与一个Thread绑定。
-  * 所有有 EnventLoop 处理的 I/O 事件都将在它专有的 Thread 上被处理。
-  * 一个 Channel 在它的生命周期内只能注册与一个 EventLoop。
-  * 一个 EventLoop 可被分配至一个或多个 Channel 。
-
-  当一个连接到达时，Netty 就会注册一个 Channel，然后从 EventLoopGroup 中分配一个 EventLoop 绑定到这个Channel上，在该Channel的整个生命周期中都是有这个绑定的 EventLoop 来服务的。
-
-### ChannelFuture
-
-  Netty 为异步非阻塞，即所有的 I/O 操作都为异步的，因此，我们不能立刻得知消息是否已经被处理了。
-  Netty 提供了 ChannelFuture 接口，通过该接口的 `addListener()` 方法注册一个 `ChannelFutureListener`，当操作执行成功或者失败时，监听就会自动触发返回结果。
-
-### ChannelHandler
-  `ChannelHandler` 为 Netty 中最核心的组件，它 **充当了所有处理入站和出站数据的应用程序逻辑的容器**。
-
-  ChannelHandler 主要用来处理各种事件，这里的事件很广泛，比如可以是连接、数据接收、异常、数据转换等。
-
-  ChannelHandler 有两个核心子类 ChannelInboundHandler 和 ChannelOutboundHandler，其中 ChannelInboundHandler 用于接收、处理入站数据和事件，而 ChannelOutboundHandler 则相反。
-
-### ChannelPipeline
-  `ChannelPipeline` **为 ChannelHandler 链提供了一个容器并定义了用于沿着链传播入站和出站事件流的 API**。一个数据或者事件可能会被多个 Handler 处理，在这个过程中，数据或者事件经流 ChannelPipeline，由 ChannelHandler 处理。
-
-  在这个处理过程中，一个 ChannelHandler 接收数据后处理完成后交给下一个 ChannelHandler，或者什么都不做直接交给下一个 ChannelHandler。
-
-  <div align="center"><img src="img/2251324-0b57c10e60471725.png"></div>
-
-  当一个数据流进入 ChannlePipeline 时，它会从 ChannelPipeline 头部开始传给第一个 ChannelInboundHandler ，当第一个处理完后再传给下一个，一直传递到管道的尾部。与之相对应的是，当数据被写出时，它会从管道的尾部开始，先经过管道尾部的 “最后” 一个ChannelOutboundHandler，当它处理完成后会传递给前一个 ChannelOutboundHandler 。
-
-  当 ChannelHandler 被添加到 ChannelPipeline 时，它将会被分配一个 `ChannelHandlerContext`，它代表了 ChannelHandler 和 ChannelPipeline 之间的绑定。
-
-  其中 ChannelHandler 添加到 ChannelPipeline 过程如下：
-
-  1. 一个 ChannelInitializer 的实现被注册到了 ServerBootStrap中
-  2. 当 ChannelInitializer.initChannel() 方法被调用时，ChannelInitializer 将在 ChannelPipeline 中安装一组自定义的 ChannelHandler
-  3. ChannelInitializer 将它自己从 ChannelPipeline 中移除
+原文出处http://cmsblogs.com/ 『chenssy』
+
+什么是 Netty？
+
+    Netty 是一款提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序
+
+    也就是说，Netty 是一个基于 NIO 的客户、服务器端编程框架，使用 Netty 可以确保你快速和简单地开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty 相当简化和流线化了网络应用的编程开发过程，例如，TCP 和 UDP 的 socket 服务开发。（以上摘自百度百科）。
+
+Netty具有如下特性（摘自《Netty in Action》）
+
+`设计`
+  * 统一的API，支持多种传输类型，阻塞和非阻塞的
+  * 简单而强大的线程模型
+  * 真正的无连接数据报套接字支持
+  * 链接逻辑组件以支持复用
+
+`易于使用`
+  * 详实的 Javadoc 和大量的示例集
+  * 不需要超过JdK 1.6+的依赖
+
+`性能`
+  * 拥有比 Java 的核心 API 更高的吞吐量以及更低的延迟
+  * 得益于池化和复用，拥有更低的资源消耗
+  * 最少的内存复制
+
+`健壮性`
+  * 不会因为慢速、快速或者超载的连接而导致 OutOfMemoryError
+  * 消除在高速网络中 NIO 应用程序常见的不公平读/写比率
+
+`安全性`
+  * 完整的 SSL/TLS 以及 StartTLs 支持
+  * 可用于受限环境下，如 Applet 和 OSGI
+
+`社区驱动`
+  * 发布快速而且频繁
+
+### Netty核心组件
+
+  为了后期更好地理解和进一步深入 Netty，有必要总体认识一下 Netty 所用到的核心组件以及他们在整个 Netty 架构中是如何协调工作的。Nettty 有如下几个核心组件：
+
+  * Channel
+  * ChannelFuture
+  * EventLoop
+  * ChannelHandler
+  * ChannelPipeline
+
+### Channel
+  Channel 是 Netty 网络操作抽象类，它除了包括基本的 I/O 操作，如 `bind`、`connect`、`read`、`write` 之外，还包括了 Netty 框架相关的一些功能，如获取该 Channel 的 `EventLoop`。
+
+  在传统的网络编程中，作为核心类的 Socket ，它对程序员来说并不是那么友好，直接使用其成本还是稍微高了点。而Netty 的 Channel 则提供的一系列的 API ，它大大降低了直接与 Socket 进行操作的复杂性。而相对于原生 NIO 的 Channel，Netty 的 Channel 具有如下优势（摘自《Netty权威指南（第二版）》）：
+
+  * 在 Channel 接口层，采用 `Facade` 模式进行统一封装，将网络 I/O 操作、网络 I/O 相关联的其他操作封装起来，统一对外提供。
+  * Channel 接口的定义尽量大而全，为 `SocketChannel` 和 `ServerSocketChannel` 提供统一的视图，由不同子类实现不同的功能，公共功能在抽象父类中实现，最大程度地实现功能和接口的重用。
+  * 具体实现采用聚合而非包含的方式，将相关的功能类聚合在 Channel 中，有 Channel 统一负责和调度，功能实现更加灵活。
+
+### EventLoop
+  Netty 基于事件驱动模型，使用不同的事件来通知我们状态的改变或者操作状态的改变。它定义了在整个连接的生命周期里当有事件发生的时候处理的核心抽象。
+
+  `Channel` 为Netty `网络操作抽象类`，`EventLoop` 主要是`为Channel 处理 I/O 操作`，两者配合参与 I/O 操作。
+
+  下图是Channel、EventLoop、Thread、EventLoopGroup之间的关系（摘自《Netty In Action》）：
+
+  <div align="center"><img src="img/2251324-eb649f88013c075d.png"></div>
+
+  * 一个 EventLoopGroup 包含一个或多个 EventLoop。
+  * 一个 EventLoop 在它的生命周期内只能与一个Thread绑定。
+  * 所有有 EnventLoop 处理的 I/O 事件都将在它专有的 Thread 上被处理。
+  * 一个 Channel 在它的生命周期内只能注册与一个 EventLoop。
+  * 一个 EventLoop 可被分配至一个或多个 Channel 。
+
+  当一个连接到达时，Netty 就会注册一个 Channel，然后从 EventLoopGroup 中分配一个 EventLoop 绑定到这个Channel上，在该Channel的整个生命周期中都是有这个绑定的 EventLoop 来服务的。
+
+### ChannelFuture
+
+  Netty 为异步非阻塞，即所有的 I/O 操作都为异步的，因此，我们不能立刻得知消息是否已经被处理了。
+  Netty 提供了 ChannelFuture 接口，通过该接口的 `addListener()` 方法注册一个 `ChannelFutureListener`，当操作执行成功或者失败时，监听就会自动触发返回结果。
+
+### ChannelHandler
+  `ChannelHandler` 为 Netty 中最核心的组件，它 **充当了所有处理入站和出站数据的应用程序逻辑的容器**。
+
+  ChannelHandler 主要用来处理各种事件，这里的事件很广泛，比如可以是连接、数据接收、异常、数据转换等。
+
+  ChannelHandler 有两个核心子类 ChannelInboundHandler 和 ChannelOutboundHandler，其中 ChannelInboundHandler 用于接收、处理入站数据和事件，而 ChannelOutboundHandler 则相反。
+
+### ChannelPipeline
+  `ChannelPipeline` **为 ChannelHandler 链提供了一个容器并定义了用于沿着链传播入站和出站事件流的 API**。一个数据或者事件可能会被多个 Handler 处理，在这个过程中，数据或者事件经流 ChannelPipeline，由 ChannelHandler 处理。
+
+  在这个处理过程中，一个 ChannelHandler 接收数据后处理完成后交给下一个 ChannelHandler，或者什么都不做直接交给下一个 ChannelHandler。
+
+  <div align="center"><img src="img/2251324-0b57c10e60471725.png"></div>
+
+  当一个数据流进入 ChannlePipeline 时，它会从 ChannelPipeline 头部开始传给第一个 ChannelInboundHandler ，当第一个处理完后再传给下一个，一直传递到管道的尾部。与之相对应的是，当数据被写出时，它会从管道的尾部开始，先经过管道尾部的 “最后” 一个ChannelOutboundHandler，当它处理完成后会传递给前一个 ChannelOutboundHandler 。
+
+  当 ChannelHandler 被添加到 ChannelPipeline 时，它将会被分配一个 `ChannelHandlerContext`，它代表了 ChannelHandler 和 ChannelPipeline 之间的绑定。
+
+  其中 ChannelHandler 添加到 ChannelPipeline 过程如下：
+
+  1. 一个 ChannelInitializer 的实现被注册到了 ServerBootStrap中
+  2. 当 ChannelInitializer.initChannel() 方法被调用时，ChannelInitializer 将在 ChannelPipeline 中安装一组自定义的 ChannelHandler
+  3. ChannelInitializer 将它自己从 ChannelPipeline 中移除
diff --git a/04 - Middleware/netty/img/20171204211824475.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/20171204211824475.png"
similarity index 100%
rename from 04 - Middleware/netty/img/20171204211824475.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/20171204211824475.png"
diff --git a/04 - Middleware/netty/img/20171204211923932.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/20171204211923932.png"
similarity index 100%
rename from 04 - Middleware/netty/img/20171204211923932.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/20171204211923932.png"
diff --git a/04 - Middleware/netty/img/20171204211954815.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/20171204211954815.png"
similarity index 100%
rename from 04 - Middleware/netty/img/20171204211954815.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/20171204211954815.png"
diff --git a/04 - Middleware/netty/img/2251324-0b57c10e60471725.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/2251324-0b57c10e60471725.png"
similarity index 100%
rename from 04 - Middleware/netty/img/2251324-0b57c10e60471725.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/2251324-0b57c10e60471725.png"
diff --git a/04 - Middleware/netty/img/2251324-eb649f88013c075d.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/2251324-eb649f88013c075d.png"
similarity index 100%
rename from 04 - Middleware/netty/img/2251324-eb649f88013c075d.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/img/2251324-eb649f88013c075d.png"
diff --git a/04 - Middleware/netty/userGaide.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/userGaide.md"
similarity index 100%
rename from 04 - Middleware/netty/userGaide.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/userGaide.md"
diff --git "a/04 - Middleware/netty/\346\234\215\345\212\241\347\253\257\345\220\257\345\212\250\350\277\207\347\250\213\345\210\206\346\236\220.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/\346\234\215\345\212\241\347\253\257\345\220\257\345\212\250\350\277\207\347\250\213\345\210\206\346\236\220.md"
similarity index 97%
rename from "04 - Middleware/netty/\346\234\215\345\212\241\347\253\257\345\220\257\345\212\250\350\277\207\347\250\213\345\210\206\346\236\220.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/\346\234\215\345\212\241\347\253\257\345\220\257\345\212\250\350\277\207\347\250\213\345\210\206\346\236\220.md"
index d02a58b5..97ea5deb 100644
--- "a/04 - Middleware/netty/\346\234\215\345\212\241\347\253\257\345\220\257\345\212\250\350\277\207\347\250\213\345\210\206\346\236\220.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/\346\234\215\345\212\241\347\253\257\345\220\257\345\212\250\350\277\207\347\250\213\345\210\206\346\236\220.md"	
@@ -1,889 +1,889 @@
-https://blog.csdn.net/chenssy/article/details/78714003
-下面先来一段 Netty 服务端的代码：
-```java
-public class NettyServer {
-
-    public void bind(int port){
-        // 创建EventLoopGroup
-        EventLoopGroup bossGroup = new NioEventLoopGroup();        //创建BOSS线程组 用于服务端接受客户端的连接
-        EventLoopGroup workerGroup = new NioEventLoopGroup();      //创建WORK线程组 用于进行SocketChannel的网络读写
-
-        try {
-            // 创建ServerBootStrap实例
-            // ServerBootstrap 用于启动NIO服务端的辅助启动类，目的是降低服务端的开发复杂度
-            ServerBootstrap b = new ServerBootstrap();
-            // 绑定Reactor线程池
-            b.group(bossGroup, workerGroup)
-                    // 设置并绑定服务端Channel
-                    // 指定所使用的NIO传输的Channel
-                    .channel(NioServerSocketChannel.class)
-                    .option(ChannelOption.SO_BACKLOG, 1024)
-                    .handler(new LoggingServerHandler())
-                    .childHandler(new ChannelInitializer(){
-
-                        @Override
-                        protected void initChannel(Channel ch) throws Exception {
-                            //do something
-                        }
-                    });
-
-            // 绑定端口，同步等待成功
-            ChannelFuture future = b.bind(port).sync();
-            // 等待服务端监听端口关闭
-            future.channel().closeFuture().sync();
-
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        } finally {
-            // 优雅地关闭
-            bossGroup.shutdownGracefully();
-            workerGroup.shutdownGracefully();
-        }
-    }
-
-    private class LoggingServerHandler extends ChannelInboundHandlerAdapter{
-        @Override
-        public void channelActive(ChannelHandlerContext ctx) throws Exception {
-            System.out.println("loggin-channelActive");
-        }
-
-        @Override
-        public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
-            System.out.println("loggin-channelRegistered");
-        }
-
-        @Override
-        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
-            System.out.println("loggin-handlerAdded");
-        }
-    }
-
-    public static void main(String[] args){
-            new NettyServer().bind(8899);
-    }
-}
-```
-上面代码为 Netty 服务器端的完整代码，在整个服务端代码中会涉及如下几个核心类。
-
-`ServerBootstrap`
-
-ServerBootstrap 为 Netty 服务端的启动辅助类，它提供了一系列的方法用于设置服务端启动相关的参数。
-
-`Channel`
-
-Channel 为 Netty 网络操作抽象类，它定义了一组功能，其提供的 API 大大降低了直接使用 Socket 类的复杂性。当然它也不仅仅只是包括了网络 IO 操作的基本功能，还包括一些与 Netty 框架相关的功能，包括获取该 Channel 的 EventLoop 等等。
-
-`EventLoopGroup`
-
-EventLoopGroup 为 Netty 的 Reactor 线程池，它实际上就是 EventLoop 的容器，而 EventLoop 为 Netty 的核心抽象类，它的主要职责是处理所有注册到本线程多路复用器 Selector 上的 Channel。
-
-`ChannelHandler`
-
-ChannelHandler 作为 Netty 的主要组件，它主要负责 I/O 事件或者 I/O 操作进行拦截和处理，它可以选择性地拦截和处理自己感觉兴趣的事件，也可以透传和终止事件的传递。
-
-`ChannelPipeline`
-
-ChannelPipeline 是 ChannelHandler 链的容器，它负责 ChannelHandler 的管理和事件拦截与调度。每当新建一个 Channel 都会分配一个新的 ChannelPepeline，同时这种关联是永久性的。
-
-### 服务端创建流程
-Netty 服务端创建的时序图，如下（摘自《Netty权威指南（第二版）》）
-
-<div align="center" ><img src="img/20171204211824475.png"></div>
-
-主要步骤为：
-
-1. 创建 ServerBootstrap 实例
-2. 设置并绑定 Reactor 线程池
-3. 设置并绑定服务端 Channel
-4. 创建并初始化 ChannelPipeline
-5. 添加并设置 ChannelHandler
-6. 绑定并启动监听端口
-
-### 服务端源码分析
-
-#### 1、创建两个EventLoopGroup
-```java
-    EventLoopGroup bossGroup = new NioEventLoopGroup();
-    EventLoopGroup workerGroup = new NioEventLoopGroup();
-```
-bossGroup 为 BOSS 线程组，用于服务端接受客户端的连接, workerGroup 为 worker 线程组，用于进行 SocketChannel 的网络读写。当然也可以创建一个并共享。
-#### 2、创建ServerBootstrap实例
-```java
-ServerBootstrap b = new ServerBootstrap();
-```
-ServerBootStrap为Netty服务端的启动引导类，用于帮助用户快速配置、启动服务端服务。提供的方法如下：
-
-| 方法名称	       |  方法描述
-| -------- | --------
-| group	          |  设置 ServerBootstrap 要用的 EventLoopGroup
-| channel	        |  设置将要被实例化的 ServerChannel 类
-| option	        |  实例化的 ServerChannel 的配置项
-| childHandler	  |  设置并添加 ChannelHandler
-| bind	          |  绑定 ServerChannel
-
-
-ServerBootStrap底层采用`装饰者模式`。
-
-#### 3、设置并绑定Reactor线程池
-
-调用 group() 方法，为 ServerBootstrap 实例设置并绑定 Reactor 线程池。
-```java
-b.group(bossGroup, workerGroup)
-```
-EventLoopGroup 为 Netty 线程池，它实际上就是 EventLoop 的数组容器。EventLoop 的职责是处理所有注册到本线程多路复用器 Selector 上的 Channel，Selector 的轮询操作由绑定的 EventLoop 线程 run 方法驱动，在一个循环体内循环执行。通俗点讲就是一个死循环，不断的检测 I/O 事件、处理 I/O 事件。
-
-这里设置了两个group，这个其实有点儿像我们工作一样。需要两类型的工人，一个老板（bossGroup）,一个工人（workerGroup），老板负责从外面接活，工人则负责死命干活。所以这里 bossGroup 的作用就是不断地接收新的连接，接收之后就丢给 workerGroup 来处理，workerGroup 负责干活就行（负责客户端连接的 IO 操作）。
-
-源码如下：
-```java
-public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
-    super.group(parentGroup);        // 绑定boosGroup
-    if (childGroup == null) {
-        throw new NullPointerException("childGroup");
-    }
-    if (this.childGroup != null) {
-        throw new IllegalStateException("childGroup set already");
-    }
-    this.childGroup = childGroup;    // 绑定workerGroup
-    return this;
-}
-```
-其中父 EventLoopGroup 传递到父类的构造函数中：
-```java
-public B group(EventLoopGroup group) {
-    if (group == null) {
-        throw new NullPointerException("group");
-    }
-    if (this.group != null) {
-        throw new IllegalStateException("group set already");
-    }
-    this.group = group;
-    return (B) this;
-}
-```
-#### 4、设置并绑定服务端Channel
-绑定线程池后，则需要设置 channel 类型，服务端用的是 NioServerSocketChannel 。
-```java
-.channel(NioServerSocketChannel.class)
-```
-调用 ServerBootstrap.channel 方法用于设置服务端使用的 Channel，传递一个 NioServerSocketChannel Class对象，Netty通过工厂类，利用反射创建NioServerSocketChannel 对象，如下：
-```java
-public B channel(Class<? extends C> channelClass) {
-    if (channelClass == null) {
-        throw new NullPointerException("channelClass");
-    }
-    return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
-}
-```
-channelFactory() 用于设置 Channel 工厂的：
-```java
-public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
-    return channelFactory((ChannelFactory<C>) channelFactory);
-}
-
-public B channelFactory(ChannelFactory<? extends C> channelFactory) {
-    if (channelFactory == null) {
-        throw new NullPointerException("channelFactory");
-    }
-    if (this.channelFactory != null) {
-        throw new IllegalStateException("channelFactory set already");
-    }
-
-    this.channelFactory = channelFactory;
-    return (B) this;
-}
-```
-这里传递的是 ReflectiveChannelFactory，其源代码如下：
-```java
-public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {
-
-    private final Class<? extends T> clazz;
-
-    public ReflectiveChannelFactory(Class<? extends T> clazz) {
-        if (clazz == null) {
-            throw new NullPointerException("clazz");
-        }
-        this.clazz = clazz;
-    }
-    //需要创建 channel 的时候，该方法将被调用
-    @Override
-    public T newChannel() {
-        try {
-            // 反射创建对应 channel
-            return clazz.newInstance();
-        } catch (Throwable t) {
-            throw new ChannelException("Unable to create Channel from class " + clazz, t);
-        }
-    }
-
-    @Override
-    public String toString() {
-        return StringUtil.simpleClassName(clazz) + ".class";
-    }
-}
-```
-确定服务端的 Channel（NioServerSocketChannel）后，调用 option()方法设置 Channel 参数，作为服务端，主要是设置TCP的backlog参数，如下：
-```java
-.option(ChannelOption.SO_BACKLOG, 1024)
-```
-option()源码如下：
-```java
-public <T> B option(ChannelOption<T> option, T value) {
-    if (option == null) {
-        throw new NullPointerException("option");
-    }
-    if (value == null) {
-        synchronized (options) {
-            options.remove(option);
-        }
-    } else {
-        synchronized (options) {
-            options.put(option, value);
-        }
-    }
-    return (B) this;
-}
-
-private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
-```
-
-#### 五、添加并设置ChannelHandler
-
-设置完 Channel 参数后，用户可以为启动辅助类和其父类分别指定 Handler。
-```java
- .handler(new LoggingServerHandler())
-.childHandler(new ChannelInitializer(){
-    //省略代码
-})
-```
-这两个 Handler 不一样，前者（handler()）设置的 Handler 是服务端 NioServerSocketChannel的，后者（childHandler()）设置的 Handler 是属于每一个新建的 NioSocketChannel 的。跟踪源代码会发现两种所处的类不一样，handler 位于 AbstractBootstrap 中，childHandler 位于 ServerBootstrap 中，如下：
-```java
-// AbstractBootstrap
-public B handler(ChannelHandler handler) {
-    if (handler == null) {
-        throw new NullPointerException("handler");
-    }
-    this.handler = handler;
-    return (B) this;
-}
-
-// ServerBootstrap
-public ServerBootstrap childHandler(ChannelHandler childHandler) {
-    if (childHandler == null) {
-        throw new NullPointerException("childHandler");
-    }
-    this.childHandler = childHandler;
-    return this;
-}
-```
-ServerBootstrap 中的 Handler 是 NioServerSocketChannel 使用的，所有连接该监听端口的客户端都会执行它，父类 AbstractBootstrap 中的 Handler 是一个工厂类，它为每一个新接入的客户端都创建一个新的 Handler。如下图（《Netty权威指南（第二版）》）：
-<div align="center"><img src="img/20171204211923932.png></div>
-
-### 六、绑定端口，启动服务
-
-服务端最后一步，绑定端口并启动服务，如下：
-```java
-ChannelFuture future = b.bind(port).sync();
-```
-调用 ServerBootstrap 的 bind() 方法进行端口绑定：
-```java
-public ChannelFuture bind(int inetPort) {
-    return bind(new InetSocketAddress(inetPort));
-}
-
-public ChannelFuture bind(SocketAddress localAddress) {
-    validate();
-    if (localAddress == null) {
-        throw new NullPointerException("localAddress");
-    }
-    return doBind(localAddress);
-}    
-```
-首先调用 validate() 方法进行参数校验，然后调用 doBind() 方法：
-```java
-private ChannelFuture doBind(final SocketAddress localAddress) {
-    // 初始化并注册一个Channel
-    final ChannelFuture regFuture = initAndRegister();
-
-    final Channel channel = regFuture.channel();
-    if (regFuture.cause() != null) {
-        return regFuture;
-    }
-
-    // 注册成功
-    if (regFuture.isDone()) {
-        // At this point we know that the registration was complete and successful.
-        ChannelPromise promise = channel.newPromise();
-        // 调用doBind0绑定
-        doBind0(regFuture, channel, localAddress, promise);
-        return promise;
-    } else {
-        // Registration future is almost always fulfilled already, but just in case it's not.
-        final AbstractBootstrap.PendingRegistrationPromise promise = new AbstractBootstrap.PendingRegistrationPromise(channel);
-        regFuture.addListener(new ChannelFutureListener() {
-            @Override
-            public void operationComplete(ChannelFuture future) throws Exception {
-                Throwable cause = future.cause();
-                if (cause != null) {
-                    // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
-                    // IllegalStateException once we try to access the EventLoop of the Channel.
-                    promise.setFailure(cause);
-                } else {
-                    // Registration was successful, so set the correct executor to use.
-                    // See https://github.com/netty/netty/issues/2586
-                    promise.registered();
-
-                    doBind0(regFuture, channel, localAddress, promise);
-                }
-            }
-        });
-        return promise;
-    }
-}
-```
-该方法涉及内容较多，我们分解来看，如下：
-1. 首先通过 initAndRegister() 得到一个 ChannelFuture 对象 regFuture；
-2. 根据得到的 regFuture 对象判断该对象是否抛出异常 （regFuture.cause()），如果是，直接返回；
-3. 根据 regFuture.isDone()判断 initAndRegister()是否执行完毕，如果执行完成，则调用 doBind0；
-4. 若 initAndRegister() 没有执行完毕，则向 regFuture 对象添加一个 ChannelFutureListener 监听，当 initAndRegister() 执行完毕后会调用 operationComplete()，在 operationComplete() 中依然会判断 ChannelFuture 是否抛出异常，如果没有则调用 doBind0进行绑定。
-
-按照上面的步骤我们一步一步来剖析 doBind() 方法。
-
-**initAndRegister()**
-
-执行 initAndRegister() 会得到一个 ChannelFuture 对象 regFuture，代码如下：
-```java
-final ChannelFuture initAndRegister() {
-   Channel channel = null;
-   try {
-       // 新建一个Channel
-       channel = channelFactory.newChannel();
-       // 初始化Channel
-       init(channel);
-   } catch (Throwable t) {
-       if (channel != null) {
-           channel.unsafe().closeForcibly();
-       }
-       return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
-   }
-
-   // /向EventLoopGroup中注册一个channel
-   ChannelFuture regFuture = config().group().register(channel);
-   if (regFuture.cause() != null) {
-       if (channel.isRegistered()) {
-           channel.close();
-       } else {
-           channel.unsafe().closeForcibly();
-       }
-   }
-   return regFuture;
-}
-```
-首先调用 newChannel() 新建一个Channel，这里是NioServerSocketChannel，还记前面 4、设置并绑定服务端Channel（.channel(NioServerSocketChannel.class)）中 设置的Channel工厂类么？在这里派上用处了。在上面提到了通过反射的机制我们可以得到一个 NioServerSocketChannel 类的实例。那么 NioServerSocketChannel 到底是一个什么东西呢？如下图：
-
-20171204211954815.png
-
-上图是 NioServerSocketChannel 的继承体系结构图， NioServerSocketChannel 在构造函数中会依靠父类来完成一项一项的初始化工作。先看 NioServerSocketChannel 构造函数。
-```java
-public NioServerSocketChannel() {
-    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
-}
-```
-该构造函数首先是调用父类的构造方法，然后设置 config属性。父类构造方法如下：
-```java
-// AbstractNioMessageChannel
-protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
-    super(parent, ch, readInterestOp);
-}
-
-// AbstractNioChannel
-protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
-    super(parent);
-    this.ch = ch;
-    this.readInterestOp = readInterestOp;
-    try {
-        ch.configureBlocking(false);
-    } catch (IOException e) {
-        try {
-            ch.close();
-        } catch (IOException e2) {
-            if (logger.isWarnEnabled()) {
-                logger.warn(
-                        "Failed to close a partially initialized socket.", e2);
-            }
-        }
-
-        throw new ChannelException("Failed to enter non-blocking mode.", e);
-    }
-}
-
-// AbstractChannel
-protected AbstractChannel(Channel parent) {
-    this.parent = parent;
-    id = newId();
-    unsafe = newUnsafe();
-    pipeline = newChannelPipeline();
-}
-```
-通过 super() ，一层一层往上，直到 AbstractChannel。我们从最上层解析。
-
-* AbstractChannel 设置了 unsafe (unsafe = newUnsafe())和 pipeline(pipeline = newChannelPipeline())；
-* AbstractNioChannel 将当前 ServerSocketChannel 设置成了非阻塞（ch.configureBlocking(false);），同时设置SelectionKey.OP_ACCEPT事件(this.readInterestOp = readInterestOp; readInterestOp 值由 NioServerSocketChannel 中传递)；
-* NioServerSocketChannel 设置 config属性（config = new NioServerSocketChannelConfig(this, javaChannel().socket())）。
-所以 channel = channelFactory.newChannel() 通过反射机制产生了 NioServerSocketChannel 类实例。同时该实例设置了NioMessageUnsafe、DefaultChannelPipeline、非阻塞、SelectionKey.OP_ACCEPT事件 和 NioServerSocketChannelConfig 属性。
-
-看完了 channelFactory.newChannel();，我们再看 init()。
-```java
-void init(Channel channel) throws Exception {
-     // 设置配置的option参数
-    final Map<ChannelOption<?>, Object> options = options0();
-    synchronized (options) {
-        channel.config().setOptions(options);
-    }
-
-    final Map<AttributeKey<?>, Object> attrs = attrs0();
-    synchronized (attrs) {
-        for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
-            @SuppressWarnings("unchecked")
-            AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
-            channel.attr(key).set(e.getValue());
-        }
-    }
-
-    // 获取绑定的pipeline
-    ChannelPipeline p = channel.pipeline();
-
-    // 准备child用到的4个part
-    final EventLoopGroup currentChildGroup = childGroup;
-    final ChannelHandler currentChildHandler = childHandler;
-    final Entry<ChannelOption<?>, Object>[] currentChildOptions;
-    final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
-    synchronized (childOptions) {
-        currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
-    }
-    synchronized (childAttrs) {
-        currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
-    }
-
-    // 为NioServerSocketChannel的pipeline添加一个初始化Handler,
-    // 当NioServerSocketChannel在EventLoop注册成功时，该handler的init方法将被调用
-    p.addLast(new ChannelInitializer<Channel>() {
-        @Override
-        public void initChannel(Channel ch) throws Exception {
-            final ChannelPipeline pipeline = ch.pipeline();
-            ChannelHandler handler = config.handler();
-            //如果用户配置过Handler
-            if (handler != null) {
-                pipeline.addLast(handler);
-            }
-
-            ch.eventLoop().execute(new Runnable() {
-                @Override
-                public void run() {
-                    // 为NioServerSocketChannel的pipeline添加ServerBootstrapAcceptor处理器
-                    // 该Handler主要用来将新创建的NioSocketChannel注册到EventLoopGroup中
-                    pipeline.addLast(new ServerBootstrapAcceptor(
-                            currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
-                }
-            });
-        }
-    });
-}
-```
-其实整个过程可以分为三个步骤：
-
-1. 设置 Channel 的 option 和 attr；
-2. 获取绑定的 pipeline，然后为 NioServerSocketChanne l绑定的 pipeline 添加 Handler；
-3. 将用于服务端注册的 Handler ServerBootstrapAcceptor 添加到 ChannelPipeline 中。ServerBootstrapAcceptor 为一个接入器，专门接受新请求，把新的请求扔给某个事件循环器。
-
-至此初始化部分已经结束，我们再看注册部分，
-```java
-// /向EventLoopGroup中注册一个channel
-       ChannelFuture regFuture = config().group().register(channel);
-```
-注册方法的调用位于 initAndRegister() 方法中。注意这里的 group() 返回的是前面的 boss NioEvenLoopGroup，它继承 MultithreadEventLoopGroup，调用的 register()，也是 MultithreadEventLoopGroup 中的。如下：
-```java
-public ChannelFuture register(Channel channel) {
-    return next().register(channel);
-}
-```
-调用 next() 方法从 EventLoopGroup 中获取下一个 EventLoop，调用 register() 方法注册：
-```java
-public ChannelFuture register(Channel channel) {
-    return register(new DefaultChannelPromise(channel, this));
-}
-```
-将Channel和EventLoop封装成一个DefaultChannelPromise对象，然后调用register()方法。DefaultChannelPromis为ChannelPromise的默认实现，而ChannelPromisee继承Future，具备异步执行结构，绑定Channel，所以又具备了监听的能力，故而ChannelPromis是Netty异步执行的核心接口。
-```java
-public ChannelFuture register(ChannelPromise promise) {
-    ObjectUtil.checkNotNull(promise, "promise");
-    promise.channel().unsafe().register(this, promise);
-    return promise;
-}
-``
-首先获取 channel 的 unsafe 对象，该 unsafe 对象就是在之前设置过得。然后调用 register() 方法，如下：
-```java
-public final void register(EventLoop eventLoop, final ChannelPromise promise) {
-    if (eventLoop == null) {
-        throw new NullPointerException("eventLoop");
-    }
-    if (isRegistered()) {
-        promise.setFailure(new IllegalStateException("registered to an event loop already"));
-        return;
-    }
-    if (!isCompatible(eventLoop)) {
-        promise.setFailure(
-                new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
-        return;
-    }
-
-    AbstractChannel.this.eventLoop = eventLoop;
-
-    // 必须要保证注册是由该EventLoop发起的
-    if (eventLoop.inEventLoop()) {
-        register0(promise);        // 注册
-    } else {
-        // 如果不是单独封装成一个task异步执行
-        try {
-            eventLoop.execute(new Runnable() {
-                @Override
-                public void run() {
-                    register0(promise);
-                }
-            });
-        } catch (Throwable t) {
-            logger.warn(
-                    "Force-closing a channel whose registration task was not accepted by an event loop: {}",
-                    AbstractChannel.this, t);
-            closeForcibly();
-            closeFuture.setClosed();
-            safeSetFailure(promise, t);
-        }
-    }
-}
-```
-过程如下：
-1. 首先通过isRegistered() 判断该 Channel 是否已经注册到 EventLoop 中；
-2. 通过 eventLoop.inEventLoop() 来判断当前线程是否为该 EventLoop 自身发起的，如果是，则调用 register0() 直接注册；
-3. 如果不是，说明该 EventLoop 中的线程此时没有执行权，则需要新建一个线程，单独封装一个 Task，而该 Task 的主要任务则是执行 register0()。
-
-无论当前 EventLoop 的线程是否拥有执行权，最终都会要执行 register0()，如下：
-```java
-private void register0(ChannelPromise promise) {
-    try {
-        // 确保 Channel 处于 open
-        if (!promise.setUncancellable() || !ensureOpen(promise)) {
-            return;
-        }
-        boolean firstRegistration = neverRegistered;
-
-        // 真正的注册动作
-        doRegister();
-
-        neverRegistered = false;
-        registered = true;        
-
-        pipeline.invokeHandlerAddedIfNeeded();    
-        safeSetSuccess(promise);        //设置注册结果为成功
-
-        pipeline.fireChannelRegistered();
-
-        if (isActive()) {
-            //如果是首次注册,发起 pipeline 的 fireChannelActive
-            if (firstRegistration) {
-                pipeline.fireChannelActive();
-            } else if (config().isAutoRead()) {
-                beginRead();
-            }
-        }
-    } catch (Throwable t) {
-        closeForcibly();
-        closeFuture.setClosed();
-        safeSetFailure(promise, t);
-    }
-}
-```
-如果 Channel 处于 open 状态，则调用 doRegister() 方法完成注册，然后将注册结果设置为成功。最后判断如果是首次注册且处于激活状态，则发起 pipeline 的 fireChannelActive()。
-```java
-protected void doRegister() throws Exception {
-    boolean selected = false;
-    for (;;) {
-        try {
-            // 注册到NIOEventLoop的Selector上
-            selectionKey = javaChannel().register(eventLoop().selector, 0, this);
-            return;
-        } catch (CancelledKeyException e) {
-            if (!selected) {
-                eventLoop().selectNow();
-                selected = true;
-            } else {
-                throw e;
-            }
-        }
-    }
-}
-```
-这里注册时 ops 设置的是 0，也就是说 ServerSocketChannel 仅仅只是表示了注册成功，还不能监听任何网络操作，这样做的目的是（摘自《Netty权威指南（第二版）》）：
-
-1. 注册方式是多态的，它既可以被 NIOServerSocketChannel 用来监听客户端的连接接入，也可以注册 SocketChannel 用来监听网络读或者写操作。
-2. 通过 SelectionKey.interestOps(int ops) 方法可以方便地修改监听操作位。所以，此处注册需要获取 SelectionKey 并给 AbstractNIOChannel 的成员变量 selectionKey 赋值。
-
-由于这里 ops 设置为 0，所以还不能监听读写事件。调用 doRegister()后，然后调用pipeline.invokeHandlerAddedIfNeeded();，这个时候控制台会出现 loggin-handlerAdded，内部如何调用，我们在剖析 pipeline 时再做详细分析。然后将注册结果设置为成功（safeSetSuccess(promise)）。调用 pipeline.fireChannelRegistered(); 这个时候控制台会打印 loggin-channelRegistered。这里简单分析下该方法。
-```java
-public final ChannelPipeline fireChannelRegistered() {
-       AbstractChannelHandlerContext.invokeChannelRegistered(head);
-       return this;
-   }
-
-   static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
-       EventExecutor executor = next.executor();
-       if (executor.inEventLoop()) {
-           next.invokeChannelRegistered();
-       } else {
-           executor.execute(new Runnable() {
-               @Override
-               public void run() {
-                   next.invokeChannelRegistered();
-               }
-           });
-       }
-   }
-```
-pipeline 维护着 handle 链表，事件会在 NioServerSocketChannel 的 pipeline 中传播。最终都会调用 next.invokeChannelRegistered()，如下：
-```java
-private void invokeChannelRegistered() {
-    if (invokeHandler()) {
-        try {
-            ((ChannelInboundHandler) handler()).channelRegistered(this);
-        } catch (Throwable t) {
-            notifyHandlerException(t);
-        }
-    } else {
-        fireChannelRegistered();
-    }
-}
-```
-在 invokeChannelRegistered() 会调用我们在前面设置的 handler （还记得签名的 handler(new LoggingServerHandler() )么）的 channelRegistered()，这个时候控制台应该会打印 loggin-channelRegistered。
-
-到这里initAndRegister() (final ChannelFuture regFuture = initAndRegister();)就分析完毕了，该方法主要做如下三件事：
-1. 通过反射产生了一个 NioServerSocketChannle 对象；
-2. 调用 init(channel)完成初始化工作；
-3. 将NioServerSocketChannel进行了注册。
-
-initAndRegister()篇幅较长，分析完毕了，我们再返回到doBind(final SocketAddress localAddress)。在 doBind(final SocketAddress localAddress) 中如果 initAndRegister()执行完成，则 regFuture.isDone() 则为 true，执行 doBind0()。如果没有执行完成，则会注册一个监听 ChannelFutureListener，当 initAndRegister() 完成后，会调用该监听的 operationComplete()方法，最终目的还是执行 doBind0()。故而我们下面分析 doBind0()到底做了些什么。源码如下：
-```java
-private static void doBind0(
-        final ChannelFuture regFuture, final Channel channel,
-        final SocketAddress localAddress, final ChannelPromise promise) {
-
-    channel.eventLoop().execute(new Runnable() {
-        @Override
-        public void run() {
-            if (regFuture.isSuccess()) {
-                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
-            } else {
-                promise.setFailure(regFuture.cause());
-            }
-        }
-    });
-}
-```
-    doBind0() 较为简单，首先new 一个线程 task，然后将该任务提交到 NioEventLoop 中进行处理，我们先看 execute()。
-```java
-public void execute(Runnable task) {
-    if (task == null) {
-        throw new NullPointerException("task");
-    }
-
-    boolean inEventLoop = inEventLoop();
-    if (inEventLoop) {
-        addTask(task);
-    } else {
-        startThread();
-        addTask(task);
-        if (isShutdown() && removeTask(task)) {
-            reject();
-        }
-    }
-
-    if (!addTaskWakesUp && wakesUpForTask(task)) {
-        wakeup(inEventLoop);
-    }
-}
-```
-调用 inEventLoop() 判断当前线程是否为该 NioEventLoop 所关联的线程，如果是，则调用 addTask() 将任务 task 添加到队列中，如果不是，则先启动线程，在调用 addTask() 将任务 task 添加到队列中。addTask() 如下：
-```java
-protected void addTask(Runnable task) {
-    if (task == null) {
-        throw new NullPointerException("task");
-    }
-    if (!offerTask(task)) {
-        reject(task);
-    }
-}
-```
-offerTask()添加到队列中：
-```java
-final boolean offerTask(Runnable task) {
-    if (isShutdown()) {
-        reject();
-    }
-    return taskQueue.offer(task);
-}
-```
-task 添加到任务队列 taskQueue成功后，执行任务会调用如下方法：
-```java
-channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
-```
-channel 首先调用 bind() 完成 channel 与端口的绑定，如下：
-```java
-public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
-    return pipeline.bind(localAddress, promise);
-}
-
-public final ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
-    return tail.bind(localAddress, promise);
-}
-```
-tail 在 DefaultChannelPipeline 中定义：final AbstractChannelHandlerContext tail; 有 tail 就会有 head ，在 DefaultChannelPipeline 中维护这一个 AbstractChannelHandlerContext 节点的双向链表，该链表是实现 Pipeline 机制的关键，更多详情会在 ChannelPipeline 中做详细说明。bind() 最终会调用 DefaultChannelPipeline 的 bind() 方法。如下：
-```java
-public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
-    if (localAddress == null) {
-        throw new NullPointerException("localAddress");
-    }
-    if (!validatePromise(promise, false)) {
-        // cancelled
-        return promise;
-    }
-
-    final AbstractChannelHandlerContext next = findContextOutbound();
-    EventExecutor executor = next.executor();
-    if (executor.inEventLoop()) {
-        next.invokeBind(localAddress, promise);
-    } else {
-        safeExecute(executor, new Runnable() {
-            @Override
-            public void run() {
-                next.invokeBind(localAddress, promise);
-            }
-        }, promise, null);
-    }
-    return promise;
-}
-```
-首先对 localAddress 、 promise 进行校验，符合规范则调用 findContextOutbound() ，该方法用于在 pipeline 中获取 AbstractChannelHandlerContext 双向链表中的一个节点，如下：
-```java
-private AbstractChannelHandlerContext findContextOutbound() {
-    AbstractChannelHandlerContext ctx = this;
-    do {
-        ctx = ctx.prev;
-    } while (!ctx.outbound);
-    return ctx;
-}
-```
-从该方法可以看出，所获取的节点是从 tail 开始遍历，获取第一个节点属性 outbound 为 true 的节点。其实该节点是 AbstractChannelHandlerContext 双向链表的 head 节点。获取该节点后，调用 invokeBind()，如下：
-```java
-private void invokeBind(SocketAddress localAddress, ChannelPromise promise) {
-    if (invokeHandler()) {
-        try {
-            ((ChannelOutboundHandler) handler()).bind(this, localAddress, promise);
-        } catch (Throwable t) {
-            notifyOutboundHandlerException(t, promise);
-        }
-    } else {
-        bind(localAddress, promise);
-    }
-}
-```
-handler() 返回的是 HeadContext 对象，然后调用其bind()，如下：
-```java
-public void bind(
-        ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
-        throws Exception {
-    unsafe.bind(localAddress, promise);
-}
-```
-unsafe 定义在 HeadContext 中，在构造函数中初始化（unsafe = pipeline.channel().unsafe();），调用 bind() 如下：
-```java
-public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
-    assertEventLoop();
-
-    if (!promise.setUncancellable() || !ensureOpen(promise)) {
-        return;
-    }
-
-    if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
-        localAddress instanceof InetSocketAddress &&
-        !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
-        !PlatformDependent.isWindows() && !PlatformDependent.isRoot()) {
-
-        logger.warn(
-                "A non-root user can't receive a broadcast packet if the socket " +
-                "is not bound to a wildcard address; binding to a non-wildcard " +
-                "address (" + localAddress + ") anyway as requested.");
-    }
-
-    boolean wasActive = isActive();
-    try {
-        // 最核心方法
-        doBind(localAddress);
-    } catch (Throwable t) {
-        safeSetFailure(promise, t);
-        closeIfClosed();
-        return;
-    }
-
-    if (!wasActive && isActive()) {
-        invokeLater(new Runnable() {
-            @Override
-            public void run() {
-                pipeline.fireChannelActive();
-            }
-        });
-    }
-
-    safeSetSuccess(promise);
-}
-```
-内部调用 doBind() ，该方法为绑定中最核心的方法，位于 NioServerSocketChannel 中，如下：
-```java
-protected void doBind(SocketAddress localAddress) throws Exception {
-    if (PlatformDependent.javaVersion() >= 7) {
-        javaChannel().bind(localAddress, config.getBacklog());
-    } else {
-        javaChannel().socket().bind(localAddress, config.getBacklog());
-    }
-}
-```
-javaChannel()返回的是 NioServerSocketChannel 实例初始化时所产生的 Java NIO ServerSocketChannel 实例（ServerSocketChannelImple实例），然后调用其 bind()，如下：
-```java
-public ServerSocketChannel bind(SocketAddress var1, int var2) throws IOException {
-    Object var3 = this.lock;
-    synchronized(this.lock) {
-        if(!this.isOpen()) {
-            throw new ClosedChannelException();
-        } else if(this.isBound()) {
-            throw new AlreadyBoundException();
-        } else {
-            InetSocketAddress var4 = var1 == null?new InetSocketAddress(0):Net.checkAddress(var1);
-            SecurityManager var5 = System.getSecurityManager();
-            if(var5 != null) {
-                var5.checkListen(var4.getPort());
-            }
-
-            NetHooks.beforeTcpBind(this.fd, var4.getAddress(), var4.getPort());
-            Net.bind(this.fd, var4.getAddress(), var4.getPort());
-            Net.listen(this.fd, var2 < 1?50:var2);
-            Object var6 = this.stateLock;
-            synchronized(this.stateLock) {
-                this.localAddress = Net.localAddress(this.fd);
-            }
-
-            return this;
-        }
-    }
-}
-```
-该方法属于 Java NIO 层次的，该方法涉及到服务端端口的绑定，端口的监听，这些内容在后续的 Channel 时做详细介绍。
-
-到这里就真正完成了服务端端口的绑定。
+https://blog.csdn.net/chenssy/article/details/78714003
+下面先来一段 Netty 服务端的代码：
+```java
+public class NettyServer {
+
+    public void bind(int port){
+        // 创建EventLoopGroup
+        EventLoopGroup bossGroup = new NioEventLoopGroup();        //创建BOSS线程组 用于服务端接受客户端的连接
+        EventLoopGroup workerGroup = new NioEventLoopGroup();      //创建WORK线程组 用于进行SocketChannel的网络读写
+
+        try {
+            // 创建ServerBootStrap实例
+            // ServerBootstrap 用于启动NIO服务端的辅助启动类，目的是降低服务端的开发复杂度
+            ServerBootstrap b = new ServerBootstrap();
+            // 绑定Reactor线程池
+            b.group(bossGroup, workerGroup)
+                    // 设置并绑定服务端Channel
+                    // 指定所使用的NIO传输的Channel
+                    .channel(NioServerSocketChannel.class)
+                    .option(ChannelOption.SO_BACKLOG, 1024)
+                    .handler(new LoggingServerHandler())
+                    .childHandler(new ChannelInitializer(){
+
+                        @Override
+                        protected void initChannel(Channel ch) throws Exception {
+                            //do something
+                        }
+                    });
+
+            // 绑定端口，同步等待成功
+            ChannelFuture future = b.bind(port).sync();
+            // 等待服务端监听端口关闭
+            future.channel().closeFuture().sync();
+
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            // 优雅地关闭
+            bossGroup.shutdownGracefully();
+            workerGroup.shutdownGracefully();
+        }
+    }
+
+    private class LoggingServerHandler extends ChannelInboundHandlerAdapter{
+        @Override
+        public void channelActive(ChannelHandlerContext ctx) throws Exception {
+            System.out.println("loggin-channelActive");
+        }
+
+        @Override
+        public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
+            System.out.println("loggin-channelRegistered");
+        }
+
+        @Override
+        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+            System.out.println("loggin-handlerAdded");
+        }
+    }
+
+    public static void main(String[] args){
+            new NettyServer().bind(8899);
+    }
+}
+```
+上面代码为 Netty 服务器端的完整代码，在整个服务端代码中会涉及如下几个核心类。
+
+`ServerBootstrap`
+
+ServerBootstrap 为 Netty 服务端的启动辅助类，它提供了一系列的方法用于设置服务端启动相关的参数。
+
+`Channel`
+
+Channel 为 Netty 网络操作抽象类，它定义了一组功能，其提供的 API 大大降低了直接使用 Socket 类的复杂性。当然它也不仅仅只是包括了网络 IO 操作的基本功能，还包括一些与 Netty 框架相关的功能，包括获取该 Channel 的 EventLoop 等等。
+
+`EventLoopGroup`
+
+EventLoopGroup 为 Netty 的 Reactor 线程池，它实际上就是 EventLoop 的容器，而 EventLoop 为 Netty 的核心抽象类，它的主要职责是处理所有注册到本线程多路复用器 Selector 上的 Channel。
+
+`ChannelHandler`
+
+ChannelHandler 作为 Netty 的主要组件，它主要负责 I/O 事件或者 I/O 操作进行拦截和处理，它可以选择性地拦截和处理自己感觉兴趣的事件，也可以透传和终止事件的传递。
+
+`ChannelPipeline`
+
+ChannelPipeline 是 ChannelHandler 链的容器，它负责 ChannelHandler 的管理和事件拦截与调度。每当新建一个 Channel 都会分配一个新的 ChannelPepeline，同时这种关联是永久性的。
+
+### 服务端创建流程
+Netty 服务端创建的时序图，如下（摘自《Netty权威指南（第二版）》）
+
+<div align="center" ><img src="img/20171204211824475.png"></div>
+
+主要步骤为：
+
+1. 创建 ServerBootstrap 实例
+2. 设置并绑定 Reactor 线程池
+3. 设置并绑定服务端 Channel
+4. 创建并初始化 ChannelPipeline
+5. 添加并设置 ChannelHandler
+6. 绑定并启动监听端口
+
+### 服务端源码分析
+
+#### 1、创建两个EventLoopGroup
+```java
+    EventLoopGroup bossGroup = new NioEventLoopGroup();
+    EventLoopGroup workerGroup = new NioEventLoopGroup();
+```
+bossGroup 为 BOSS 线程组，用于服务端接受客户端的连接, workerGroup 为 worker 线程组，用于进行 SocketChannel 的网络读写。当然也可以创建一个并共享。
+#### 2、创建ServerBootstrap实例
+```java
+ServerBootstrap b = new ServerBootstrap();
+```
+ServerBootStrap为Netty服务端的启动引导类，用于帮助用户快速配置、启动服务端服务。提供的方法如下：
+
+| 方法名称	       |  方法描述
+| -------- | --------
+| group	          |  设置 ServerBootstrap 要用的 EventLoopGroup
+| channel	        |  设置将要被实例化的 ServerChannel 类
+| option	        |  实例化的 ServerChannel 的配置项
+| childHandler	  |  设置并添加 ChannelHandler
+| bind	          |  绑定 ServerChannel
+
+
+ServerBootStrap底层采用`装饰者模式`。
+
+#### 3、设置并绑定Reactor线程池
+
+调用 group() 方法，为 ServerBootstrap 实例设置并绑定 Reactor 线程池。
+```java
+b.group(bossGroup, workerGroup)
+```
+EventLoopGroup 为 Netty 线程池，它实际上就是 EventLoop 的数组容器。EventLoop 的职责是处理所有注册到本线程多路复用器 Selector 上的 Channel，Selector 的轮询操作由绑定的 EventLoop 线程 run 方法驱动，在一个循环体内循环执行。通俗点讲就是一个死循环，不断的检测 I/O 事件、处理 I/O 事件。
+
+这里设置了两个group，这个其实有点儿像我们工作一样。需要两类型的工人，一个老板（bossGroup）,一个工人（workerGroup），老板负责从外面接活，工人则负责死命干活。所以这里 bossGroup 的作用就是不断地接收新的连接，接收之后就丢给 workerGroup 来处理，workerGroup 负责干活就行（负责客户端连接的 IO 操作）。
+
+源码如下：
+```java
+public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
+    super.group(parentGroup);        // 绑定boosGroup
+    if (childGroup == null) {
+        throw new NullPointerException("childGroup");
+    }
+    if (this.childGroup != null) {
+        throw new IllegalStateException("childGroup set already");
+    }
+    this.childGroup = childGroup;    // 绑定workerGroup
+    return this;
+}
+```
+其中父 EventLoopGroup 传递到父类的构造函数中：
+```java
+public B group(EventLoopGroup group) {
+    if (group == null) {
+        throw new NullPointerException("group");
+    }
+    if (this.group != null) {
+        throw new IllegalStateException("group set already");
+    }
+    this.group = group;
+    return (B) this;
+}
+```
+#### 4、设置并绑定服务端Channel
+绑定线程池后，则需要设置 channel 类型，服务端用的是 NioServerSocketChannel 。
+```java
+.channel(NioServerSocketChannel.class)
+```
+调用 ServerBootstrap.channel 方法用于设置服务端使用的 Channel，传递一个 NioServerSocketChannel Class对象，Netty通过工厂类，利用反射创建NioServerSocketChannel 对象，如下：
+```java
+public B channel(Class<? extends C> channelClass) {
+    if (channelClass == null) {
+        throw new NullPointerException("channelClass");
+    }
+    return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
+}
+```
+channelFactory() 用于设置 Channel 工厂的：
+```java
+public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
+    return channelFactory((ChannelFactory<C>) channelFactory);
+}
+
+public B channelFactory(ChannelFactory<? extends C> channelFactory) {
+    if (channelFactory == null) {
+        throw new NullPointerException("channelFactory");
+    }
+    if (this.channelFactory != null) {
+        throw new IllegalStateException("channelFactory set already");
+    }
+
+    this.channelFactory = channelFactory;
+    return (B) this;
+}
+```
+这里传递的是 ReflectiveChannelFactory，其源代码如下：
+```java
+public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {
+
+    private final Class<? extends T> clazz;
+
+    public ReflectiveChannelFactory(Class<? extends T> clazz) {
+        if (clazz == null) {
+            throw new NullPointerException("clazz");
+        }
+        this.clazz = clazz;
+    }
+    //需要创建 channel 的时候，该方法将被调用
+    @Override
+    public T newChannel() {
+        try {
+            // 反射创建对应 channel
+            return clazz.newInstance();
+        } catch (Throwable t) {
+            throw new ChannelException("Unable to create Channel from class " + clazz, t);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return StringUtil.simpleClassName(clazz) + ".class";
+    }
+}
+```
+确定服务端的 Channel（NioServerSocketChannel）后，调用 option()方法设置 Channel 参数，作为服务端，主要是设置TCP的backlog参数，如下：
+```java
+.option(ChannelOption.SO_BACKLOG, 1024)
+```
+option()源码如下：
+```java
+public <T> B option(ChannelOption<T> option, T value) {
+    if (option == null) {
+        throw new NullPointerException("option");
+    }
+    if (value == null) {
+        synchronized (options) {
+            options.remove(option);
+        }
+    } else {
+        synchronized (options) {
+            options.put(option, value);
+        }
+    }
+    return (B) this;
+}
+
+private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
+```
+
+#### 五、添加并设置ChannelHandler
+
+设置完 Channel 参数后，用户可以为启动辅助类和其父类分别指定 Handler。
+```java
+ .handler(new LoggingServerHandler())
+.childHandler(new ChannelInitializer(){
+    //省略代码
+})
+```
+这两个 Handler 不一样，前者（handler()）设置的 Handler 是服务端 NioServerSocketChannel的，后者（childHandler()）设置的 Handler 是属于每一个新建的 NioSocketChannel 的。跟踪源代码会发现两种所处的类不一样，handler 位于 AbstractBootstrap 中，childHandler 位于 ServerBootstrap 中，如下：
+```java
+// AbstractBootstrap
+public B handler(ChannelHandler handler) {
+    if (handler == null) {
+        throw new NullPointerException("handler");
+    }
+    this.handler = handler;
+    return (B) this;
+}
+
+// ServerBootstrap
+public ServerBootstrap childHandler(ChannelHandler childHandler) {
+    if (childHandler == null) {
+        throw new NullPointerException("childHandler");
+    }
+    this.childHandler = childHandler;
+    return this;
+}
+```
+ServerBootstrap 中的 Handler 是 NioServerSocketChannel 使用的，所有连接该监听端口的客户端都会执行它，父类 AbstractBootstrap 中的 Handler 是一个工厂类，它为每一个新接入的客户端都创建一个新的 Handler。如下图（《Netty权威指南（第二版）》）：
+<div align="center"><img src="img/20171204211923932.png></div>
+
+### 六、绑定端口，启动服务
+
+服务端最后一步，绑定端口并启动服务，如下：
+```java
+ChannelFuture future = b.bind(port).sync();
+```
+调用 ServerBootstrap 的 bind() 方法进行端口绑定：
+```java
+public ChannelFuture bind(int inetPort) {
+    return bind(new InetSocketAddress(inetPort));
+}
+
+public ChannelFuture bind(SocketAddress localAddress) {
+    validate();
+    if (localAddress == null) {
+        throw new NullPointerException("localAddress");
+    }
+    return doBind(localAddress);
+}    
+```
+首先调用 validate() 方法进行参数校验，然后调用 doBind() 方法：
+```java
+private ChannelFuture doBind(final SocketAddress localAddress) {
+    // 初始化并注册一个Channel
+    final ChannelFuture regFuture = initAndRegister();
+
+    final Channel channel = regFuture.channel();
+    if (regFuture.cause() != null) {
+        return regFuture;
+    }
+
+    // 注册成功
+    if (regFuture.isDone()) {
+        // At this point we know that the registration was complete and successful.
+        ChannelPromise promise = channel.newPromise();
+        // 调用doBind0绑定
+        doBind0(regFuture, channel, localAddress, promise);
+        return promise;
+    } else {
+        // Registration future is almost always fulfilled already, but just in case it's not.
+        final AbstractBootstrap.PendingRegistrationPromise promise = new AbstractBootstrap.PendingRegistrationPromise(channel);
+        regFuture.addListener(new ChannelFutureListener() {
+            @Override
+            public void operationComplete(ChannelFuture future) throws Exception {
+                Throwable cause = future.cause();
+                if (cause != null) {
+                    // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
+                    // IllegalStateException once we try to access the EventLoop of the Channel.
+                    promise.setFailure(cause);
+                } else {
+                    // Registration was successful, so set the correct executor to use.
+                    // See https://github.com/netty/netty/issues/2586
+                    promise.registered();
+
+                    doBind0(regFuture, channel, localAddress, promise);
+                }
+            }
+        });
+        return promise;
+    }
+}
+```
+该方法涉及内容较多，我们分解来看，如下：
+1. 首先通过 initAndRegister() 得到一个 ChannelFuture 对象 regFuture；
+2. 根据得到的 regFuture 对象判断该对象是否抛出异常 （regFuture.cause()），如果是，直接返回；
+3. 根据 regFuture.isDone()判断 initAndRegister()是否执行完毕，如果执行完成，则调用 doBind0；
+4. 若 initAndRegister() 没有执行完毕，则向 regFuture 对象添加一个 ChannelFutureListener 监听，当 initAndRegister() 执行完毕后会调用 operationComplete()，在 operationComplete() 中依然会判断 ChannelFuture 是否抛出异常，如果没有则调用 doBind0进行绑定。
+
+按照上面的步骤我们一步一步来剖析 doBind() 方法。
+
+**initAndRegister()**
+
+执行 initAndRegister() 会得到一个 ChannelFuture 对象 regFuture，代码如下：
+```java
+final ChannelFuture initAndRegister() {
+   Channel channel = null;
+   try {
+       // 新建一个Channel
+       channel = channelFactory.newChannel();
+       // 初始化Channel
+       init(channel);
+   } catch (Throwable t) {
+       if (channel != null) {
+           channel.unsafe().closeForcibly();
+       }
+       return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
+   }
+
+   // /向EventLoopGroup中注册一个channel
+   ChannelFuture regFuture = config().group().register(channel);
+   if (regFuture.cause() != null) {
+       if (channel.isRegistered()) {
+           channel.close();
+       } else {
+           channel.unsafe().closeForcibly();
+       }
+   }
+   return regFuture;
+}
+```
+首先调用 newChannel() 新建一个Channel，这里是NioServerSocketChannel，还记前面 4、设置并绑定服务端Channel（.channel(NioServerSocketChannel.class)）中 设置的Channel工厂类么？在这里派上用处了。在上面提到了通过反射的机制我们可以得到一个 NioServerSocketChannel 类的实例。那么 NioServerSocketChannel 到底是一个什么东西呢？如下图：
+
+20171204211954815.png
+
+上图是 NioServerSocketChannel 的继承体系结构图， NioServerSocketChannel 在构造函数中会依靠父类来完成一项一项的初始化工作。先看 NioServerSocketChannel 构造函数。
+```java
+public NioServerSocketChannel() {
+    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
+}
+```
+该构造函数首先是调用父类的构造方法，然后设置 config属性。父类构造方法如下：
+```java
+// AbstractNioMessageChannel
+protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
+    super(parent, ch, readInterestOp);
+}
+
+// AbstractNioChannel
+protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
+    super(parent);
+    this.ch = ch;
+    this.readInterestOp = readInterestOp;
+    try {
+        ch.configureBlocking(false);
+    } catch (IOException e) {
+        try {
+            ch.close();
+        } catch (IOException e2) {
+            if (logger.isWarnEnabled()) {
+                logger.warn(
+                        "Failed to close a partially initialized socket.", e2);
+            }
+        }
+
+        throw new ChannelException("Failed to enter non-blocking mode.", e);
+    }
+}
+
+// AbstractChannel
+protected AbstractChannel(Channel parent) {
+    this.parent = parent;
+    id = newId();
+    unsafe = newUnsafe();
+    pipeline = newChannelPipeline();
+}
+```
+通过 super() ，一层一层往上，直到 AbstractChannel。我们从最上层解析。
+
+* AbstractChannel 设置了 unsafe (unsafe = newUnsafe())和 pipeline(pipeline = newChannelPipeline())；
+* AbstractNioChannel 将当前 ServerSocketChannel 设置成了非阻塞（ch.configureBlocking(false);），同时设置SelectionKey.OP_ACCEPT事件(this.readInterestOp = readInterestOp; readInterestOp 值由 NioServerSocketChannel 中传递)；
+* NioServerSocketChannel 设置 config属性（config = new NioServerSocketChannelConfig(this, javaChannel().socket())）。
+所以 channel = channelFactory.newChannel() 通过反射机制产生了 NioServerSocketChannel 类实例。同时该实例设置了NioMessageUnsafe、DefaultChannelPipeline、非阻塞、SelectionKey.OP_ACCEPT事件 和 NioServerSocketChannelConfig 属性。
+
+看完了 channelFactory.newChannel();，我们再看 init()。
+```java
+void init(Channel channel) throws Exception {
+     // 设置配置的option参数
+    final Map<ChannelOption<?>, Object> options = options0();
+    synchronized (options) {
+        channel.config().setOptions(options);
+    }
+
+    final Map<AttributeKey<?>, Object> attrs = attrs0();
+    synchronized (attrs) {
+        for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
+            @SuppressWarnings("unchecked")
+            AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
+            channel.attr(key).set(e.getValue());
+        }
+    }
+
+    // 获取绑定的pipeline
+    ChannelPipeline p = channel.pipeline();
+
+    // 准备child用到的4个part
+    final EventLoopGroup currentChildGroup = childGroup;
+    final ChannelHandler currentChildHandler = childHandler;
+    final Entry<ChannelOption<?>, Object>[] currentChildOptions;
+    final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
+    synchronized (childOptions) {
+        currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
+    }
+    synchronized (childAttrs) {
+        currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
+    }
+
+    // 为NioServerSocketChannel的pipeline添加一个初始化Handler,
+    // 当NioServerSocketChannel在EventLoop注册成功时，该handler的init方法将被调用
+    p.addLast(new ChannelInitializer<Channel>() {
+        @Override
+        public void initChannel(Channel ch) throws Exception {
+            final ChannelPipeline pipeline = ch.pipeline();
+            ChannelHandler handler = config.handler();
+            //如果用户配置过Handler
+            if (handler != null) {
+                pipeline.addLast(handler);
+            }
+
+            ch.eventLoop().execute(new Runnable() {
+                @Override
+                public void run() {
+                    // 为NioServerSocketChannel的pipeline添加ServerBootstrapAcceptor处理器
+                    // 该Handler主要用来将新创建的NioSocketChannel注册到EventLoopGroup中
+                    pipeline.addLast(new ServerBootstrapAcceptor(
+                            currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
+                }
+            });
+        }
+    });
+}
+```
+其实整个过程可以分为三个步骤：
+
+1. 设置 Channel 的 option 和 attr；
+2. 获取绑定的 pipeline，然后为 NioServerSocketChanne l绑定的 pipeline 添加 Handler；
+3. 将用于服务端注册的 Handler ServerBootstrapAcceptor 添加到 ChannelPipeline 中。ServerBootstrapAcceptor 为一个接入器，专门接受新请求，把新的请求扔给某个事件循环器。
+
+至此初始化部分已经结束，我们再看注册部分，
+```java
+// /向EventLoopGroup中注册一个channel
+       ChannelFuture regFuture = config().group().register(channel);
+```
+注册方法的调用位于 initAndRegister() 方法中。注意这里的 group() 返回的是前面的 boss NioEvenLoopGroup，它继承 MultithreadEventLoopGroup，调用的 register()，也是 MultithreadEventLoopGroup 中的。如下：
+```java
+public ChannelFuture register(Channel channel) {
+    return next().register(channel);
+}
+```
+调用 next() 方法从 EventLoopGroup 中获取下一个 EventLoop，调用 register() 方法注册：
+```java
+public ChannelFuture register(Channel channel) {
+    return register(new DefaultChannelPromise(channel, this));
+}
+```
+将Channel和EventLoop封装成一个DefaultChannelPromise对象，然后调用register()方法。DefaultChannelPromis为ChannelPromise的默认实现，而ChannelPromisee继承Future，具备异步执行结构，绑定Channel，所以又具备了监听的能力，故而ChannelPromis是Netty异步执行的核心接口。
+```java
+public ChannelFuture register(ChannelPromise promise) {
+    ObjectUtil.checkNotNull(promise, "promise");
+    promise.channel().unsafe().register(this, promise);
+    return promise;
+}
+``
+首先获取 channel 的 unsafe 对象，该 unsafe 对象就是在之前设置过得。然后调用 register() 方法，如下：
+```java
+public final void register(EventLoop eventLoop, final ChannelPromise promise) {
+    if (eventLoop == null) {
+        throw new NullPointerException("eventLoop");
+    }
+    if (isRegistered()) {
+        promise.setFailure(new IllegalStateException("registered to an event loop already"));
+        return;
+    }
+    if (!isCompatible(eventLoop)) {
+        promise.setFailure(
+                new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
+        return;
+    }
+
+    AbstractChannel.this.eventLoop = eventLoop;
+
+    // 必须要保证注册是由该EventLoop发起的
+    if (eventLoop.inEventLoop()) {
+        register0(promise);        // 注册
+    } else {
+        // 如果不是单独封装成一个task异步执行
+        try {
+            eventLoop.execute(new Runnable() {
+                @Override
+                public void run() {
+                    register0(promise);
+                }
+            });
+        } catch (Throwable t) {
+            logger.warn(
+                    "Force-closing a channel whose registration task was not accepted by an event loop: {}",
+                    AbstractChannel.this, t);
+            closeForcibly();
+            closeFuture.setClosed();
+            safeSetFailure(promise, t);
+        }
+    }
+}
+```
+过程如下：
+1. 首先通过isRegistered() 判断该 Channel 是否已经注册到 EventLoop 中；
+2. 通过 eventLoop.inEventLoop() 来判断当前线程是否为该 EventLoop 自身发起的，如果是，则调用 register0() 直接注册；
+3. 如果不是，说明该 EventLoop 中的线程此时没有执行权，则需要新建一个线程，单独封装一个 Task，而该 Task 的主要任务则是执行 register0()。
+
+无论当前 EventLoop 的线程是否拥有执行权，最终都会要执行 register0()，如下：
+```java
+private void register0(ChannelPromise promise) {
+    try {
+        // 确保 Channel 处于 open
+        if (!promise.setUncancellable() || !ensureOpen(promise)) {
+            return;
+        }
+        boolean firstRegistration = neverRegistered;
+
+        // 真正的注册动作
+        doRegister();
+
+        neverRegistered = false;
+        registered = true;        
+
+        pipeline.invokeHandlerAddedIfNeeded();    
+        safeSetSuccess(promise);        //设置注册结果为成功
+
+        pipeline.fireChannelRegistered();
+
+        if (isActive()) {
+            //如果是首次注册,发起 pipeline 的 fireChannelActive
+            if (firstRegistration) {
+                pipeline.fireChannelActive();
+            } else if (config().isAutoRead()) {
+                beginRead();
+            }
+        }
+    } catch (Throwable t) {
+        closeForcibly();
+        closeFuture.setClosed();
+        safeSetFailure(promise, t);
+    }
+}
+```
+如果 Channel 处于 open 状态，则调用 doRegister() 方法完成注册，然后将注册结果设置为成功。最后判断如果是首次注册且处于激活状态，则发起 pipeline 的 fireChannelActive()。
+```java
+protected void doRegister() throws Exception {
+    boolean selected = false;
+    for (;;) {
+        try {
+            // 注册到NIOEventLoop的Selector上
+            selectionKey = javaChannel().register(eventLoop().selector, 0, this);
+            return;
+        } catch (CancelledKeyException e) {
+            if (!selected) {
+                eventLoop().selectNow();
+                selected = true;
+            } else {
+                throw e;
+            }
+        }
+    }
+}
+```
+这里注册时 ops 设置的是 0，也就是说 ServerSocketChannel 仅仅只是表示了注册成功，还不能监听任何网络操作，这样做的目的是（摘自《Netty权威指南（第二版）》）：
+
+1. 注册方式是多态的，它既可以被 NIOServerSocketChannel 用来监听客户端的连接接入，也可以注册 SocketChannel 用来监听网络读或者写操作。
+2. 通过 SelectionKey.interestOps(int ops) 方法可以方便地修改监听操作位。所以，此处注册需要获取 SelectionKey 并给 AbstractNIOChannel 的成员变量 selectionKey 赋值。
+
+由于这里 ops 设置为 0，所以还不能监听读写事件。调用 doRegister()后，然后调用pipeline.invokeHandlerAddedIfNeeded();，这个时候控制台会出现 loggin-handlerAdded，内部如何调用，我们在剖析 pipeline 时再做详细分析。然后将注册结果设置为成功（safeSetSuccess(promise)）。调用 pipeline.fireChannelRegistered(); 这个时候控制台会打印 loggin-channelRegistered。这里简单分析下该方法。
+```java
+public final ChannelPipeline fireChannelRegistered() {
+       AbstractChannelHandlerContext.invokeChannelRegistered(head);
+       return this;
+   }
+
+   static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
+       EventExecutor executor = next.executor();
+       if (executor.inEventLoop()) {
+           next.invokeChannelRegistered();
+       } else {
+           executor.execute(new Runnable() {
+               @Override
+               public void run() {
+                   next.invokeChannelRegistered();
+               }
+           });
+       }
+   }
+```
+pipeline 维护着 handle 链表，事件会在 NioServerSocketChannel 的 pipeline 中传播。最终都会调用 next.invokeChannelRegistered()，如下：
+```java
+private void invokeChannelRegistered() {
+    if (invokeHandler()) {
+        try {
+            ((ChannelInboundHandler) handler()).channelRegistered(this);
+        } catch (Throwable t) {
+            notifyHandlerException(t);
+        }
+    } else {
+        fireChannelRegistered();
+    }
+}
+```
+在 invokeChannelRegistered() 会调用我们在前面设置的 handler （还记得签名的 handler(new LoggingServerHandler() )么）的 channelRegistered()，这个时候控制台应该会打印 loggin-channelRegistered。
+
+到这里initAndRegister() (final ChannelFuture regFuture = initAndRegister();)就分析完毕了，该方法主要做如下三件事：
+1. 通过反射产生了一个 NioServerSocketChannle 对象；
+2. 调用 init(channel)完成初始化工作；
+3. 将NioServerSocketChannel进行了注册。
+
+initAndRegister()篇幅较长，分析完毕了，我们再返回到doBind(final SocketAddress localAddress)。在 doBind(final SocketAddress localAddress) 中如果 initAndRegister()执行完成，则 regFuture.isDone() 则为 true，执行 doBind0()。如果没有执行完成，则会注册一个监听 ChannelFutureListener，当 initAndRegister() 完成后，会调用该监听的 operationComplete()方法，最终目的还是执行 doBind0()。故而我们下面分析 doBind0()到底做了些什么。源码如下：
+```java
+private static void doBind0(
+        final ChannelFuture regFuture, final Channel channel,
+        final SocketAddress localAddress, final ChannelPromise promise) {
+
+    channel.eventLoop().execute(new Runnable() {
+        @Override
+        public void run() {
+            if (regFuture.isSuccess()) {
+                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
+            } else {
+                promise.setFailure(regFuture.cause());
+            }
+        }
+    });
+}
+```
+    doBind0() 较为简单，首先new 一个线程 task，然后将该任务提交到 NioEventLoop 中进行处理，我们先看 execute()。
+```java
+public void execute(Runnable task) {
+    if (task == null) {
+        throw new NullPointerException("task");
+    }
+
+    boolean inEventLoop = inEventLoop();
+    if (inEventLoop) {
+        addTask(task);
+    } else {
+        startThread();
+        addTask(task);
+        if (isShutdown() && removeTask(task)) {
+            reject();
+        }
+    }
+
+    if (!addTaskWakesUp && wakesUpForTask(task)) {
+        wakeup(inEventLoop);
+    }
+}
+```
+调用 inEventLoop() 判断当前线程是否为该 NioEventLoop 所关联的线程，如果是，则调用 addTask() 将任务 task 添加到队列中，如果不是，则先启动线程，在调用 addTask() 将任务 task 添加到队列中。addTask() 如下：
+```java
+protected void addTask(Runnable task) {
+    if (task == null) {
+        throw new NullPointerException("task");
+    }
+    if (!offerTask(task)) {
+        reject(task);
+    }
+}
+```
+offerTask()添加到队列中：
+```java
+final boolean offerTask(Runnable task) {
+    if (isShutdown()) {
+        reject();
+    }
+    return taskQueue.offer(task);
+}
+```
+task 添加到任务队列 taskQueue成功后，执行任务会调用如下方法：
+```java
+channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
+```
+channel 首先调用 bind() 完成 channel 与端口的绑定，如下：
+```java
+public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
+    return pipeline.bind(localAddress, promise);
+}
+
+public final ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
+    return tail.bind(localAddress, promise);
+}
+```
+tail 在 DefaultChannelPipeline 中定义：final AbstractChannelHandlerContext tail; 有 tail 就会有 head ，在 DefaultChannelPipeline 中维护这一个 AbstractChannelHandlerContext 节点的双向链表，该链表是实现 Pipeline 机制的关键，更多详情会在 ChannelPipeline 中做详细说明。bind() 最终会调用 DefaultChannelPipeline 的 bind() 方法。如下：
+```java
+public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
+    if (localAddress == null) {
+        throw new NullPointerException("localAddress");
+    }
+    if (!validatePromise(promise, false)) {
+        // cancelled
+        return promise;
+    }
+
+    final AbstractChannelHandlerContext next = findContextOutbound();
+    EventExecutor executor = next.executor();
+    if (executor.inEventLoop()) {
+        next.invokeBind(localAddress, promise);
+    } else {
+        safeExecute(executor, new Runnable() {
+            @Override
+            public void run() {
+                next.invokeBind(localAddress, promise);
+            }
+        }, promise, null);
+    }
+    return promise;
+}
+```
+首先对 localAddress 、 promise 进行校验，符合规范则调用 findContextOutbound() ，该方法用于在 pipeline 中获取 AbstractChannelHandlerContext 双向链表中的一个节点，如下：
+```java
+private AbstractChannelHandlerContext findContextOutbound() {
+    AbstractChannelHandlerContext ctx = this;
+    do {
+        ctx = ctx.prev;
+    } while (!ctx.outbound);
+    return ctx;
+}
+```
+从该方法可以看出，所获取的节点是从 tail 开始遍历，获取第一个节点属性 outbound 为 true 的节点。其实该节点是 AbstractChannelHandlerContext 双向链表的 head 节点。获取该节点后，调用 invokeBind()，如下：
+```java
+private void invokeBind(SocketAddress localAddress, ChannelPromise promise) {
+    if (invokeHandler()) {
+        try {
+            ((ChannelOutboundHandler) handler()).bind(this, localAddress, promise);
+        } catch (Throwable t) {
+            notifyOutboundHandlerException(t, promise);
+        }
+    } else {
+        bind(localAddress, promise);
+    }
+}
+```
+handler() 返回的是 HeadContext 对象，然后调用其bind()，如下：
+```java
+public void bind(
+        ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
+        throws Exception {
+    unsafe.bind(localAddress, promise);
+}
+```
+unsafe 定义在 HeadContext 中，在构造函数中初始化（unsafe = pipeline.channel().unsafe();），调用 bind() 如下：
+```java
+public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
+    assertEventLoop();
+
+    if (!promise.setUncancellable() || !ensureOpen(promise)) {
+        return;
+    }
+
+    if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
+        localAddress instanceof InetSocketAddress &&
+        !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
+        !PlatformDependent.isWindows() && !PlatformDependent.isRoot()) {
+
+        logger.warn(
+                "A non-root user can't receive a broadcast packet if the socket " +
+                "is not bound to a wildcard address; binding to a non-wildcard " +
+                "address (" + localAddress + ") anyway as requested.");
+    }
+
+    boolean wasActive = isActive();
+    try {
+        // 最核心方法
+        doBind(localAddress);
+    } catch (Throwable t) {
+        safeSetFailure(promise, t);
+        closeIfClosed();
+        return;
+    }
+
+    if (!wasActive && isActive()) {
+        invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                pipeline.fireChannelActive();
+            }
+        });
+    }
+
+    safeSetSuccess(promise);
+}
+```
+内部调用 doBind() ，该方法为绑定中最核心的方法，位于 NioServerSocketChannel 中，如下：
+```java
+protected void doBind(SocketAddress localAddress) throws Exception {
+    if (PlatformDependent.javaVersion() >= 7) {
+        javaChannel().bind(localAddress, config.getBacklog());
+    } else {
+        javaChannel().socket().bind(localAddress, config.getBacklog());
+    }
+}
+```
+javaChannel()返回的是 NioServerSocketChannel 实例初始化时所产生的 Java NIO ServerSocketChannel 实例（ServerSocketChannelImple实例），然后调用其 bind()，如下：
+```java
+public ServerSocketChannel bind(SocketAddress var1, int var2) throws IOException {
+    Object var3 = this.lock;
+    synchronized(this.lock) {
+        if(!this.isOpen()) {
+            throw new ClosedChannelException();
+        } else if(this.isBound()) {
+            throw new AlreadyBoundException();
+        } else {
+            InetSocketAddress var4 = var1 == null?new InetSocketAddress(0):Net.checkAddress(var1);
+            SecurityManager var5 = System.getSecurityManager();
+            if(var5 != null) {
+                var5.checkListen(var4.getPort());
+            }
+
+            NetHooks.beforeTcpBind(this.fd, var4.getAddress(), var4.getPort());
+            Net.bind(this.fd, var4.getAddress(), var4.getPort());
+            Net.listen(this.fd, var2 < 1?50:var2);
+            Object var6 = this.stateLock;
+            synchronized(this.stateLock) {
+                this.localAddress = Net.localAddress(this.fd);
+            }
+
+            return this;
+        }
+    }
+}
+```
+该方法属于 Java NIO 层次的，该方法涉及到服务端端口的绑定，端口的监听，这些内容在后续的 Channel 时做详细介绍。
+
+到这里就真正完成了服务端端口的绑定。
diff --git "a/04 - Middleware/netty/\346\240\270\345\277\203.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/netty/\346\240\270\345\277\203.md"
similarity index 100%
rename from "04 - Middleware/netty/\346\240\270\345\277\203.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/netty/\346\240\270\345\277\203.md"
diff --git "a/04 - Middleware/redis/Redis\346\225\260\346\215\256\347\273\223\346\236\204\345\217\212\345\221\275\344\273\244.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/Redis\346\225\260\346\215\256\347\273\223\346\236\204\345\217\212\345\221\275\344\273\244.md"
similarity index 97%
rename from "04 - Middleware/redis/Redis\346\225\260\346\215\256\347\273\223\346\236\204\345\217\212\345\221\275\344\273\244.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/Redis\346\225\260\346\215\256\347\273\223\346\236\204\345\217\212\345\221\275\344\273\244.md"
index 85cbbb56..957fcc29 100644
--- "a/04 - Middleware/redis/Redis\346\225\260\346\215\256\347\273\223\346\236\204\345\217\212\345\221\275\344\273\244.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/Redis\346\225\260\346\215\256\347\273\223\346\236\204\345\217\212\345\221\275\344\273\244.md"	
@@ -1,202 +1,202 @@
-Redis是远程字典服务器，字典的值所支持的数据类型：
-
-1. 字符串类型 `string`
-2. 散列类型 `hashs`
-3. 列表类型 `list`
-4. 集合类型 `set`
-5. 有序集合类型 `zset`(sorted set)
-
-[http://www.redis.net.cn/order/](http://www.redis.net.cn/order/)
-
-### Redis命令
-
-`dbsize`：获取redis中键的总数
-redis提供了多个用来存储数据的字典，一个字典相当于传统数据库系统一个数据库实例中可以创建多个数据库类型。redis默认支持16个数据库，也就是说16个字典，这个数值是可以配置的。默认客户端自动选择0号数据库。数据库之间不是完全隔离的，Flushall会清空redis实例中所有数据库。
-
-`select`：用于切换数据库 如：select 1 表示切换到1号数据库。
-
-`keys`：获取符合规则的键名列表，支持通配符，不支持正则表达式。出于性能考虑一般很少在生产环境使用。
-
-	？匹配一个字符
-	* 匹配任意字符（包括0）
-	[] 区间，比如a[b-d]可以匹配ab,ac,ad
-	\x 转义字符，比如匹配？可以使用 ?
-
-### 1. 字符串类型
-
-	当存储的字符串类型是整数形式时，可以对其进行递增操作，
-	比如：set age 1，incr age，返回递增后的值，递增操作是原子操作。
-
-`set`：设置字符串值，比如：set name liu，表示键为name，值为liu
-
-`get`：获取键值，比如：get name
-
-`exists`：判断是否存在某键，比如：exists name，存在返回1，不存在返回0
-
-`del`：删除键，比如：del name，一次可以删除多个键，比如：del name age ，成功删除返回1，如果删除时该键不存在，那么返回0
-
-`type`：获取键对应值的数据类型，比如：type name ，返回string，如果是：lpush bar 1，type bar 返回list。
-
-`incrby`：增加指定的整数，比如：incrby age 10，表示在当前值上加10，与之对应的递减的两个命令是：
-
-`decr`：递减
-
-`decrby`：减少指定整数
-
-`incrbyfloat`：增加指定浮点数
-
-`append`：向尾部追加值，append name zhijun，返回追加后字符串的长度，这个命令尽作用与字符串类型
-
-`strlen`：获取字符串长度
-
-`mset`：一次设置多个键值，比如：mset name liu age 2
-
-`mget`：一次获取多个键的值，比如：mget name get
-
-以上命令都是针对字符串类型的值进行操作的命令，接下来是hash类型的值的命令。
-
-### 2. hash类型，散列类型，字典类型
-
-	hash类型是以键值对的形式存在的，而且hash类型的的值只能是字符串，不能再嵌套其他类型
-	redis所有的数据类型都遵循此规则。
-
-`hset`：赋值，比如：hset person name liu，key是person，value是{name:liu}。
-
-`hget`：获取值，比如：hget person name，必须指定hash类型的键名，比如前面的name
-
-	HGET KEY_NAME FIELD_NAME
-
-`hmset`：多个字段赋值，比如：hmset person name liu age 10
-
-`hmget`：获取多个字段的值，比如：hmget person name age
-
-`hgetall`：获取hash的键值对，比如：hgetall person，这里就不需要指定hash的键名了。
-
-`hexists`：判断字段是否存在，比如：hexists person name，表示是否有name字段。
-
-`hincrby`：递增字段值，如果是数值类型的字符串的话，比如：hincrby person age 20
-
-`hdel`：删除字段，hdel person name
-
-`hkeys`：只获取字段名 hkeys person
-
-`hvals`：只获取字段值 hvals person
-
-`hlen`：获取有多少个字段，hlen person 以上这些命令的基本规律就是在字符串类型的命令上加个H
-
-### 3. 列表类型
-
-	列表类型是一个双向链表实现的，越接近链表两端的元素获取速度越快，
-	因此非常适合做TimeLine的实现。
-	还可以做队列使用。
-	但是列表在数据量非常大的时候获取中间元素时效率不高。
-
-`lpush`：向列表的左边添加元素，返回列表的长度，比如：lpush names zhangsan lisi wangwu，一次可以添加多个元素。注意：字典的key对应的键值的类型不能随意变更，比如：set name zhang，不能再使用lpush name zhang li。
-
-`rpush`：向列表右边添加元素
-
-`lpop`：从列表左边取出元素，先移除列表中的元素，在返回该元素
-
-`rpop`：从列表右边取出元素，先移除列表中的元素，在返回该元素
-
-`llen`：获取列表长度
-
-`lrange`：分片操作，获取列表的片段，语法：lrange key start stop，元素包括stop位置的，与python稍有不一样。比如：lrange names 0 2，会获取三个元素，-1表示最后一个元素，获取所有就可以使用lrange names 0 -1。
-
-`lram`：删除列表中指定值，语法：lram key count value，删除列表中前count个值为value的元素，返回删除元素的个数。
-
-`count>0`：从列表左边开始删除前count个值为value的元素。
-
-`count<0`：从列表右边开始往左删除前-count个值为value的元素，比如：lrem names -1 li，表示从右边开始删除1个值为li的元素。
-
-`count=0`：删除所有值为value的元素
-
-`lindex`：获取指定索引位置的元素，语法：lindex key index，也可以使用lrange实现此功能。
-
-`lset`：设置指定索引位置的值，语法：lset key index value。注意这里是替换索引位置的值，如果索引不存在是没法操作的。
-
-`ltrim`：只保留列表指定范围内的元素，语法：ltrim key start end。此操作是对列表进行修改.
-
-### 4. 集合类型
-
-	集合类型在Redis内部是用值为空的散列表实现的。集合之间可以进行交集、并集、差集操作。
-
-`sadd`：向集合中添加一个或多个元素，如果键不存在则自动创建，语法：sadd key member1 member2 ...例如：sadd tags python java c++
-
-`srem`：删除集合中的某些元素，语法：srem key member1 member2...，例如：srem tags python java
-
-`smemebers`：获取集合中所有元素 smembers tags
-
-`sismember`：判断元素是否在集合中 sismembers tags python，时间复杂度为O(1)。
-
-`sdiff`：多个集合的差集运算，语法：sdiff key1 key2
-
-`sinter`：交集运算
-
-`sunion`：并集运算
-
-`scard`：获取元素个数
-
-### 5. 有序集合类型
-
-	有序集合的每个元素都有一个分数，它不仅有插入、删除、是否存在元素的操作外
-	还支持获取得分最高或最低的前N个元素、获取指定分数范围内的元素。
-
-`zadd` 添加，如果值存在添加，将会重新排序。
-
-	127.0.0.1:6379> ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN
-
-`zcard` 查看zset集合的成员个数。zcard
-
-	127.0.0.1:6379>zcard myZSet   ---输出zset的成员个数为3
-
-`zrange` 查看Zset指定范围的成员，withscores为输出结果带分数。
-
-	127.0.0.1:6379>zrange mZySet 0 -1   ----0为开始，-1为结束，输出顺序结果为： zlh tom jim
-	127.0.0.1:6379>zrange mZySet 0 -1 withscores   ---输出带分数的结果为：zlh 1 tom 2 jim 3
-
-`zrank` 获取zset成员的下标位置，如果值不存在返回null。
-
-	127.0.0.1:6379>zrank mZySet Jim    ---Jim的在zset集合中的下标为2
-
-`zcount` 获取zset集合指定分数之间存在的成员个数。
-
-	127.0.0.1:6379>zcount mySet 1 3   ---输出分数>=1 and 分数 <=3的成员个数为3，因为分数是可以重复的，所以这个命令是有道理的。
-
-`zrem`删除指定的一个成员或多个成员。
-
-	127.0.0.1:6379>zrem myZSet zlh   --删除值为zlh的zset成员
-	127.0.0.1:6379>zrem myZSet Tom Jim    ---删除值为Tom和Jim的两个zset成员
-
-`zscore` 获取指定值的分数。
-
-	127.0.0.1:6379>zadd myZset 1 zlh 1 tom 2 jim 3 xdd 4 pmm   ---由于上面的数据被删除完了，这里添加5条示范数据再。
-	127.0.0.1:6379>zscore myZset zlh    ---输出值为zlh的分数为1
-
-`zincrby`给指定元素的分数进行增减操作，负值为减，正值为加。
-
-	127.0.0.1:6379>zscore myZset tom    ----输出tom的分数为1
-	127.0.0.1:6379>zincrby myZset 4 tom   ---tom的分数值加4，输入分数值为5
-	127.0.0.1:6379>zscore myZset tom    ---输出tom的分数值为5
-
-`zrangebysocre` 根据指定分数的范围获取值。
-
-	127.0.0.1:6379>zrangebyscore myZset  1 5   ---输出分数>=1 and <=5的成员值为：zlh jim xdd pmm  tom
-	127.0.0.1:6379>zrangebyscore myZset  (1 5    ----输出分数>1 and <=5的成员值为：jim xdd pmm tom
-	127.0.0.1:6379>zrangebyscore myZset 2 5 limit 1 2    ---检索分数为2到5之间的数据，然后从下标为1的数据开始往后输出2个数据，包含下标为1的数据。结果为：xdd pmm
-	127.0.0.1:6379>zrangebyscore myZset -inf +inf limit 2 3   ----+inf表示最后一个成员，-inf表示第一个成员，意思是：检索所有数据，然后从下标为2的数据开始再往后输出2个数据。结果为：xdd pmm tom
-
-`zrevrange，zrevrangebyscore`倒序，从高到底排序输出指定范围的数据。
-
-	127.0.0.1:6379>zrevrange myZset 2 3   ---先倒序排列数据，输出下标为>=2 and <=3的数据为xdd jim，这里注意的是倒序之后下标也反过来了。
-	127.0.0.1:6379>zrevrange myZset 2 4 withscores    ---输出结果为：xdd 3 jim 2 zlh 1
-	127.0.0.1:6379>zrevrangebyscore myZset 5 1 limit  3 2  ----输出结果为：jim zlh 。获取score <=5 and >=1，从下标为为3开始获取2条数据。
-	127.0.0.1:6379>zrevrangebyscore myZset 4 2   ----分数>=2 and <=4 的数据倒序输出：pmm xdd jim
-
-`zremrangebyscore，zremrangebyrank`根据坐标，分数范围删除数据。
-
-
-	127.0.0.1:6379>zremrangebyscore myZset 1 2   ---删除分数>=1 and <=2的数据
-	127.0.0.1:6379>zrange myZset 0 -1    ----输出结果为 xdd pmm tom
-	127.0.0.1:6379>zremrangebyrank myZset 0 2    ---删除下标>=0 and <=2的zset元素
-	127.0.0.1:6379>zrange myZset 0 -1    --输出结果为：empty list or set 。没数据啦。
+Redis是远程字典服务器，字典的值所支持的数据类型：
+
+1. 字符串类型 `string`
+2. 散列类型 `hashs`
+3. 列表类型 `list`
+4. 集合类型 `set`
+5. 有序集合类型 `zset`(sorted set)
+
+[http://www.redis.net.cn/order/](http://www.redis.net.cn/order/)
+
+### Redis命令
+
+`dbsize`：获取redis中键的总数
+redis提供了多个用来存储数据的字典，一个字典相当于传统数据库系统一个数据库实例中可以创建多个数据库类型。redis默认支持16个数据库，也就是说16个字典，这个数值是可以配置的。默认客户端自动选择0号数据库。数据库之间不是完全隔离的，Flushall会清空redis实例中所有数据库。
+
+`select`：用于切换数据库 如：select 1 表示切换到1号数据库。
+
+`keys`：获取符合规则的键名列表，支持通配符，不支持正则表达式。出于性能考虑一般很少在生产环境使用。
+
+	？匹配一个字符
+	* 匹配任意字符（包括0）
+	[] 区间，比如a[b-d]可以匹配ab,ac,ad
+	\x 转义字符，比如匹配？可以使用 ?
+
+### 1. 字符串类型
+
+	当存储的字符串类型是整数形式时，可以对其进行递增操作，
+	比如：set age 1，incr age，返回递增后的值，递增操作是原子操作。
+
+`set`：设置字符串值，比如：set name liu，表示键为name，值为liu
+
+`get`：获取键值，比如：get name
+
+`exists`：判断是否存在某键，比如：exists name，存在返回1，不存在返回0
+
+`del`：删除键，比如：del name，一次可以删除多个键，比如：del name age ，成功删除返回1，如果删除时该键不存在，那么返回0
+
+`type`：获取键对应值的数据类型，比如：type name ，返回string，如果是：lpush bar 1，type bar 返回list。
+
+`incrby`：增加指定的整数，比如：incrby age 10，表示在当前值上加10，与之对应的递减的两个命令是：
+
+`decr`：递减
+
+`decrby`：减少指定整数
+
+`incrbyfloat`：增加指定浮点数
+
+`append`：向尾部追加值，append name zhijun，返回追加后字符串的长度，这个命令尽作用与字符串类型
+
+`strlen`：获取字符串长度
+
+`mset`：一次设置多个键值，比如：mset name liu age 2
+
+`mget`：一次获取多个键的值，比如：mget name get
+
+以上命令都是针对字符串类型的值进行操作的命令，接下来是hash类型的值的命令。
+
+### 2. hash类型，散列类型，字典类型
+
+	hash类型是以键值对的形式存在的，而且hash类型的的值只能是字符串，不能再嵌套其他类型
+	redis所有的数据类型都遵循此规则。
+
+`hset`：赋值，比如：hset person name liu，key是person，value是{name:liu}。
+
+`hget`：获取值，比如：hget person name，必须指定hash类型的键名，比如前面的name
+
+	HGET KEY_NAME FIELD_NAME
+
+`hmset`：多个字段赋值，比如：hmset person name liu age 10
+
+`hmget`：获取多个字段的值，比如：hmget person name age
+
+`hgetall`：获取hash的键值对，比如：hgetall person，这里就不需要指定hash的键名了。
+
+`hexists`：判断字段是否存在，比如：hexists person name，表示是否有name字段。
+
+`hincrby`：递增字段值，如果是数值类型的字符串的话，比如：hincrby person age 20
+
+`hdel`：删除字段，hdel person name
+
+`hkeys`：只获取字段名 hkeys person
+
+`hvals`：只获取字段值 hvals person
+
+`hlen`：获取有多少个字段，hlen person 以上这些命令的基本规律就是在字符串类型的命令上加个H
+
+### 3. 列表类型
+
+	列表类型是一个双向链表实现的，越接近链表两端的元素获取速度越快，
+	因此非常适合做TimeLine的实现。
+	还可以做队列使用。
+	但是列表在数据量非常大的时候获取中间元素时效率不高。
+
+`lpush`：向列表的左边添加元素，返回列表的长度，比如：lpush names zhangsan lisi wangwu，一次可以添加多个元素。注意：字典的key对应的键值的类型不能随意变更，比如：set name zhang，不能再使用lpush name zhang li。
+
+`rpush`：向列表右边添加元素
+
+`lpop`：从列表左边取出元素，先移除列表中的元素，在返回该元素
+
+`rpop`：从列表右边取出元素，先移除列表中的元素，在返回该元素
+
+`llen`：获取列表长度
+
+`lrange`：分片操作，获取列表的片段，语法：lrange key start stop，元素包括stop位置的，与python稍有不一样。比如：lrange names 0 2，会获取三个元素，-1表示最后一个元素，获取所有就可以使用lrange names 0 -1。
+
+`lram`：删除列表中指定值，语法：lram key count value，删除列表中前count个值为value的元素，返回删除元素的个数。
+
+`count>0`：从列表左边开始删除前count个值为value的元素。
+
+`count<0`：从列表右边开始往左删除前-count个值为value的元素，比如：lrem names -1 li，表示从右边开始删除1个值为li的元素。
+
+`count=0`：删除所有值为value的元素
+
+`lindex`：获取指定索引位置的元素，语法：lindex key index，也可以使用lrange实现此功能。
+
+`lset`：设置指定索引位置的值，语法：lset key index value。注意这里是替换索引位置的值，如果索引不存在是没法操作的。
+
+`ltrim`：只保留列表指定范围内的元素，语法：ltrim key start end。此操作是对列表进行修改.
+
+### 4. 集合类型
+
+	集合类型在Redis内部是用值为空的散列表实现的。集合之间可以进行交集、并集、差集操作。
+
+`sadd`：向集合中添加一个或多个元素，如果键不存在则自动创建，语法：sadd key member1 member2 ...例如：sadd tags python java c++
+
+`srem`：删除集合中的某些元素，语法：srem key member1 member2...，例如：srem tags python java
+
+`smemebers`：获取集合中所有元素 smembers tags
+
+`sismember`：判断元素是否在集合中 sismembers tags python，时间复杂度为O(1)。
+
+`sdiff`：多个集合的差集运算，语法：sdiff key1 key2
+
+`sinter`：交集运算
+
+`sunion`：并集运算
+
+`scard`：获取元素个数
+
+### 5. 有序集合类型
+
+	有序集合的每个元素都有一个分数，它不仅有插入、删除、是否存在元素的操作外
+	还支持获取得分最高或最低的前N个元素、获取指定分数范围内的元素。
+
+`zadd` 添加，如果值存在添加，将会重新排序。
+
+	127.0.0.1:6379> ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN
+
+`zcard` 查看zset集合的成员个数。zcard
+
+	127.0.0.1:6379>zcard myZSet   ---输出zset的成员个数为3
+
+`zrange` 查看Zset指定范围的成员，withscores为输出结果带分数。
+
+	127.0.0.1:6379>zrange mZySet 0 -1   ----0为开始，-1为结束，输出顺序结果为： zlh tom jim
+	127.0.0.1:6379>zrange mZySet 0 -1 withscores   ---输出带分数的结果为：zlh 1 tom 2 jim 3
+
+`zrank` 获取zset成员的下标位置，如果值不存在返回null。
+
+	127.0.0.1:6379>zrank mZySet Jim    ---Jim的在zset集合中的下标为2
+
+`zcount` 获取zset集合指定分数之间存在的成员个数。
+
+	127.0.0.1:6379>zcount mySet 1 3   ---输出分数>=1 and 分数 <=3的成员个数为3，因为分数是可以重复的，所以这个命令是有道理的。
+
+`zrem`删除指定的一个成员或多个成员。
+
+	127.0.0.1:6379>zrem myZSet zlh   --删除值为zlh的zset成员
+	127.0.0.1:6379>zrem myZSet Tom Jim    ---删除值为Tom和Jim的两个zset成员
+
+`zscore` 获取指定值的分数。
+
+	127.0.0.1:6379>zadd myZset 1 zlh 1 tom 2 jim 3 xdd 4 pmm   ---由于上面的数据被删除完了，这里添加5条示范数据再。
+	127.0.0.1:6379>zscore myZset zlh    ---输出值为zlh的分数为1
+
+`zincrby`给指定元素的分数进行增减操作，负值为减，正值为加。
+
+	127.0.0.1:6379>zscore myZset tom    ----输出tom的分数为1
+	127.0.0.1:6379>zincrby myZset 4 tom   ---tom的分数值加4，输入分数值为5
+	127.0.0.1:6379>zscore myZset tom    ---输出tom的分数值为5
+
+`zrangebysocre` 根据指定分数的范围获取值。
+
+	127.0.0.1:6379>zrangebyscore myZset  1 5   ---输出分数>=1 and <=5的成员值为：zlh jim xdd pmm  tom
+	127.0.0.1:6379>zrangebyscore myZset  (1 5    ----输出分数>1 and <=5的成员值为：jim xdd pmm tom
+	127.0.0.1:6379>zrangebyscore myZset 2 5 limit 1 2    ---检索分数为2到5之间的数据，然后从下标为1的数据开始往后输出2个数据，包含下标为1的数据。结果为：xdd pmm
+	127.0.0.1:6379>zrangebyscore myZset -inf +inf limit 2 3   ----+inf表示最后一个成员，-inf表示第一个成员，意思是：检索所有数据，然后从下标为2的数据开始再往后输出2个数据。结果为：xdd pmm tom
+
+`zrevrange，zrevrangebyscore`倒序，从高到底排序输出指定范围的数据。
+
+	127.0.0.1:6379>zrevrange myZset 2 3   ---先倒序排列数据，输出下标为>=2 and <=3的数据为xdd jim，这里注意的是倒序之后下标也反过来了。
+	127.0.0.1:6379>zrevrange myZset 2 4 withscores    ---输出结果为：xdd 3 jim 2 zlh 1
+	127.0.0.1:6379>zrevrangebyscore myZset 5 1 limit  3 2  ----输出结果为：jim zlh 。获取score <=5 and >=1，从下标为为3开始获取2条数据。
+	127.0.0.1:6379>zrevrangebyscore myZset 4 2   ----分数>=2 and <=4 的数据倒序输出：pmm xdd jim
+
+`zremrangebyscore，zremrangebyrank`根据坐标，分数范围删除数据。
+
+
+	127.0.0.1:6379>zremrangebyscore myZset 1 2   ---删除分数>=1 and <=2的数据
+	127.0.0.1:6379>zrange myZset 0 -1    ----输出结果为 xdd pmm tom
+	127.0.0.1:6379>zremrangebyrank myZset 0 2    ---删除下标>=0 and <=2的zset元素
+	127.0.0.1:6379>zrange myZset 0 -1    --输出结果为：empty list or set 。没数据啦。
diff --git "a/04 - Middleware/redis/Redis\347\233\221\346\216\247\345\267\245\345\205\267.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/Redis\347\233\221\346\216\247\345\267\245\345\205\267.md"
similarity index 100%
rename from "04 - Middleware/redis/Redis\347\233\221\346\216\247\345\267\245\345\205\267.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/Redis\347\233\221\346\216\247\345\267\245\345\205\267.md"
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1319.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1319.png"
new file mode 100644
index 00000000..5d92ff56
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1319.png" differ
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1320.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1320.png"
new file mode 100644
index 00000000..3ddc3f0f
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1320.png" differ
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1321.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1321.png"
new file mode 100644
index 00000000..ce0b4add
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/1321.png" differ
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/640.webp" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/640.webp"
new file mode 100644
index 00000000..34add19f
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/640.webp" differ
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/6401.webp" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/6401.webp"
new file mode 100644
index 00000000..63eabf4f
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/6401.webp" differ
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/6402.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/6402.png"
new file mode 100644
index 00000000..b49e0db0
Binary files /dev/null and "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/6402.png" differ
diff --git a/04 - Middleware/redis/img/soon1.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon1.png"
similarity index 100%
rename from 04 - Middleware/redis/img/soon1.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon1.png"
diff --git a/04 - Middleware/redis/img/soon2.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon2.png"
similarity index 100%
rename from 04 - Middleware/redis/img/soon2.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon2.png"
diff --git a/04 - Middleware/redis/img/soon3.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon3.png"
similarity index 100%
rename from 04 - Middleware/redis/img/soon3.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon3.png"
diff --git a/04 - Middleware/redis/img/soon4.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon4.png"
similarity index 100%
rename from 04 - Middleware/redis/img/soon4.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon4.png"
diff --git a/04 - Middleware/redis/img/soon5.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon5.png"
similarity index 100%
rename from 04 - Middleware/redis/img/soon5.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon5.png"
diff --git a/04 - Middleware/redis/img/soon6.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon6.png"
similarity index 100%
rename from 04 - Middleware/redis/img/soon6.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/soon6.png"
diff --git a/04 - Middleware/redis/img/tc1.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc1.png"
similarity index 100%
rename from 04 - Middleware/redis/img/tc1.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc1.png"
diff --git a/04 - Middleware/redis/img/tc2.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc2.png"
similarity index 100%
rename from 04 - Middleware/redis/img/tc2.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc2.png"
diff --git a/04 - Middleware/redis/img/tc3.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc3.png"
similarity index 100%
rename from 04 - Middleware/redis/img/tc3.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc3.png"
diff --git a/04 - Middleware/redis/img/tc4.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc4.png"
similarity index 100%
rename from 04 - Middleware/redis/img/tc4.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc4.png"
diff --git a/04 - Middleware/redis/img/tc5.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc5.png"
similarity index 100%
rename from 04 - Middleware/redis/img/tc5.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc5.png"
diff --git a/04 - Middleware/redis/img/tc6.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc6.png"
similarity index 100%
rename from 04 - Middleware/redis/img/tc6.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/tc6.png"
diff --git a/04 - Middleware/redis/img/zset1.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/zset1.png"
similarity index 100%
rename from 04 - Middleware/redis/img/zset1.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/zset1.png"
diff --git a/04 - Middleware/redis/img/zset2.png "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/zset2.png"
similarity index 100%
rename from 04 - Middleware/redis/img/zset2.png
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/img/zset2.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\345\244\247\345\236\213\347\275\221\347\253\231\346\236\266\346\236\204\344\271\213\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\351\230\237\345\210\227.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/ms.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\345\244\247\345\236\213\347\275\221\347\253\231\346\236\266\346\236\204\344\271\213\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\351\230\237\345\210\227.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/ms.md"
diff --git a/04 - Middleware/redis/redis.md "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis.md"
similarity index 99%
rename from 04 - Middleware/redis/redis.md
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis.md"
index 0f580e78..1be212f2 100644
--- a/04 - Middleware/redis/redis.md	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis.md"	
@@ -1,4 +1,4 @@
-REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
-Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
-它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
-
+REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
+Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
+它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
+
diff --git "a/04 - Middleware/redis/redis4/\345\256\211\350\243\205\345\220\257\345\212\250.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis4/\345\256\211\350\243\205\345\220\257\345\212\250.md"
similarity index 100%
rename from "04 - Middleware/redis/redis4/\345\256\211\350\243\205\345\220\257\345\212\250.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis4/\345\256\211\350\243\205\345\220\257\345\212\250.md"
diff --git "a/04 - Middleware/redis/redis\344\272\213\345\212\241.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis\344\272\213\345\212\241.md"
similarity index 98%
rename from "04 - Middleware/redis/redis\344\272\213\345\212\241.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis\344\272\213\345\212\241.md"
index af110fed..d595d759 100644
--- "a/04 - Middleware/redis/redis\344\272\213\345\212\241.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/redis\344\272\213\345\212\241.md"	
@@ -1,75 +1,75 @@
-https://blog.csdn.net/cuipeng0916/article/details/53698774
-
-如果要进入事务要通过`MULTI命令`，但是这个命令的结果是成功的，有没有正确的执行那就是另外一码事了，这个就和java中的强引用是差不多个意思，，这些需要执行的命令都会入队并不会立即执行，通过`exec`执行事务中的命令，`discard`会放弃本次事务的操作
-
-事务命令
-
-序号|命令及描述
----|----
-1	 | `DISCARD` 取消事务，放弃执行事务块内的所有命令。
-2	 | `EXEC` 执行所有事务块内的命令。
-3	 | `MULTI` 标记一个事务块的开始。
-4	 | `UNWATCH` 取消 WATCH 命令对所有 key 的监视。
-5  | `WATCH` key [key ...] 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
-
-redis事务能干嘛：一个队列中，一次性、顺序性、排他性的执行一系列命令
-
-### 事务实例1：正常执行
-<div align ="center"><img src="img/tc1.png"></div>
-
-大家可以看到，通过`multi`开启事务之后之后的所有命令都`入队 (QUEUED)`了，并没有立即执行，而是在执行`exec`命令之后执行的
-
-### 事务实例2：放弃事务
-<div align ="center"><img src="img/tc2.png"></div>
-
-这里呢所有的命令也是没有立即执行，而是将这些命令入队，如果你觉得这个队列中有些命令时不要执行的，那么通过`discard`命令来放弃，通过结果可以看出，放弃之后那些命令并没有执行，如果用关系型数据库中的术语来说，就是都回滚了
-
-### 事务实例3：redis事务的一致性
-<div align ="center"><img src="img/tc3.png"></div>
-
-开启事务之后，我在这里故意敲错一个命令，而后面的命令任然还在`入队`，但是通过`exec`命令执行之后发现这些改变并没有写入到数据库中。这个就像关系型数据库中的事务的一致性，要么一起成功，要么一起失败
-
-### 事务实例4：事务的非一致性
-<div align ="center"><img src="img/tc4.png"></div>
-
-首先呢改变k1值为11，然后开启事务，然后就执行命令了，最后大家看看结果，发现正确的命令执行了，而那些执行失败的命令是没有执行的。那么有的人就会发现，你这个命令不是和实例3一样的吗？兄弟，麻烦看清楚，这里是不一样的，实例3中有
-
-`setget k6`
-
-但是这种命令在redis中是不存在的，这个就好比是java的运行时异常和非运行时异常一个意思。所以实例3中事务都回滚了，但是实例4中的部分成功，部分失败。
-
-那么对于实例3和实例4我们可以的出的总结是：
-redis对事务是部分支持的，如果是在`入队时报错`，那么`都不会执行`；在`非入队时报错`，那么`成功的就会成功执行`。
-
-### redis监控：锁的介绍
-
-在MySQL中我们都知道有行锁和表锁的概念，所谓的行锁也就是把我需要改的那一行给锁住，不让其他的事务去修改；而表锁就是在修改一张表的时候把整张表都锁住，不让其他的事务修改，所以行锁的效率比表锁的概念更高，那么在redis也存在锁的概念
-
- * 乐观锁（Optimistic Lock）： 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，乐观锁策略:提交版本必须大于记录当前版本才能执行更新
- * 悲观锁（Pessimistic Lock）： 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁
- * CAS（Check And Set）：
-
-### 监控实例：银行卡余额
-<div align ="center"><img src="img/tc5.png"></div>
-
-大家可以看到，我在watch银行卡余额时然后将余额修改成200，在开启事务去修改余额，发现事务执行失败，因为这个时候在事务执行之前余额已经被其他人修改过了，所以事务执行失败了。
-类似乐观锁，事务提交时，如果Key的值已被别的客户端改变，比如某个list已被别的客户端push/pop过了，整个事务队列都不会被执行。
-通过WATCH命令在事务执行之前监控了多个Keys，倘若在`WATCH之后`有任何`Key`的值`发生了变化`，`EXEC命令`执行的事务都将被`放弃`，同时返回`Nullmulti-bulk`应答以通知调用者事务执行失败
-
-<div align ="center"><img src="img/tc6.png"></div>
-
-在watch余额之后发现有人修改过余额，那么我们就可以取消watch，也就是unwatch，然后确认没有人去修改余额再去watch余额，开启事务，对余额操作，我们发现余额修改成功
-
-上面呢我们通过实例说明了redis的事务
-
-### redis事务三阶段：
-
-1. 开启：以MULTI开始一个事务
-2. 入队：将多个命令入队到事务中，接到这些命令并不会立即执行，而是放到等待执行的事务队列里面
-3. 执行：由EXEC命令触发事务
-
-### redis事务三大特性：
-
-1. 单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
-2. 没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在”事务内的查询要看到事务里的更新，在事务外查询不能看到”这个让人万分头痛的问题
-3. 不保证原子性：redis同一个事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚
+https://blog.csdn.net/cuipeng0916/article/details/53698774
+
+如果要进入事务要通过`MULTI命令`，但是这个命令的结果是成功的，有没有正确的执行那就是另外一码事了，这个就和java中的强引用是差不多个意思，，这些需要执行的命令都会入队并不会立即执行，通过`exec`执行事务中的命令，`discard`会放弃本次事务的操作
+
+事务命令
+
+序号|命令及描述
+---|----
+1	 | `DISCARD` 取消事务，放弃执行事务块内的所有命令。
+2	 | `EXEC` 执行所有事务块内的命令。
+3	 | `MULTI` 标记一个事务块的开始。
+4	 | `UNWATCH` 取消 WATCH 命令对所有 key 的监视。
+5  | `WATCH` key [key ...] 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
+
+redis事务能干嘛：一个队列中，一次性、顺序性、排他性的执行一系列命令
+
+### 事务实例1：正常执行
+<div align ="center"><img src="img/tc1.png"></div>
+
+大家可以看到，通过`multi`开启事务之后之后的所有命令都`入队 (QUEUED)`了，并没有立即执行，而是在执行`exec`命令之后执行的
+
+### 事务实例2：放弃事务
+<div align ="center"><img src="img/tc2.png"></div>
+
+这里呢所有的命令也是没有立即执行，而是将这些命令入队，如果你觉得这个队列中有些命令时不要执行的，那么通过`discard`命令来放弃，通过结果可以看出，放弃之后那些命令并没有执行，如果用关系型数据库中的术语来说，就是都回滚了
+
+### 事务实例3：redis事务的一致性
+<div align ="center"><img src="img/tc3.png"></div>
+
+开启事务之后，我在这里故意敲错一个命令，而后面的命令任然还在`入队`，但是通过`exec`命令执行之后发现这些改变并没有写入到数据库中。这个就像关系型数据库中的事务的一致性，要么一起成功，要么一起失败
+
+### 事务实例4：事务的非一致性
+<div align ="center"><img src="img/tc4.png"></div>
+
+首先呢改变k1值为11，然后开启事务，然后就执行命令了，最后大家看看结果，发现正确的命令执行了，而那些执行失败的命令是没有执行的。那么有的人就会发现，你这个命令不是和实例3一样的吗？兄弟，麻烦看清楚，这里是不一样的，实例3中有
+
+`setget k6`
+
+但是这种命令在redis中是不存在的，这个就好比是java的运行时异常和非运行时异常一个意思。所以实例3中事务都回滚了，但是实例4中的部分成功，部分失败。
+
+那么对于实例3和实例4我们可以的出的总结是：
+redis对事务是部分支持的，如果是在`入队时报错`，那么`都不会执行`；在`非入队时报错`，那么`成功的就会成功执行`。
+
+### redis监控：锁的介绍
+
+在MySQL中我们都知道有行锁和表锁的概念，所谓的行锁也就是把我需要改的那一行给锁住，不让其他的事务去修改；而表锁就是在修改一张表的时候把整张表都锁住，不让其他的事务修改，所以行锁的效率比表锁的概念更高，那么在redis也存在锁的概念
+
+ * 乐观锁（Optimistic Lock）： 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，乐观锁策略:提交版本必须大于记录当前版本才能执行更新
+ * 悲观锁（Pessimistic Lock）： 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁
+ * CAS（Check And Set）：
+
+### 监控实例：银行卡余额
+<div align ="center"><img src="img/tc5.png"></div>
+
+大家可以看到，我在watch银行卡余额时然后将余额修改成200，在开启事务去修改余额，发现事务执行失败，因为这个时候在事务执行之前余额已经被其他人修改过了，所以事务执行失败了。
+类似乐观锁，事务提交时，如果Key的值已被别的客户端改变，比如某个list已被别的客户端push/pop过了，整个事务队列都不会被执行。
+通过WATCH命令在事务执行之前监控了多个Keys，倘若在`WATCH之后`有任何`Key`的值`发生了变化`，`EXEC命令`执行的事务都将被`放弃`，同时返回`Nullmulti-bulk`应答以通知调用者事务执行失败
+
+<div align ="center"><img src="img/tc6.png"></div>
+
+在watch余额之后发现有人修改过余额，那么我们就可以取消watch，也就是unwatch，然后确认没有人去修改余额再去watch余额，开启事务，对余额操作，我们发现余额修改成功
+
+上面呢我们通过实例说明了redis的事务
+
+### redis事务三阶段：
+
+1. 开启：以MULTI开始一个事务
+2. 入队：将多个命令入队到事务中，接到这些命令并不会立即执行，而是放到等待执行的事务队列里面
+3. 执行：由EXEC命令触发事务
+
+### redis事务三大特性：
+
+1. 单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
+2. 没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在”事务内的查询要看到事务里的更新，在事务外查询不能看到”这个让人万分头痛的问题
+3. 不保证原子性：redis同一个事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚
diff --git "a/04 - Middleware/redis/\345\210\206\345\270\203\345\274\217\351\224\201.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\210\206\345\270\203\345\274\217\351\224\201.md"
similarity index 97%
rename from "04 - Middleware/redis/\345\210\206\345\270\203\345\274\217\351\224\201.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\210\206\345\270\203\345\274\217\351\224\201.md"
index 76fd016e..2f18d883 100644
--- "a/04 - Middleware/redis/\345\210\206\345\270\203\345\274\217\351\224\201.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\210\206\345\270\203\345\274\217\351\224\201.md"	
@@ -1,37 +1,37 @@
-https://www.cnblogs.com/liuyang0/p/6744076.html
-`setnx`
-
-### 使用命令介绍
-SETNX
-
-SETNX key val
-当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。
-
-expire
-
-expire key timeout
-为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。
-
-delete
-
-delete key
-删除key
-
-在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。
-
-### 实现思想
-
-获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
-获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
-释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。
-
-https://blog.csdn.net/fuyuwei2015/article/details/72870131
-
-SETNX key value
-将 key 的值设为 value ，当且仅当 key 不存在。
-若给定的 key 已经存在，则 SETNX 不做任何动作。
-SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。
-
-GETSET key value
-将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
-当 key 存在但不是字符串类型时，返回一个错误。
+https://www.cnblogs.com/liuyang0/p/6744076.html
+`setnx`
+
+### 使用命令介绍
+SETNX
+
+SETNX key val
+当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。
+
+expire
+
+expire key timeout
+为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。
+
+delete
+
+delete key
+删除key
+
+在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。
+
+### 实现思想
+
+获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。
+获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。
+释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。
+
+https://blog.csdn.net/fuyuwei2015/article/details/72870131
+
+SETNX key value
+将 key 的值设为 value ，当且仅当 key 不存在。
+若给定的 key 已经存在，则 SETNX 不做任何动作。
+SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。
+
+GETSET key value
+将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
+当 key 存在但不是字符串类型时，返回一个错误。
diff --git "a/04 - Middleware/redis/\345\215\225\347\272\277\347\250\213\347\232\204redis\351\200\237\345\272\246\344\271\237\345\276\210\345\277\253.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\215\225\347\272\277\347\250\213\347\232\204redis\351\200\237\345\272\246\344\271\237\345\276\210\345\277\253.md"
similarity index 98%
rename from "04 - Middleware/redis/\345\215\225\347\272\277\347\250\213\347\232\204redis\351\200\237\345\272\246\344\271\237\345\276\210\345\277\253.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\215\225\347\272\277\347\250\213\347\232\204redis\351\200\237\345\272\246\344\271\237\345\276\210\345\277\253.md"
index 50c4eaa7..17a0cac5 100644
--- "a/04 - Middleware/redis/\345\215\225\347\272\277\347\250\213\347\232\204redis\351\200\237\345\272\246\344\271\237\345\276\210\345\277\253.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\215\225\347\272\277\347\250\213\347\232\204redis\351\200\237\345\272\246\344\271\237\345\276\210\345\277\253.md"	
@@ -1,111 +1,111 @@
-https://blog.csdn.net/chenyao1994/article/details/79491337
-### 一、前言
-近乎所有与Java相关的面试都会问到缓存的问题，基础一点的会问到什么是“二八定律”、什么是“热数据和冷数据”，复杂一点的会问到缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级等问题，这些看似不常见的概念，都与我们的缓存服务器相关，一般常用的缓存服务器有Redis、Memcached等，而笔者目前最常用的也只有Redis这一种。
-
-如果你在以前面试的时候还没有遇到过面试官问你《为什么说Redis是单线程的以及Redis为什么这么快！》，那么你看到这篇文章的时候，你应该觉得是一件很幸运的事情！如果你刚好是一位高逼格的面试官，你也可以拿这道题去面试对面“望穿秋水”般的小伙伴，测试一下他的掌握程度。
-
-好啦！步入正题！我们先探讨一下Redis是什么，Redis为什么这么快、然后在探讨一下为什么Redis是单线程的？
-
-### 二、Redis简介
-Redis是一个开源的内存中的数据结构存储系统，它可以用作：`数据库、缓存和消息中间件`。
-
-它支持多种类型的数据结构，如字符串（Strings），散列（Hash），列表（List），集合（Set），有序集合（Sorted Set或者是ZSet）与范围查询，Bitmaps，Hyperloglogs 和地理空间（Geospatial）索引半径查询。其中常见的数据结构类型有：`String、List、Set、Hash、ZSet`这5种。
-
-Redis 内置了`复制（Replication）`，`LUA脚本（Lua scripting）`， `LRU驱动事件（LRU eviction）`，`事务（Transactions）` 和不同级别的磁盘持久化`（Persistence）`，并通过 `Redis哨兵（Sentinel）`和`自动分区（Cluster）`提供`高可用性（High Availability）`。
-
-Redis也提供了持久化的选项，这些选项可以让用户将自己的数据保存到磁盘上面进行存储。根据实际情况，可以`每隔一定时间将数据集导出到磁盘（快照）`，或者`追加到命令日志中（AOF只追加文件）`，他会在执行写命令时，将被执行的写命令复制到硬盘里面。您也可以关闭持久化功能，将Redis作为一个高效的网络的缓存数据功能使用。
-
-Redis不使用表，他的数据库不会预定义或者强制去要求用户对Redis存储的不同数据进行关联。
-
-数据库的工作模式按存储方式可分为：硬盘数据库和内存数据库。Redis 将数据储存在内存里面，读写数据的时候都不会受到硬盘 I/O 速度的限制，所以速度极快。
-
-（1）硬盘数据库的工作模式：
-<div align="center"> <img src="img/soon1.png" > </div>
-
-（2）内存数据库的工作模式：
-<div align="center"> <img src="img/soon2.png" > </div>
-
-看完上述的描述，对于一些常见的Redis相关的面试题，是否有所认识了，例如：什么是Redis、Redis常见的数据结构类型有哪些、Redis是如何进行持久化的等。
-
-### 三、Redis到底有多快
-Redis采用的是基于内存的采用的是单进程单线程模型的 KV 数据库，由C语言编写，官方提供的数据是可以达到100000+的QPS（每秒内查询次数）。这个数据不比采用单进程多线程的同样基于内存的 KV 数据库 Memcached 差！有兴趣的可以参考官方的基准程序测试《How fast is Redis？》（https://redis.io/topics/benchmarks）
-
-<div align="center"> <img src="img/soon3.png" > </div>
-
-横轴是连接数，纵轴是QPS。此时，这张图反映了一个数量级，希望大家在面试的时候可以正确的描述出来，不要问你的时候，你回答的数量级相差甚远！
-
-### 四、Redis为什么这么快
-1、完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)；
-
-2、数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的；
-
-3、采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；
-
-4、使用多路I/O复用模型，非阻塞IO；
-
-5、使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis直接自己构建了VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；
-
-以上几点都比较好理解，下边我们针对多路 I/O 复用模型进行简单的探讨：
-
-（1）多路 I/O 复用模型
-
-多路I/O复用模型是利用 select、poll、epoll 可以同时监察多个流的 I/O 事件的能力，在空闲的时候，会把当前线程阻塞掉，当有一个或多个流有 I/O 事件时，就从阻塞态中唤醒，于是程序就会轮询一遍所有的流（epoll 是只轮询那些真正发出了事件的流），并且只依次顺序的处理就绪的流，这种做法就避免了大量的无用操作。
-
-这里“多路”指的是多个网络连接，“复用”指的是复用同一个线程。采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求（尽量减少网络 IO 的时间消耗），且 Redis 在内存中操作数据的速度非常快，也就是说内存内的操作不会成为影响Redis性能的瓶颈，主要由以上几点造就了 Redis 具有很高的吞吐量。
-
-### 五、那么为什么Redis是单线程的
-我们首先要明白，上边的种种分析，都是为了营造一个Redis很快的氛围！官方FAQ表示，因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了（毕竟采用多线程会有很多麻烦！）。
-
-<div align="center"> <img src="img/soon4.png" > </div>
-可以参考：https://redis.io/topics/faq
-
-看到这里，你可能会气哭！本以为会有什么重大的技术要点才使得Redis使用单线程就可以这么快，没想到就是一句官方看似糊弄我们的回答！但是，我们已经可以很清楚的解释了为什么Redis这么快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了！
-
-但是，我们使用单线程的方式是无法发挥多核CPU 性能，不过我们可以通过在单机开多个Redis 实例来完善！
-
-警告1：这里我们一直在强调的单线程，只是在处理我们的网络请求的时候只有一个线程来处理，一个正式的Redis Server运行的时候肯定是不止一个线程的，这里需要大家明确的注意一下！例如Redis进行持久化的时候会以子进程或者子线程的方式执行（具体是子线程还是子进程待读者深入研究）；例如我在测试服务器上查看Redis进程，然后找到该进程下的线程：
-
-<div align="center"> <img src="img/soon5.png" > </div>
-
-ps命令的“-T”参数表示显示线程（Show threads, possibly with SPID column.）“SID”栏表示线程ID，而“CMD”栏则显示了线程名称。
-
-警告2：在上图中FAQ中的最后一段，表述了从Redis 4.0版本开始会支持多线程的方式，但是，只是在某一些操作上进行多线程的操作！所以该篇文章在以后的版本中是否还是单线程的方式需要读者考证！
-
-### 六、注意点
-1、我们知道Redis是用”单线程-多路复用IO模型”来实现高性能的内存数据服务的，这种机制避免了使用锁，但是同时这种机制在进行sunion之类的比较耗时的命令时会使redis的并发下降。因为是单一线程，所以同一时刻只有一个操作在进行，所以，耗时的命令会导致并发的下降，不只是读并发，写并发也会下降。而单一线程也只能用到一个CPU核心，所以可以在同一个多核的服务器中，可以启动多个实例，组成master-master或者master-slave的形式，耗时的读命令可以完全在slave进行。
-
-需要改的redis.conf项：
-```
-pidfile /var/run/redis/redis_6377.pid  #pidfile要加上端口号
-port 6377  #这个是必须改的
-logfile /var/log/redis/redis_6377.log #logfile的名称也加上端口号
-dbfilename dump_6377.rdb  #rdbfile也加上端口号
-```
-2、“我们不能任由操作系统负载均衡，因为我们自己更了解自己的程序，所以，我们可以手动地为其分配CPU核，而不会过多地占用CPU，或是让我们关键进程和一堆别的进程挤在一起。”。
-CPU 是一个重要的影响因素，由于是单线程模型，Redis 更喜欢大缓存快速 CPU， 而不是多核
-
-在多核 CPU 服务器上面，Redis 的性能还依赖NUMA 配置和处理器绑定位置。最明显的影响是 redis-benchmark 会随机使用CPU内核。为了获得精准的结果，需要使用固定处理器工具（在 Linux 上可以使用 taskset）。最有效的办法是将客户端和服务端分离到两个不同的 CPU 来高校使用三级缓存。
-
-七、扩展
-以下也是你应该知道的几种模型，祝你的面试一臂之力！
-
-* 1、单进程多线程模型：MySQL、Memcached、Oracle（Windows版本）；
-
-* 2、多进程模型：Oracle（Linux版本）；
-
-* 3、Nginx有两类进程，一类称为Master进程(相当于管理进程)，另一类称为Worker进程（实际工作进程）。启动方式有两种：
-
-（1）单进程启动：此时系统中仅有一个进程，该进程既充当Master进程的角色，也充当Worker进程的角色。
-
-（2）多进程启动：此时系统有且仅有一个Master进程，至少有一个Worker进程工作。
-
-（3）Master进程主要进行一些全局性的初始化工作和管理Worker的工作；事件处理是在Worker中进行的。
-
-<div align="center"> <img src="img/soon6.png" > </div>
-
-参考文章：
-
-1、http://www.syyong.com/db/Redis-why-the-use-of-single-process-and-single-threaded-way-so-fast.html
-2、http://blog.csdn.net/xxb2008/article/details/42238557
-3、http://blog.csdn.net/hobbs136/article/details/7619719
-4、http://blog.csdn.net/yushitao/article/details/43565851
+https://blog.csdn.net/chenyao1994/article/details/79491337
+### 一、前言
+近乎所有与Java相关的面试都会问到缓存的问题，基础一点的会问到什么是“二八定律”、什么是“热数据和冷数据”，复杂一点的会问到缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级等问题，这些看似不常见的概念，都与我们的缓存服务器相关，一般常用的缓存服务器有Redis、Memcached等，而笔者目前最常用的也只有Redis这一种。
+
+如果你在以前面试的时候还没有遇到过面试官问你《为什么说Redis是单线程的以及Redis为什么这么快！》，那么你看到这篇文章的时候，你应该觉得是一件很幸运的事情！如果你刚好是一位高逼格的面试官，你也可以拿这道题去面试对面“望穿秋水”般的小伙伴，测试一下他的掌握程度。
+
+好啦！步入正题！我们先探讨一下Redis是什么，Redis为什么这么快、然后在探讨一下为什么Redis是单线程的？
+
+### 二、Redis简介
+Redis是一个开源的内存中的数据结构存储系统，它可以用作：`数据库、缓存和消息中间件`。
+
+它支持多种类型的数据结构，如字符串（Strings），散列（Hash），列表（List），集合（Set），有序集合（Sorted Set或者是ZSet）与范围查询，Bitmaps，Hyperloglogs 和地理空间（Geospatial）索引半径查询。其中常见的数据结构类型有：`String、List、Set、Hash、ZSet`这5种。
+
+Redis 内置了`复制（Replication）`，`LUA脚本（Lua scripting）`， `LRU驱动事件（LRU eviction）`，`事务（Transactions）` 和不同级别的磁盘持久化`（Persistence）`，并通过 `Redis哨兵（Sentinel）`和`自动分区（Cluster）`提供`高可用性（High Availability）`。
+
+Redis也提供了持久化的选项，这些选项可以让用户将自己的数据保存到磁盘上面进行存储。根据实际情况，可以`每隔一定时间将数据集导出到磁盘（快照）`，或者`追加到命令日志中（AOF只追加文件）`，他会在执行写命令时，将被执行的写命令复制到硬盘里面。您也可以关闭持久化功能，将Redis作为一个高效的网络的缓存数据功能使用。
+
+Redis不使用表，他的数据库不会预定义或者强制去要求用户对Redis存储的不同数据进行关联。
+
+数据库的工作模式按存储方式可分为：硬盘数据库和内存数据库。Redis 将数据储存在内存里面，读写数据的时候都不会受到硬盘 I/O 速度的限制，所以速度极快。
+
+（1）硬盘数据库的工作模式：
+<div align="center"> <img src="img/soon1.png" > </div>
+
+（2）内存数据库的工作模式：
+<div align="center"> <img src="img/soon2.png" > </div>
+
+看完上述的描述，对于一些常见的Redis相关的面试题，是否有所认识了，例如：什么是Redis、Redis常见的数据结构类型有哪些、Redis是如何进行持久化的等。
+
+### 三、Redis到底有多快
+Redis采用的是基于内存的采用的是单进程单线程模型的 KV 数据库，由C语言编写，官方提供的数据是可以达到100000+的QPS（每秒内查询次数）。这个数据不比采用单进程多线程的同样基于内存的 KV 数据库 Memcached 差！有兴趣的可以参考官方的基准程序测试《How fast is Redis？》（https://redis.io/topics/benchmarks）
+
+<div align="center"> <img src="img/soon3.png" > </div>
+
+横轴是连接数，纵轴是QPS。此时，这张图反映了一个数量级，希望大家在面试的时候可以正确的描述出来，不要问你的时候，你回答的数量级相差甚远！
+
+### 四、Redis为什么这么快
+1、完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)；
+
+2、数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的；
+
+3、采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；
+
+4、使用多路I/O复用模型，非阻塞IO；
+
+5、使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis直接自己构建了VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；
+
+以上几点都比较好理解，下边我们针对多路 I/O 复用模型进行简单的探讨：
+
+（1）多路 I/O 复用模型
+
+多路I/O复用模型是利用 select、poll、epoll 可以同时监察多个流的 I/O 事件的能力，在空闲的时候，会把当前线程阻塞掉，当有一个或多个流有 I/O 事件时，就从阻塞态中唤醒，于是程序就会轮询一遍所有的流（epoll 是只轮询那些真正发出了事件的流），并且只依次顺序的处理就绪的流，这种做法就避免了大量的无用操作。
+
+这里“多路”指的是多个网络连接，“复用”指的是复用同一个线程。采用多路 I/O 复用技术可以让单个线程高效的处理多个连接请求（尽量减少网络 IO 的时间消耗），且 Redis 在内存中操作数据的速度非常快，也就是说内存内的操作不会成为影响Redis性能的瓶颈，主要由以上几点造就了 Redis 具有很高的吞吐量。
+
+### 五、那么为什么Redis是单线程的
+我们首先要明白，上边的种种分析，都是为了营造一个Redis很快的氛围！官方FAQ表示，因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了（毕竟采用多线程会有很多麻烦！）。
+
+<div align="center"> <img src="img/soon4.png" > </div>
+可以参考：https://redis.io/topics/faq
+
+看到这里，你可能会气哭！本以为会有什么重大的技术要点才使得Redis使用单线程就可以这么快，没想到就是一句官方看似糊弄我们的回答！但是，我们已经可以很清楚的解释了为什么Redis这么快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了！
+
+但是，我们使用单线程的方式是无法发挥多核CPU 性能，不过我们可以通过在单机开多个Redis 实例来完善！
+
+警告1：这里我们一直在强调的单线程，只是在处理我们的网络请求的时候只有一个线程来处理，一个正式的Redis Server运行的时候肯定是不止一个线程的，这里需要大家明确的注意一下！例如Redis进行持久化的时候会以子进程或者子线程的方式执行（具体是子线程还是子进程待读者深入研究）；例如我在测试服务器上查看Redis进程，然后找到该进程下的线程：
+
+<div align="center"> <img src="img/soon5.png" > </div>
+
+ps命令的“-T”参数表示显示线程（Show threads, possibly with SPID column.）“SID”栏表示线程ID，而“CMD”栏则显示了线程名称。
+
+警告2：在上图中FAQ中的最后一段，表述了从Redis 4.0版本开始会支持多线程的方式，但是，只是在某一些操作上进行多线程的操作！所以该篇文章在以后的版本中是否还是单线程的方式需要读者考证！
+
+### 六、注意点
+1、我们知道Redis是用”单线程-多路复用IO模型”来实现高性能的内存数据服务的，这种机制避免了使用锁，但是同时这种机制在进行sunion之类的比较耗时的命令时会使redis的并发下降。因为是单一线程，所以同一时刻只有一个操作在进行，所以，耗时的命令会导致并发的下降，不只是读并发，写并发也会下降。而单一线程也只能用到一个CPU核心，所以可以在同一个多核的服务器中，可以启动多个实例，组成master-master或者master-slave的形式，耗时的读命令可以完全在slave进行。
+
+需要改的redis.conf项：
+```
+pidfile /var/run/redis/redis_6377.pid  #pidfile要加上端口号
+port 6377  #这个是必须改的
+logfile /var/log/redis/redis_6377.log #logfile的名称也加上端口号
+dbfilename dump_6377.rdb  #rdbfile也加上端口号
+```
+2、“我们不能任由操作系统负载均衡，因为我们自己更了解自己的程序，所以，我们可以手动地为其分配CPU核，而不会过多地占用CPU，或是让我们关键进程和一堆别的进程挤在一起。”。
+CPU 是一个重要的影响因素，由于是单线程模型，Redis 更喜欢大缓存快速 CPU， 而不是多核
+
+在多核 CPU 服务器上面，Redis 的性能还依赖NUMA 配置和处理器绑定位置。最明显的影响是 redis-benchmark 会随机使用CPU内核。为了获得精准的结果，需要使用固定处理器工具（在 Linux 上可以使用 taskset）。最有效的办法是将客户端和服务端分离到两个不同的 CPU 来高校使用三级缓存。
+
+七、扩展
+以下也是你应该知道的几种模型，祝你的面试一臂之力！
+
+* 1、单进程多线程模型：MySQL、Memcached、Oracle（Windows版本）；
+
+* 2、多进程模型：Oracle（Linux版本）；
+
+* 3、Nginx有两类进程，一类称为Master进程(相当于管理进程)，另一类称为Worker进程（实际工作进程）。启动方式有两种：
+
+（1）单进程启动：此时系统中仅有一个进程，该进程既充当Master进程的角色，也充当Worker进程的角色。
+
+（2）多进程启动：此时系统有且仅有一个Master进程，至少有一个Worker进程工作。
+
+（3）Master进程主要进行一些全局性的初始化工作和管理Worker的工作；事件处理是在Worker中进行的。
+
+<div align="center"> <img src="img/soon6.png" > </div>
+
+参考文章：
+
+1、http://www.syyong.com/db/Redis-why-the-use-of-single-process-and-single-threaded-way-so-fast.html
+2、http://blog.csdn.net/xxb2008/article/details/42238557
+3、http://blog.csdn.net/hobbs136/article/details/7619719
+4、http://blog.csdn.net/yushitao/article/details/43565851
diff --git "a/04 - Middleware/redis/\345\270\270\347\224\250\345\221\275\344\273\244.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\270\270\347\224\250\345\221\275\344\273\244.md"
similarity index 91%
rename from "04 - Middleware/redis/\345\270\270\347\224\250\345\221\275\344\273\244.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\270\270\347\224\250\345\221\275\344\273\244.md"
index 745b0235..15dc00d3 100644
--- "a/04 - Middleware/redis/\345\270\270\347\224\250\345\221\275\344\273\244.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\345\270\270\347\224\250\345\221\275\344\273\244.md"	
@@ -1,42 +1,42 @@
-
-
-## 启动 
-
-### windows
-
-启动服务
-cmd 进入 redis目录 redis-server.exe redis.windows.conf  
-
-进入命令
-redis-cli.exe -h 127.0.0.1 -p 6379 -a密码 如果没有密码 就不需要 -a
-
-
-### linux
-
-在redis目录下
-
-启动服务 ./redis-server + conf
-
-进入命令 ./redis-cli -h 127.0.0.1 -p 6379 -a 123456
-
-认真 AUTH 123456
-
-
-## 密码设置
-
-在redis.conf 中修改 
-
-requirepass 123456  
-
-//123456即为密码
-
-### Get set
-
-set key value
-
-get key
-
-keys *
-
-
-
+
+
+## 启动 
+
+### windows
+
+启动服务
+cmd 进入 redis目录 redis-server.exe redis.windows.conf  
+
+进入命令
+redis-cli.exe -h 127.0.0.1 -p 6379 -a密码 如果没有密码 就不需要 -a
+
+
+### linux
+
+在redis目录下
+
+启动服务 ./redis-server + conf
+
+进入命令 ./redis-cli -h 127.0.0.1 -p 6379 -a 123456
+
+认真 AUTH 123456
+
+
+## 密码设置
+
+在redis.conf 中修改 
+
+requirepass 123456  
+
+//123456即为密码
+
+### Get set
+
+set key value
+
+get key
+
+keys *
+
+
+
diff --git "a/04 - Middleware/redis/\346\234\200\344\275\263\345\256\236\350\267\265 \347\274\223\345\255\230\347\251\277\351\200\217,\347\236\254\351\227\264\345\271\266\345\217\221,\347\274\223\345\255\230\351\233\252\345\264\251\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\346\234\200\344\275\263\345\256\236\350\267\265 \347\274\223\345\255\230\347\251\277\351\200\217,\347\236\254\351\227\264\345\271\266\345\217\221,\347\274\223\345\255\230\351\233\252\345\264\251\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"
similarity index 100%
rename from "04 - Middleware/redis/\346\234\200\344\275\263\345\256\236\350\267\265 \347\274\223\345\255\230\347\251\277\351\200\217,\347\236\254\351\227\264\345\271\266\345\217\221,\347\274\223\345\255\230\351\233\252\345\264\251\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\346\234\200\344\275\263\345\256\236\350\267\265 \347\274\223\345\255\230\347\251\277\351\200\217,\347\236\254\351\227\264\345\271\266\345\217\221,\347\274\223\345\255\230\351\233\252\345\264\251\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"
diff --git "a/04 - Middleware/redis/\346\234\211\345\272\217\351\233\206\345\220\210\345\256\236\347\216\260.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\346\234\211\345\272\217\351\233\206\345\220\210\345\256\236\347\216\260.md"
similarity index 100%
rename from "04 - Middleware/redis/\346\234\211\345\272\217\351\233\206\345\220\210\345\256\236\347\216\260.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\346\234\211\345\272\217\351\233\206\345\220\210\345\256\236\347\216\260.md"
diff --git "a/04 - Middleware/redis/\347\224\237\345\221\275\345\221\250\346\234\237.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\347\224\237\345\221\275\345\221\250\346\234\237.txt"
similarity index 95%
rename from "04 - Middleware/redis/\347\224\237\345\221\275\345\221\250\346\234\237.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\347\224\237\345\221\275\345\221\250\346\234\237.txt"
index e6dfb93c..fd1f806a 100644
--- "a/04 - Middleware/redis/\347\224\237\345\221\275\345\221\250\346\234\237.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\347\224\237\345\221\275\345\221\250\346\234\237.txt"	
@@ -1,6 +1,6 @@
-
-设置一个键的存活时间，超过就销毁
-expire key seconde
-
-查看剩余存活时间
+
+设置一个键的存活时间，超过就销毁
+expire key seconde
+
+查看剩余存活时间
 TTL key
\ No newline at end of file
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\347\274\223\345\255\230\347\251\277\351\200\217\343\200\201\347\274\223\345\255\230\345\207\273\347\251\277\343\200\201\347\274\223\345\255\230\351\233\252\345\264\251\345\222\214\347\203\255\347\202\271\346\225\260\346\215\256\345\244\261\346\225\210\351\227\256\351\242\230\347\232\204\350\247\243\345\206\263\346\226\271\346\241\210.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\347\274\223\345\255\230\347\251\277\351\200\217\343\200\201\347\274\223\345\255\230\345\207\273\347\251\277\343\200\201\347\274\223\345\255\230\351\233\252\345\264\251\345\222\214\347\203\255\347\202\271\346\225\260\346\215\256\345\244\261\346\225\210\351\227\256\351\242\230\347\232\204\350\247\243\345\206\263\346\226\271\346\241\210.md"
new file mode 100644
index 00000000..d74cf919
--- /dev/null
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\347\274\223\345\255\230\347\251\277\351\200\217\343\200\201\347\274\223\345\255\230\345\207\273\347\251\277\343\200\201\347\274\223\345\255\230\351\233\252\345\264\251\345\222\214\347\203\255\347\202\271\346\225\260\346\215\256\345\244\261\346\225\210\351\227\256\351\242\230\347\232\204\350\247\243\345\206\263\346\226\271\346\241\210.md"	
@@ -0,0 +1,86 @@
+https://mp.weixin.qq.com/s/ks3ztlFfsj00qlCOPcjtOw
+### 1 前言
+
+在我们的平常的项目中多多少少都会使用到缓存，因为一些数据我们没有必要每次查询的时候都去查询到数据库。特别是高 QPS 的系统，每次都去查询数据库，对于你的数据库来说将是灾难。
+
+今天我们不牵涉多级缓存的知识，就把系统使用到的缓存方案，不管是一级还是多级的都统称为缓存，主要是为了讲述使用缓存的时候可能会遇到的一些问题以及一些解决办法。
+
+我们使用缓存时，我们的业务系统大概的调用流程如下图：
+
+<img src = 'img/1320.png'>
+
+当我们查询一条数据时，先去查询缓存，如果缓存有就直接返回，如果没有就去查询数据库，然后返回。这种情况下就可能会出现一些现象。
+
+### 2 缓存穿透
+#### 2.1 什么是缓存穿透
+正常情况下，我们去查询数据都是存在。那么请求去查询一条压根数据库中根本就不存在的数据，也就是缓存和数据库都查询不到这条数据，但是请求每次都会打到数据库上面去。
+
+这种查询不存在数据的现象我们称为缓存穿透。
+
+#### 2.2 穿透带来的问题
+试想一下，如果有黑客会对你的系统进行攻击，拿一个不存在的id 去查询数据，会产生大量的请求到数据库去查询。可能会导致你的数据库由于压力过大而宕掉。
+
+#### 2.3 解决办法
+##### 2.3.1 缓存空值
+之所以会发生穿透，就是因为缓存中没有存储这些空数据的key。从而导致每次查询都到数据库去了。
+
+那么我们就可以为这些key 设置的值设置为null 丢到缓存里面去。后面再出现查询这个key 的请求的时候，直接返回null ,就不用在到 数据库中去走一圈了。但是别忘了设置过期时间。
+
+##### 2.3.2 BloomFilter
+BloomFilter 类似于一个hase set 用来判断某个元素（key）是否存在于某个集合中。具体概念
+
+这种方式在大数据场景应用比较多，比如 Hbase 中使用它去判断数据是否在磁盘上。还有在爬虫场景判断url 是否已经被爬取过。
+
+这种方案可以加在第一种方案中，在缓存之前在加一层 BloomFilter ，在查询的时候先去 BloomFilter 去查询 key 是否存在，如果不存在就直接返回，存在再走查 缓存 -> 查 DB。
+
+流程图如下：
+<img src = 'img/1319.png'>
+#### 2.4 如何选择
+针对于一些恶意攻击，攻击带过来的大量key 是不存在的，那么我们采用第一种方案就会缓存大量不存在 key 的数据。此时我们采用第一种方案就不合适了，我们完全可以先对使用第二种方案进行过滤掉这些key。
+
+针对这种key 异常多，请求重复率比较低的数据，我们就没有必要进行缓存，使用第二种方案直接过滤掉。
+
+对于空数据的key 有限的，重复率比较高的，我们则可以采用第一种方式进行缓存。
+
+
+### 3 缓存击穿
+#### 3.1 什么是击穿
+缓存击穿是我们可能遇到的第二个使用缓存方案可能遇到的问题。
+
+在平常高并发的系统中，大量的请求同时查询一个 key 时，此时 这个key 正好失效了，就会导致大量的请求都打到数据库上面去。这种现象我们成为击穿。
+
+#### 3.2 会带来什么问题
+会造成某一时刻数据库请求量过大，压力剧增。
+
+#### 3.3 如何解决
+上面的现象是多个线程同时去查询数据库的这条数据，那么我们可以在第一个查询数据的请求上使用一个 互斥锁来锁住它。其他的线程走到这一步拿不到锁就等着，等第一个线程查询到了数据，然后做缓存。后面的线程进来发现已经有缓存了，就直接走缓存。
+
+### 4、缓存雪崩
+#### 4.1 什么是缓存雪崩
+缓存的情况是说，当某一时刻发生大规模的缓存失效的情况。比如你的缓存服务宕机了，会有大量的请求进来直接打到DB上面。结果就是DB 称不住，挂掉。
+
+#### 4.2 解决办法
+##### 4.2.1 事前：使用集群缓存，保证缓存服务的高可用
+这种方案就是在发生雪崩前对缓存集群实现高可用，如果是使用 Redis，可以使用 主从+哨兵 ，Redis Cluster 来避免 Redis 全盘崩溃的情况。
+
+##### 4.2.2 事中：使用 ehcache 本地缓存 + Hystrix 限流&降级 ,避免 MySQL 被打死的情况发生。
+使用 ehcache 本地缓存的目的也是考虑在 Redis Cluster 完全不可用的时候，ehcache 本地缓存还能够支撑一阵。
+
+使用 Hystrix 进行 限流 & 降级 ，比如一秒来了5000个请求，我们可以设置假设只能有一秒 2000 个请求能通过这个组件，那么其他剩余的 3000 请求就会走限流逻辑，然后去调用我们自己开发的降级组件（降级）。比如设置的一些默认值呀之类的。以此来保护最后的 MySQL 不会被大量的请求给打死。
+
+##### 4.2.3 事后：开启 Redis 持久化机制，尽快恢复缓存集群
+一旦重启，就能从磁盘上自动加载数据恢复内存中的数据。
+
+防止雪崩方案如下图所示：
+
+<img src = 'img/1321.png'>
+
+### 5 热点数据集中失效问题怎么解决
+我们在设置缓存的时候，一般会给缓存设置一个失效时间，过了这个时间，缓存就失效了。对于一些热点的数据来说，当缓存失效以后会存在大量的请求过来，然后打到数据库去，从而可能导致数据库崩溃的情况。
+
+#### 5.1 解决办法
+##### 5.1.1 设置不同的失效时间
+为了避免这些热点的数据集中失效，那么我们在设置缓存过期时间的时候，我们让他们失效的时间错开。比如在一个基础的时间上加上或者减去一个范围内的随机值。
+
+##### 5.1.2 互斥锁
+结合上面的击穿的情况，在第一个请求去查询数据库的时候对他加一个互斥锁，其余的查询请求都会被阻塞住，直到锁被释放，从而保护数据库。但是也是由于它会阻塞其他的线程，此时系统吞吐量会下降。需要结合实际的业务去考虑是否要这么做。
diff --git "a/04 - Middleware/redis/\351\230\277\351\207\214\344\272\221Redis\345\274\200\345\217\221\350\247\204\350\214\203.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\351\230\277\351\207\214\344\272\221Redis\345\274\200\345\217\221\350\247\204\350\214\203.md"
similarity index 100%
rename from "04 - Middleware/redis/\351\230\277\351\207\214\344\272\221Redis\345\274\200\345\217\221\350\247\204\350\214\203.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/redis/\351\230\277\351\207\214\344\272\221Redis\345\274\200\345\217\221\350\247\204\350\214\203.md"
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/seata(fescar)\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/seata(fescar)\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
new file mode 100644
index 00000000..0fbd23ac
--- /dev/null
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/seata(fescar)\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"	
@@ -0,0 +1,41 @@
+seata(fescar)
+
+https://github.com/seata/seata
+
+There are 3 basic components in Seata:
+
+Transaction Coordinator(TC): Maintain status of global and branch transactions, drive the global commit or rollback.
+Transaction Manager(TM): Define the scope of global transaction: begin a global transaction, commit or rollback a global transaction.
+Resource Manager(RM): Manage resources that branch transactions working on, talk to TC for registering branch transactions and reporting status of branch transactions, and drive the branch transaction commit or rollback.
+
+FESCAR有三个基础组件:
+
+* `Transaction Coordinator(TC)`: 全局和分支事务的状态的保持，驱动这个全局的提交和回滚.
+* `Transaction Manager(TM)`: 明确全局事务的范围：开始一个全局事务，提交或者回滚一个全局事务.
+* `Resource Manager(RM)`: 管理分支事务工作资源，告诉TC，注册这个分支事务和上报分支事务的状态，驱动分支事务的的提交和回滚。
+
+<img src="img/seata(fescar)分布式事务1.png"/>
+
+
+A typical lifecycle of Seata managed distributed transaction:
+
+TM asks TC to begin a new global transaction. TC generates an XID representing the global transaction.
+XID is propagated through microservices' invoke chain.
+RM register local transaction as a branch of the corresponding global transaction of XID to TC.
+TM asks TC for committing or rollbacking the corresponding global transaction of XID.
+TC drives all branch transactions under the corresponding global transaction of XID to finish branch committing or rollbacking.
+
+一个典型的FESCAR管理分布式事务的生命周期：
+
+* TM询问TC开启一个新的全局事务，TC生成一个XID，代表这个全局事务
+* XID 通过微服务的调用链传播
+* RM将本地事务注册为XID到TC的相应全局事务的分支。
+* TM要求TC提交或回滚XID的对应的全局事务。
+* TC驱动整个分支在XID对应的全局事务下，去完成分支的提交或者回滚
+* TM asks TC to begin a new global transaction. TC generates an XID representing the global transaction.
+* XID is propagated through microservices' invoke chain.
+* RM register local transaction as a branch of the corresponding global transaction of XID to TC.
+* TM asks TC for committing or rollbacking the corresponding global transaction of XID.
+* TC drives all branch transactions under the corresponding global transaction of XID to finish branch committing or rollbacking.
+
+<img src="img/10115652-d1465ce8ff6e0218.png"/>
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/ActiveMQ/activeMQ\345\272\225\345\261\202\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/ActiveMQ/activeMQ\345\272\225\345\261\202\345\256\236\347\216\260\345\216\237\347\220\206.md"
similarity index 98%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/ActiveMQ/activeMQ\345\272\225\345\261\202\345\256\236\347\216\260\345\216\237\347\220\206.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/ActiveMQ/activeMQ\345\272\225\345\261\202\345\256\236\347\216\260\345\216\237\347\220\206.md"
index 8813ffba..3ba99f7f 100644
--- "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/ActiveMQ/activeMQ\345\272\225\345\261\202\345\256\236\347\216\260\345\216\237\347\220\206.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/ActiveMQ/activeMQ\345\272\225\345\261\202\345\256\236\347\216\260\345\216\237\347\220\206.md"	
@@ -1,24 +1,24 @@
-在讨论具体方式的时候，我们先看看使用activemq需要启动服务的主要过程。
-按照JMS的规范，我们首先需要获得一个JMS connection factory.，通过这个connection factory来创建connection.在这个基础之上我们再创建session, destination, producer和consumer。因此主要的几个步骤如下：
-1. 获得JMS connection factory. 通过我们提供特定环境的连接信息来构造factory。
-2. 利用factory构造JMS connection
-3. 启动connection
-4. 通过connection创建JMS session.
-5. 指定JMS destination.
-6. 创建JMS producer或者创建JMS message并提供destination.
-7. 创建JMS consumer或注册JMS message listener.
-8. 发送和接收JMS message.
-9. 关闭所有JMS资源，包括connection, session, producer, consumer等。
-Java Message Service：是Java平台上有关面向消息中间件的技术规范。
-
-执行流程：
-通过生产者配置文件配置Spring Caching连接工厂和JmsTemplate的类型（Queue，Topic），发布消息时通过调用jmsTemplate的send(“bos_sms”, new MessageCreator())方
-法(第一个参数与消费者配置文件中的 监听器 一致，new MessageCreator()是一个接口，通过
-mapMessage.setString(“randomCode”, randomCode)添加信息)，当消息发布成功之后，消费者会通过消费者配置文件中对应的的监听器（Queue，Topic）监听到消息队列中
-有新的消息，则对应的()消费者方法（smsConsumer）执行，该方法需要实现MessageListener 接口
-
-配置信息：
-生产者配置：ConnectionFactory生产ConnectionFactory—》定义JmsTemplate的Queue类型
-生产发布消息：jmsTemplate.send(“bos_sms”, new MessageCreator() {}) bos_sms:消费者（在消费者配置文件中），new MessageCreator() {}：中的Message存储相关消息具体内容
-消费配置：ConnectionFactory生产ConnectionFactory—》定义Queue监听器（监听到有mq，则执行消费者代码）
-消费者消费消息：消费者实现MessageListener 接口。
+在讨论具体方式的时候，我们先看看使用activemq需要启动服务的主要过程。
+按照JMS的规范，我们首先需要获得一个JMS connection factory.，通过这个connection factory来创建connection.在这个基础之上我们再创建session, destination, producer和consumer。因此主要的几个步骤如下：
+1. 获得JMS connection factory. 通过我们提供特定环境的连接信息来构造factory。
+2. 利用factory构造JMS connection
+3. 启动connection
+4. 通过connection创建JMS session.
+5. 指定JMS destination.
+6. 创建JMS producer或者创建JMS message并提供destination.
+7. 创建JMS consumer或注册JMS message listener.
+8. 发送和接收JMS message.
+9. 关闭所有JMS资源，包括connection, session, producer, consumer等。
+Java Message Service：是Java平台上有关面向消息中间件的技术规范。
+
+执行流程：
+通过生产者配置文件配置Spring Caching连接工厂和JmsTemplate的类型（Queue，Topic），发布消息时通过调用jmsTemplate的send(“bos_sms”, new MessageCreator())方
+法(第一个参数与消费者配置文件中的 监听器 一致，new MessageCreator()是一个接口，通过
+mapMessage.setString(“randomCode”, randomCode)添加信息)，当消息发布成功之后，消费者会通过消费者配置文件中对应的的监听器（Queue，Topic）监听到消息队列中
+有新的消息，则对应的()消费者方法（smsConsumer）执行，该方法需要实现MessageListener 接口
+
+配置信息：
+生产者配置：ConnectionFactory生产ConnectionFactory—》定义JmsTemplate的Queue类型
+生产发布消息：jmsTemplate.send(“bos_sms”, new MessageCreator() {}) bos_sms:消费者（在消费者配置文件中），new MessageCreator() {}：中的Message存储相关消息具体内容
+消费配置：ConnectionFactory生产ConnectionFactory—》定义Queue监听器（监听到有mq，则执行消费者代码）
+消费者消费消息：消费者实现MessageListener 接口。
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/4.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/4.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/4.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/4.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/5.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/5.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/5.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/5.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/6.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/6.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/6.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/6.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/7.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/7.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/7.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/7.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka_tuopo.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka_tuopo.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka_tuopo.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka_tuopo.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka\345\216\237\347\220\206\346\267\261\345\205\245\347\240\224\347\251\266.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka\345\216\237\347\220\206\346\267\261\345\205\245\347\240\224\347\251\266.md"
similarity index 98%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka\345\216\237\347\220\206\346\267\261\345\205\245\347\240\224\347\251\266.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka\345\216\237\347\220\206\346\267\261\345\205\245\347\240\224\347\251\266.md"
index 05acdd1a..90ed146e 100644
--- "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka\345\216\237\347\220\206\346\267\261\345\205\245\347\240\224\347\251\266.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/kafka\345\216\237\347\220\206\346\267\261\345\205\245\347\240\224\347\251\266.md"	
@@ -1,326 +1,326 @@
-https://www.cnblogs.com/xifenglou/p/7251112.html
-
-## 一、为什么需要消息系统
-  1. `解耦`：
-  　　允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。
-  2. `冗余`：
-  　　消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。许多消息队列所采用的"插入-获取-删除"范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。
-  3. `扩展性`：
-  　　因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的，只要另外增加处理过程即可。
-  4. `灵活性 & 峰值处理能力`：
-  　　在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃。
-  5. `可恢复性`：
-  　　系统的一部分组件失效时，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。
-  6. `顺序保证`：
-  　　在大多使用场景下，数据处理的顺序都很重要。大部分消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理。（Kafka 保证一个 Partition 内的消息的有序性）
-  7. `缓冲`：
-  　　有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。
-  8. `异步通信`：
-  　　很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。
-
-## 二、kafka 架构
-### 2.1 拓扑结构
-
-  如下图1：
-  <img src = "kafka_tuopo.png">
-
-### 2.2 相关概念
-
-  如图.1中，kafka 相关名词解释如下：
-  1. producer：
-  　　消息生产者，发布消息到 kafka 集群的终端或服务。
-  2. broker：
-  　　kafka 集群中包含的服务器。
-  3. topic：
-  　　每条发布到 kafka 集群的消息属于的类别，即 kafka 是面向 topic 的。
-  4. partition：
-  　　partition 是物理上的概念，每个 topic 包含一个或多个 partition。kafka 分配的单位是 partition。
-  5. consumer：
-  　　从 kafka 集群中消费消息的终端或服务。
-  6. Consumer group：
-  　　high-level consumer API 中，每个 consumer 都属于一个 consumer group，每条消息只能被 consumer group 中的一个 Consumer 消费，但可以被多个 consumer group 消费。
-  7. replica：
-  　　partition 的副本，保障 partition 的高可用。
-  8. leader：
-  　　replica 中的一个角色， producer 和 consumer 只跟 leader 交互。
-  9. follower：
-  　　replica 中的一个角色，从 leader 中复制数据。
-  10. controller：
-  　　kafka 集群中的其中一个服务器，用来进行 leader election 以及 各种 failover。
-  12. zookeeper：
-  　　kafka 通过 zookeeper 来存储集群的 meta 信息。
-
-### 2.3 zookeeper 节点
-
-  kafka 在 zookeeper 中的存储结构如下图所示：
-  <img src = "zookeeper_node.png">
-
-## 三、producer 发布消息
-
-### 3.1 写入方式
-
-  producer 采用 `push` 模式将消息发布到 broker，每条消息都被 append 到 patition 中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障 kafka 吞吐率）。
-
-### 3.2 消息路由
-  producer 发送消息到 broker 时，会根据分区算法选择将其存储到哪一个 partition。其路由机制为：
-    1. 指定了 patition，则直接使用；
-    2. 未指定 patition 但指定 key，通过对 key 的 value 进行hash 选出一个 patition
-    3. patition 和 key 都未指定，使用轮询选出一个 patition。
-  附上 java 客户端分区源码，一目了然：
-  ```java
-  //创建消息实例
-  public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value) {
-       if (topic == null)
-            throw new IllegalArgumentException("Topic cannot be null");
-       if (timestamp != null && timestamp < 0)
-            throw new IllegalArgumentException("Invalid timestamp " + timestamp);
-       this.topic = topic;
-       this.partition = partition;
-       this.key = key;
-       this.value = value;
-       this.timestamp = timestamp;
-  }
-
-  //计算 patition，如果指定了 patition 则直接使用，否则使用 key 计算
-  private int partition(ProducerRecord<K, V> record, byte[] serializedKey , byte[] serializedValue, Cluster cluster) {
-       Integer partition = record.partition();
-       if (partition != null) {
-            List<PartitionInfo> partitions = cluster.partitionsForTopic(record.topic());
-            int lastPartition = partitions.size() - 1;
-            if (partition < 0 || partition > lastPartition) {
-                 throw new IllegalArgumentException(String.format("Invalid partition given with record: %d is not in the range [0...%d].", partition, lastPartition));
-            }
-            return partition;
-       }
-       return this.partitioner.partition(record.topic(), record.key(), serializedKey, record.value(), serializedValue, cluster);
-  }
-
-  // 使用 key 选取 patition
-  public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
-       List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
-       int numPartitions = partitions.size();
-       if (keyBytes == null) {
-            int nextValue = counter.getAndIncrement();
-            List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);
-            if (availablePartitions.size() > 0) {
-                 int part = DefaultPartitioner.toPositive(nextValue) % availablePartitions.size();
-                 return availablePartitions.get(part).partition();
-            } else {
-                 return DefaultPartitioner.toPositive(nextValue) % numPartitions;
-            }
-       } else {
-            //对 keyBytes 进行 hash 选出一个 patition
-            return DefaultPartitioner.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
-       }
-  }
-  ```
-
-### 3.3 写入流程
-  producer 写入消息序列图如下所示：
-  <img src ="producer_write.png">
-  流程说明：
-      1. producer 先从 zookeeper 的 "/brokers/.../state" 节点找到该 partition 的 leader
-      2. producer 将消息发送给该 leader
-      3. leader 将消息写入本地 log
-      4. followers 从 leader pull 消息，写入本地 log 后 leader 发送 ACK
-      5. leader 收到所有 ISR 中的 replica 的 ACK 后，增加 HW（high watermark，最后 commit 的 offset） 并向 producer 发送 ACK
-
-### 3.4 producer delivery guarantee
-  一般情况下存在三种情况：
-      1. At most once 消息可能会丢，但绝不会重复传输
-      2. At least one 消息绝不会丢，但可能会重复传输
-      3. Exactly once 每条消息肯定会被传输一次且仅传输一次
-  当 producer 向 broker 发送消息时，一旦这条消息被 commit，由于 replication 的存在，它就不会丢。但是如果 producer 发送数据给 broker 后，遇到网络问题而造成通信中断，那 Producer 就无法判断该条消息是否已经 commit。虽然 Kafka 无法确定网络故障期间发生了什么，但是 producer 可以生成一种类似于主键的东西，发生故障时幂等性的重试多次，这样就做到了 Exactly once，但目前还并未实现。所以目前默认情况下一条消息从 producer 到 broker 是确保了 At least once，可通过设置 producer 异步发送实现At most once。
-
-## 四、broker 保存消息
-### 4.1 存储方式
-  物理上把 topic 分成一个或多个 patition（对应 server.properties 中的 num.partitions=3 配置），每个 patition 物理上对应一个文件夹（该文件夹存储该 patition 的所有消息和索引文件），如下：
-  <img src ="4.png">
-### 4.2 存储策略
-  无论消息是否被消费，kafka 都会保留所有消息。有两种策略可以删除旧数据：
-      1. 基于时间：log.retention.hours=168
-      2. 基于大小：log.retention.bytes=1073741824
-  需要注意的是，因为Kafka读取特定消息的时间复杂度为O(1)，即与文件大小无关，所以这里删除过期文件与提高 Kafka 性能无关。
-
-### 4.3 topic 创建与删除
-#### 4.3.1 创建 topic
-  创建 topic 的序列图如下所示：
-  <img src="5.png">
-  流程说明：
-      1. controller 在 ZooKeeper 的 /brokers/topics 节点上注册 watcher，当 topic 被创建，则 controller 会通过 watch 得到该 topic 的 partition/replica 分配。
-      2. controller从 /brokers/ids 读取当前所有可用的 broker 列表，对于 set_p 中的每一个 partition：
-      	2.1 从分配给该 partition 的所有 replica（称为AR）中任选一个可用的 broker 作为新的 leader，并将AR设置为新的 ISR
-      	2.2 将新的 leader 和 ISR 写入 /brokers/topics/[topic]/partitions/[partition]/state
-      3. controller 通过 RPC 向相关的 broker 发送 LeaderAndISRRequest。
-#### 4.3.2 删除 topic
-  删除 topic 的序列图如下所示：
-  <img src="6.png">
-  流程说明：
-      1. controller 在 zooKeeper 的 /brokers/topics 节点上注册 watcher，当 topic 被删除，则 controller 会通过 watch 得到该 topic 的 partition/replica 分配。
-      2. 若 delete.topic.enable=false，结束；否则 controller 注册在 /admin/delete_topics 上的 watch 被 fire，controller 通过回调向对应的 broker 发送 StopReplicaRequest。
-
-## 五、kafka HA
-### 5.1 replication
-  如图.1所示，同一个 partition 可能会有多个 replica（对应 server.properties 配置中的 default.replication.factor=N）。没有 replica 的情况下，一旦 broker 宕机，其上所有 patition 的数据都不可被消费，同时 producer 也不能再将数据存于其上的 patition。引入replication 之后，同一个 partition 可能会有多个 replica，而这时需要在这些 replica 之间选出一个 leader，producer 和 consumer 只与这个 leader 交互，其它 replica 作为 follower 从 leader 中复制数据。
-
-  Kafka 分配 Replica 的算法如下：
-      1. 将所有 broker（假设共 n 个 broker）和待分配的 partition 排序
-      2. 将第 i 个 partition 分配到第（i mod n）个 broker 上
-      3. 将第 i 个 partition 的第 j 个 replica 分配到第（(i + j) mode n）个 broker上
-### 5.2 leader failover
-  当 partition 对应的 leader 宕机时，需要从 follower 中选举出新 leader。在选举新leader时，一个基本的原则是，新的 leader 必须拥有旧 leader commit 过的所有消息。
-
-  kafka 在 zookeeper 中（/brokers/.../state）动态维护了一个 ISR（in-sync replicas），由3.3节的写入流程可知 ISR 里面的所有 replica 都跟上了 leader，只有 ISR 里面的成员才能选为 leader。对于 f+1 个 replica，一个 partition 可以在容忍 f 个 replica 失效的情况下保证消息不丢失。
-
-  当所有 replica 都不工作时，有两种可行的方案：
-      1. 等待 ISR 中的任一个 replica 活过来，并选它作为 leader。可保障数据不丢失，但时间可能相对较长。
-      2. 选择第一个活过来的 replica（不一定是 ISR 成员）作为 leader。无法保障数据不丢失，但相对不可用时间较短。
-
-  kafka 0.8.* 使用第二种方式。
-
-  kafka 通过 Controller 来选举 leader，流程请参考5.3节。
-
-### 5.3 broker failover
-  kafka broker failover 序列图如下所示：
-  <img src="7.png">
-  流程说明：
-      1. controller 在 zookeeper 的 /brokers/ids/[brokerId] 节点注册 Watcher，当 broker 宕机时 zookeeper 会 fire watch
-      2. controller 从 /brokers/ids 节点读取可用broker
-      3. controller决定set_p，该集合包含宕机 broker 上的所有 partition
-      4. 对 set_p 中的每一个 partition
-          4.1 从/brokers/topics/[topic]/partitions/[partition]/state 节点读取 ISR
-          4.2 决定新 leader（如4.3节所描述）
-          4.3 将新 leader、ISR、controller_epoch 和 leader_epoch 等信息写入 state 节点
-      5. 通过 RPC 向相关 broker 发送 leaderAndISRRequest 命令
-### 5.4 controller failover
-  当 controller 宕机时会触发 controller failover。每个 broker 都会在 zookeeper 的 "/controller" 节点注册 watcher，当 controller 宕机时 zookeeper 中的临时节点消失，所有存活的 broker 收到 fire 的通知，每个 broker 都尝试创建新的 controller path，只有一个竞选成功并当选为 controller。
-
-  当新的 controller 当选时，会触发 KafkaController.onControllerFailover 方法，在该方法中完成如下操作：
-      1. 读取并增加 Controller Epoch。
-      2. 在 reassignedPartitions Patch(/admin/reassign_partitions) 上注册 watcher。
-      3. 在 preferredReplicaElection Path(/admin/preferred_replica_election) 上注册 watcher。
-      4. 通过 partitionStateMachine 在 broker Topics Patch(/brokers/topics) 上注册 watcher。
-      5. 若 delete.topic.enable=true（默认值是 false），则 partitionStateMachine 在 Delete Topic Patch(/admin/delete_topics) 上注册 watcher。
-      6. 通过 replicaStateMachine在 Broker Ids Patch(/brokers/ids)上注册Watch。
-      7. 初始化 ControllerContext 对象，设置当前所有 topic，“活”着的 broker 列表，所有 partition 的 leader 及 ISR等。
-      8. 启动 replicaStateMachine 和 partitionStateMachine。
-      9. 将 brokerState 状态设置为 RunningAsController。
-      10. 将每个 partition 的 Leadership 信息发送给所有“活”着的 broker。
-      11. 若 auto.leader.rebalance.enable=true（默认值是true），则启动 partition-rebalance 线程。
-      12. 若 delete.topic.enable=true 且Delete Topic Patch(/admin/delete_topics)中有值，则删除相应的Topic。
-## 6. consumer 消费消息
-### 6.1 consumer API
-  kafka 提供了两套 consumer API：
-      1. The high-level Consumer API
-      2. The SimpleConsumer API
-      其中 high-level consumer API 提供了一个从 kafka 消费数据的高层抽象，而 SimpleConsumer API 则需要开发人员更多地关注细节。
-
-#### 6.1.1 The high-level consumer API
-  high-level consumer API 提供了 consumer group 的语义，一个消息只能被 group 内的一个 consumer 所消费，且 consumer 消费消息时不关注 offset，最后一个 offset 由 zookeeper 保存。
-
-  使用 high-level consumer API 可以是多线程的应用，应当注意：
-      1. 如果消费线程大于 patition 数量，则有些线程将收不到消息
-      2. 如果 patition 数量大于线程数，则有些线程多收到多个 patition 的消息
-      3. 如果一个线程消费多个 patition，则无法保证你收到的消息的顺序，而一个 patition 内的消息是有序的
-#### 6.1.2 The SimpleConsumer API
-  如果你想要对 patition 有更多的控制权，那就应该使用 SimpleConsumer API，比如：
-      1. 多次读取一个消息
-      2. 只消费一个 patition 中的部分消息
-      3. 使用事务来保证一个消息仅被消费一次
-
-  但是使用此 API 时，partition、offset、broker、leader 等对你不再透明，需要自己去管理。你需要做大量的额外工作：
-      1. 必须在应用程序中跟踪 offset，从而确定下一条应该消费哪条消息
-      2. 应用程序需要通过程序获知每个 Partition 的 leader 是谁
-      3. 需要处理 leader 的变更
-  使用 SimpleConsumer API 的一般流程如下：
-      1. 查找到一个“活着”的 broker，并且找出每个 partition 的 leader
-      2. 找出每个 partition 的 follower
-      3. 定义好请求，该请求应该能描述应用程序需要哪些数据
-      4. fetch 数据
-      5. 识别 leader 的变化，并对之作出必要的响应
-
-  以下针对 high-level Consumer API 进行说明。
-
-### 6.2 consumer group
-  如 2.2 节所说， kafka 的分配单位是 patition。每个 consumer 都属于一个 group，一个 partition 只能被同一个 group 内的一个 consumer 所消费（也就保障了一个消息只能被 group 内的一个 consuemr 所消费），但是多个 group 可以同时消费这个 partition。
-
-  kafka 的设计目标之一就是同时实现离线处理和实时处理，根据这一特性，可以使用 spark/Storm 这些实时处理系统对消息在线处理，同时使用 Hadoop 批处理系统进行离线处理，还可以将数据备份到另一个数据中心，只需要保证这三者属于不同的 consumer group。如下图所示：
-
-### 6.3 消费方式
-  consumer 采用 pull 模式从 broker 中读取数据。
-
-  push 模式很难适应消费速率不同的消费者，因为消息发送速率是由 broker 决定的。它的目标是尽可能以最快速度传递消息，但是这样很容易造成 consumer 来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而 pull 模式则可以根据 consumer 的消费能力以适当的速率消费消息。
-
-  对于 Kafka 而言，pull 模式更合适，它可简化 broker 的设计，consumer 可自主控制消费消息的速率，同时 consumer 可以自己控制消费方式——即可批量消费也可逐条消费，同时还能选择不同的提交方式从而实现不同的传输语义。
-
-### 6.4 consumer delivery guarantee
-  如果将 consumer 设置为 autocommit，consumer 一旦读到数据立即自动 commit。如果只讨论这一读取消息的过程，那 Kafka 确保了 Exactly once。
-
-  但实际使用中应用程序并非在 consumer 读取完数据就结束了，而是要进行进一步处理，而数据处理与 commit 的顺序在很大程度上决定了consumer delivery guarantee：
-
-  1. 读完消息先 commit 再处理消息。
-    这种模式下，如果 consumer 在 commit 后还没来得及处理消息就 crash 了，下次重新开始工作后就无法读到刚刚已提交而未处理的消息，这就对应于 At most once
-  2. 读完消息先处理再 commit。
-    这种模式下，如果在处理完消息之后 commit 之前 consumer crash 了，下次重新开始工作时还会处理刚刚未 commit 的消息，实际上该消息已经被处理过了。这就对应于 At least once。
-  3. 如果一定要做到 Exactly once，就需要协调 offset 和实际操作的输出。
-    精典的做法是引入两阶段提交。如果能让 offset 和操作输入存在同一个地方，会更简洁和通用。这种方式可能更好，因为许多输出系统可能不支持两阶段提交。比如，consumer 拿到数据后可能把数据放到 HDFS，如果把最新的 offset 和数据本身一起写到 HDFS，那就可以保证数据的输出和 offset 的更新要么都完成，要么都不完成，间接实现 Exactly once。（目前就 high-level API而言，offset 是存于Zookeeper 中的，无法存于HDFS，而SimpleConsuemr API的 offset 是由自己去维护的，可以将之存于 HDFS 中）
-
-  总之，Kafka 默认保证 At least once，并且允许通过设置 producer 异步提交来实现 At most once（见文章《kafka consumer防止数据丢失》http://kane-xie.iteye.com/blog/2225085）。而 Exactly once 要求与外部存储系统协作，幸运的是 kafka 提供的 offset 可以非常直接非常容易得使用这种方式。
-
-  更多关于 kafka 传输语义的信息请参考《Message Delivery Semantics》http://kafka.apache.org/documentation.html#semantics。
-
-### 6.5 consumer rebalance
-  当有 consumer 加入或退出、以及 partition 的改变（如 broker 加入或退出）时会触发 rebalance。consumer rebalance算法如下：
-      1. 将目标 topic 下的所有 partirtion 排序，存于PT
-      2. 对某 consumer group 下所有 consumer 排序，存于 CG，第 i 个consumer 记为 Ci
-      3. N=size(PT)/size(CG)，向上取整
-      4. 解除 Ci 对原来分配的 partition 的消费权（i从0开始）
-      5. 将第i*N到（i+1）* N-1个 partition 分配给 Ci
-  在 0.8.* 版本，每个 consumer 都只负责调整自己所消费的 partition，为了保证整个consumer group 的一致性，当一个 consumer 触发了 rebalance 时，该 consumer group 内的其它所有其它 consumer 也应该同时触发 rebalance。这会导致以下几个问题：
-      1. Herd effect
-      　　任何 broker 或者 consumer 的增减都会触发所有的 consumer 的 rebalance
-      2. Split Brain
-      　　每个 consumer 分别单独通过 zookeeper 判断哪些 broker 和 consumer 宕机了，那么不同 consumer 在同一时刻从 zookeeper 看到的 view 就可能不一样，这是由 zookeeper 的特性决定的，这就会造成不正确的 reblance 尝试。
-      3. 调整结果不可控
-      　　所有的 consumer 都并不知道其它 consumer 的 rebalance 是否成功，这可能会导致 kafka 工作在一个不正确的状态。
-  基于以上问题，kafka 设计者考虑在0.9.* 版本开始使用中心 coordinator 来控制 consumer rebalance，然后又从简便性和验证要求两方面考虑，计划在 consumer 客户端实现分配方案。（见文章《Kafka Detailed Consumer Coordinator Design》 https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Detailed+Consumer+Coordinator+Design#KafkaDetailedConsumerCoordinatorDesign-WARN:Thisisanobsoletedesign.Thedesignthat%27simplementedinKafka0.9.0isdescribedinthiswiki. 和《Kafka Client-side Assignment Proposal》https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Client-side+Assignment+Proposal），此处不再赘述。
-
-## 七、注意事项
-### 7.1 producer 无法发送消息的问题
-最开始在本机搭建了kafka伪集群，本地 producer 客户端成功发布消息至 broker。随后在服务器上搭建了 kafka 集群，在本机连接该集群，producer 却无法发布消息到 broker（奇怪也没有抛错）。最开始怀疑是 iptables 没开放，于是开放端口，结果还不行（又开始是代码问题、版本问题等等，倒腾了很久）。最后没办法，一项一项查看 server.properties 配置，发现以下两个配置：
-```
-# The address the socket server listens on. It will get the value returned from
-# java.net.InetAddress.getCanonicalHostName() if not configured.
-#   FORMAT:
-#     listeners = security_protocol://host_name:port
-#   EXAMPLE:
-#     listeners = PLAINTEXT://your.host.name:9092
-listeners=PLAINTEXT://:9092
-　# Hostname and port the broker will advertise to producers and consumers. If not set,
-　# it uses the value for "listeners" if configured. Otherwise, it will use the value
-　# returned from java.net.InetAddress.getCanonicalHostName().
-　#advertised.listeners=PLAINTEXT://your.host.name:9092
-```
-以上说的就是 advertised.listeners 是 broker 给 producer 和 consumer 连接使用的，如果没有设置，就使用 listeners，而如果 host_name 没有设置的话，就使用 java.net.InetAddress.getCanonicalHostName() 方法返回的主机名。
-
-修改方法：
-1. listeners=PLAINTEXT://121.10.26.XXX:9092
-2. advertised.listeners=PLAINTEXT://121.10.26.XXX:9092
-修改后重启服务，正常工作。关于更多 kafka 配置说明，见文章《Kafka学习整理三(borker(0.9.0及0.10.0)配置)》https://blog.csdn.net/louisliaoxh/article/details/51516084。
-
-## 八、参考文章
-1. 《Kafka剖析（一）：Kafka背景及架构介绍》    http://www.infoq.com/cn/articles/kafka-analysis-part-1/
-2. 《Kafka设计解析（二）：Kafka High Availability （上）》 http://www.infoq.com/cn/articles/kafka-analysis-part-2/
-3. 《Kafka设计解析（三）：Kafka High Availability （下）》 http://www.infoq.com/cn/articles/kafka-analysis-part-3/
-4. 《Kafka设计解析（四）：Kafka Consumer解析》 http://www.infoq.com/cn/articles/kafka-analysis-part-4/
-5. 《Kafka设计解析（五）：Kafka Benchmark》 http://www.infoq.com/cn/articles/kafka-analysis-part-5
-6. 《Kafka学习整理三(borker(0.9.0及0.10.0)配置)》 https://blog.csdn.net/louisliaoxh/article/details/51516084
-7. 《Using the High Level Consumer》  https://cwiki.apache.org/confluence/display/KAFKA/Consumer+Group+Example
-8. 《Using SimpleConsumer》 https://cwiki.apache.org/confluence/display/KAFKA/0.8.0+SimpleConsumer+Example
-9. 《Consumer Client Re-Design》    https://cwiki.apache.org/confluence/display/KAFKA/Consumer+Client+Re-Design
-10. 《Message Delivery Semantics》 http://kafka.apache.org/documentation.html#semantics 4.6
-11. 《Kafka Detailed Consumer Coordinator Design》 https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Detailed+Consumer+Coordinator+Design#KafkaDetailedConsumerCoordinatorDesign-WARN:Thisisanobsoletedesign.Thedesignthat%27simplementedinKafka0.9.0isdescribedinthiswiki.
-12. 《Kafka Client-side Assignment Proposal》 https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Client-side+Assignment+Proposal
-13. 《Kafka和DistributedLog技术对比》 http://www.infoq.com/cn/articles/technology-comparison-of-kafka-and-distributedlog?utm_campaign=rightbar_v2&utm_source=infoq&utm_medium=articles_link&utm_content=link_text
-14. 《kafka安装和启动》 http://orchome.com/6
-15. 《kafka consumer防止数据丢失》 http://kane-xie.iteye.com/blog/2225085
+https://www.cnblogs.com/xifenglou/p/7251112.html
+
+## 一、为什么需要消息系统
+  1. `解耦`：
+  　　允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。
+  2. `冗余`：
+  　　消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。许多消息队列所采用的"插入-获取-删除"范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。
+  3. `扩展性`：
+  　　因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的，只要另外增加处理过程即可。
+  4. `灵活性 & 峰值处理能力`：
+  　　在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃。
+  5. `可恢复性`：
+  　　系统的一部分组件失效时，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。
+  6. `顺序保证`：
+  　　在大多使用场景下，数据处理的顺序都很重要。大部分消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理。（Kafka 保证一个 Partition 内的消息的有序性）
+  7. `缓冲`：
+  　　有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。
+  8. `异步通信`：
+  　　很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。
+
+## 二、kafka 架构
+### 2.1 拓扑结构
+
+  如下图1：
+  <img src = "kafka_tuopo.png">
+
+### 2.2 相关概念
+
+  如图.1中，kafka 相关名词解释如下：
+  1. producer：
+  　　消息生产者，发布消息到 kafka 集群的终端或服务。
+  2. broker：
+  　　kafka 集群中包含的服务器。
+  3. topic：
+  　　每条发布到 kafka 集群的消息属于的类别，即 kafka 是面向 topic 的。
+  4. partition：
+  　　partition 是物理上的概念，每个 topic 包含一个或多个 partition。kafka 分配的单位是 partition。
+  5. consumer：
+  　　从 kafka 集群中消费消息的终端或服务。
+  6. Consumer group：
+  　　high-level consumer API 中，每个 consumer 都属于一个 consumer group，每条消息只能被 consumer group 中的一个 Consumer 消费，但可以被多个 consumer group 消费。
+  7. replica：
+  　　partition 的副本，保障 partition 的高可用。
+  8. leader：
+  　　replica 中的一个角色， producer 和 consumer 只跟 leader 交互。
+  9. follower：
+  　　replica 中的一个角色，从 leader 中复制数据。
+  10. controller：
+  　　kafka 集群中的其中一个服务器，用来进行 leader election 以及 各种 failover。
+  12. zookeeper：
+  　　kafka 通过 zookeeper 来存储集群的 meta 信息。
+
+### 2.3 zookeeper 节点
+
+  kafka 在 zookeeper 中的存储结构如下图所示：
+  <img src = "zookeeper_node.png">
+
+## 三、producer 发布消息
+
+### 3.1 写入方式
+
+  producer 采用 `push` 模式将消息发布到 broker，每条消息都被 append 到 patition 中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障 kafka 吞吐率）。
+
+### 3.2 消息路由
+  producer 发送消息到 broker 时，会根据分区算法选择将其存储到哪一个 partition。其路由机制为：
+    1. 指定了 patition，则直接使用；
+    2. 未指定 patition 但指定 key，通过对 key 的 value 进行hash 选出一个 patition
+    3. patition 和 key 都未指定，使用轮询选出一个 patition。
+  附上 java 客户端分区源码，一目了然：
+  ```java
+  //创建消息实例
+  public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value) {
+       if (topic == null)
+            throw new IllegalArgumentException("Topic cannot be null");
+       if (timestamp != null && timestamp < 0)
+            throw new IllegalArgumentException("Invalid timestamp " + timestamp);
+       this.topic = topic;
+       this.partition = partition;
+       this.key = key;
+       this.value = value;
+       this.timestamp = timestamp;
+  }
+
+  //计算 patition，如果指定了 patition 则直接使用，否则使用 key 计算
+  private int partition(ProducerRecord<K, V> record, byte[] serializedKey , byte[] serializedValue, Cluster cluster) {
+       Integer partition = record.partition();
+       if (partition != null) {
+            List<PartitionInfo> partitions = cluster.partitionsForTopic(record.topic());
+            int lastPartition = partitions.size() - 1;
+            if (partition < 0 || partition > lastPartition) {
+                 throw new IllegalArgumentException(String.format("Invalid partition given with record: %d is not in the range [0...%d].", partition, lastPartition));
+            }
+            return partition;
+       }
+       return this.partitioner.partition(record.topic(), record.key(), serializedKey, record.value(), serializedValue, cluster);
+  }
+
+  // 使用 key 选取 patition
+  public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
+       List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
+       int numPartitions = partitions.size();
+       if (keyBytes == null) {
+            int nextValue = counter.getAndIncrement();
+            List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);
+            if (availablePartitions.size() > 0) {
+                 int part = DefaultPartitioner.toPositive(nextValue) % availablePartitions.size();
+                 return availablePartitions.get(part).partition();
+            } else {
+                 return DefaultPartitioner.toPositive(nextValue) % numPartitions;
+            }
+       } else {
+            //对 keyBytes 进行 hash 选出一个 patition
+            return DefaultPartitioner.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
+       }
+  }
+  ```
+
+### 3.3 写入流程
+  producer 写入消息序列图如下所示：
+  <img src ="producer_write.png">
+  流程说明：
+      1. producer 先从 zookeeper 的 "/brokers/.../state" 节点找到该 partition 的 leader
+      2. producer 将消息发送给该 leader
+      3. leader 将消息写入本地 log
+      4. followers 从 leader pull 消息，写入本地 log 后 leader 发送 ACK
+      5. leader 收到所有 ISR 中的 replica 的 ACK 后，增加 HW（high watermark，最后 commit 的 offset） 并向 producer 发送 ACK
+
+### 3.4 producer delivery guarantee
+  一般情况下存在三种情况：
+      1. At most once 消息可能会丢，但绝不会重复传输
+      2. At least one 消息绝不会丢，但可能会重复传输
+      3. Exactly once 每条消息肯定会被传输一次且仅传输一次
+  当 producer 向 broker 发送消息时，一旦这条消息被 commit，由于 replication 的存在，它就不会丢。但是如果 producer 发送数据给 broker 后，遇到网络问题而造成通信中断，那 Producer 就无法判断该条消息是否已经 commit。虽然 Kafka 无法确定网络故障期间发生了什么，但是 producer 可以生成一种类似于主键的东西，发生故障时幂等性的重试多次，这样就做到了 Exactly once，但目前还并未实现。所以目前默认情况下一条消息从 producer 到 broker 是确保了 At least once，可通过设置 producer 异步发送实现At most once。
+
+## 四、broker 保存消息
+### 4.1 存储方式
+  物理上把 topic 分成一个或多个 patition（对应 server.properties 中的 num.partitions=3 配置），每个 patition 物理上对应一个文件夹（该文件夹存储该 patition 的所有消息和索引文件），如下：
+  <img src ="4.png">
+### 4.2 存储策略
+  无论消息是否被消费，kafka 都会保留所有消息。有两种策略可以删除旧数据：
+      1. 基于时间：log.retention.hours=168
+      2. 基于大小：log.retention.bytes=1073741824
+  需要注意的是，因为Kafka读取特定消息的时间复杂度为O(1)，即与文件大小无关，所以这里删除过期文件与提高 Kafka 性能无关。
+
+### 4.3 topic 创建与删除
+#### 4.3.1 创建 topic
+  创建 topic 的序列图如下所示：
+  <img src="5.png">
+  流程说明：
+      1. controller 在 ZooKeeper 的 /brokers/topics 节点上注册 watcher，当 topic 被创建，则 controller 会通过 watch 得到该 topic 的 partition/replica 分配。
+      2. controller从 /brokers/ids 读取当前所有可用的 broker 列表，对于 set_p 中的每一个 partition：
+      	2.1 从分配给该 partition 的所有 replica（称为AR）中任选一个可用的 broker 作为新的 leader，并将AR设置为新的 ISR
+      	2.2 将新的 leader 和 ISR 写入 /brokers/topics/[topic]/partitions/[partition]/state
+      3. controller 通过 RPC 向相关的 broker 发送 LeaderAndISRRequest。
+#### 4.3.2 删除 topic
+  删除 topic 的序列图如下所示：
+  <img src="6.png">
+  流程说明：
+      1. controller 在 zooKeeper 的 /brokers/topics 节点上注册 watcher，当 topic 被删除，则 controller 会通过 watch 得到该 topic 的 partition/replica 分配。
+      2. 若 delete.topic.enable=false，结束；否则 controller 注册在 /admin/delete_topics 上的 watch 被 fire，controller 通过回调向对应的 broker 发送 StopReplicaRequest。
+
+## 五、kafka HA
+### 5.1 replication
+  如图.1所示，同一个 partition 可能会有多个 replica（对应 server.properties 配置中的 default.replication.factor=N）。没有 replica 的情况下，一旦 broker 宕机，其上所有 patition 的数据都不可被消费，同时 producer 也不能再将数据存于其上的 patition。引入replication 之后，同一个 partition 可能会有多个 replica，而这时需要在这些 replica 之间选出一个 leader，producer 和 consumer 只与这个 leader 交互，其它 replica 作为 follower 从 leader 中复制数据。
+
+  Kafka 分配 Replica 的算法如下：
+      1. 将所有 broker（假设共 n 个 broker）和待分配的 partition 排序
+      2. 将第 i 个 partition 分配到第（i mod n）个 broker 上
+      3. 将第 i 个 partition 的第 j 个 replica 分配到第（(i + j) mode n）个 broker上
+### 5.2 leader failover
+  当 partition 对应的 leader 宕机时，需要从 follower 中选举出新 leader。在选举新leader时，一个基本的原则是，新的 leader 必须拥有旧 leader commit 过的所有消息。
+
+  kafka 在 zookeeper 中（/brokers/.../state）动态维护了一个 ISR（in-sync replicas），由3.3节的写入流程可知 ISR 里面的所有 replica 都跟上了 leader，只有 ISR 里面的成员才能选为 leader。对于 f+1 个 replica，一个 partition 可以在容忍 f 个 replica 失效的情况下保证消息不丢失。
+
+  当所有 replica 都不工作时，有两种可行的方案：
+      1. 等待 ISR 中的任一个 replica 活过来，并选它作为 leader。可保障数据不丢失，但时间可能相对较长。
+      2. 选择第一个活过来的 replica（不一定是 ISR 成员）作为 leader。无法保障数据不丢失，但相对不可用时间较短。
+
+  kafka 0.8.* 使用第二种方式。
+
+  kafka 通过 Controller 来选举 leader，流程请参考5.3节。
+
+### 5.3 broker failover
+  kafka broker failover 序列图如下所示：
+  <img src="7.png">
+  流程说明：
+      1. controller 在 zookeeper 的 /brokers/ids/[brokerId] 节点注册 Watcher，当 broker 宕机时 zookeeper 会 fire watch
+      2. controller 从 /brokers/ids 节点读取可用broker
+      3. controller决定set_p，该集合包含宕机 broker 上的所有 partition
+      4. 对 set_p 中的每一个 partition
+          4.1 从/brokers/topics/[topic]/partitions/[partition]/state 节点读取 ISR
+          4.2 决定新 leader（如4.3节所描述）
+          4.3 将新 leader、ISR、controller_epoch 和 leader_epoch 等信息写入 state 节点
+      5. 通过 RPC 向相关 broker 发送 leaderAndISRRequest 命令
+### 5.4 controller failover
+  当 controller 宕机时会触发 controller failover。每个 broker 都会在 zookeeper 的 "/controller" 节点注册 watcher，当 controller 宕机时 zookeeper 中的临时节点消失，所有存活的 broker 收到 fire 的通知，每个 broker 都尝试创建新的 controller path，只有一个竞选成功并当选为 controller。
+
+  当新的 controller 当选时，会触发 KafkaController.onControllerFailover 方法，在该方法中完成如下操作：
+      1. 读取并增加 Controller Epoch。
+      2. 在 reassignedPartitions Patch(/admin/reassign_partitions) 上注册 watcher。
+      3. 在 preferredReplicaElection Path(/admin/preferred_replica_election) 上注册 watcher。
+      4. 通过 partitionStateMachine 在 broker Topics Patch(/brokers/topics) 上注册 watcher。
+      5. 若 delete.topic.enable=true（默认值是 false），则 partitionStateMachine 在 Delete Topic Patch(/admin/delete_topics) 上注册 watcher。
+      6. 通过 replicaStateMachine在 Broker Ids Patch(/brokers/ids)上注册Watch。
+      7. 初始化 ControllerContext 对象，设置当前所有 topic，“活”着的 broker 列表，所有 partition 的 leader 及 ISR等。
+      8. 启动 replicaStateMachine 和 partitionStateMachine。
+      9. 将 brokerState 状态设置为 RunningAsController。
+      10. 将每个 partition 的 Leadership 信息发送给所有“活”着的 broker。
+      11. 若 auto.leader.rebalance.enable=true（默认值是true），则启动 partition-rebalance 线程。
+      12. 若 delete.topic.enable=true 且Delete Topic Patch(/admin/delete_topics)中有值，则删除相应的Topic。
+## 6. consumer 消费消息
+### 6.1 consumer API
+  kafka 提供了两套 consumer API：
+      1. The high-level Consumer API
+      2. The SimpleConsumer API
+      其中 high-level consumer API 提供了一个从 kafka 消费数据的高层抽象，而 SimpleConsumer API 则需要开发人员更多地关注细节。
+
+#### 6.1.1 The high-level consumer API
+  high-level consumer API 提供了 consumer group 的语义，一个消息只能被 group 内的一个 consumer 所消费，且 consumer 消费消息时不关注 offset，最后一个 offset 由 zookeeper 保存。
+
+  使用 high-level consumer API 可以是多线程的应用，应当注意：
+      1. 如果消费线程大于 patition 数量，则有些线程将收不到消息
+      2. 如果 patition 数量大于线程数，则有些线程多收到多个 patition 的消息
+      3. 如果一个线程消费多个 patition，则无法保证你收到的消息的顺序，而一个 patition 内的消息是有序的
+#### 6.1.2 The SimpleConsumer API
+  如果你想要对 patition 有更多的控制权，那就应该使用 SimpleConsumer API，比如：
+      1. 多次读取一个消息
+      2. 只消费一个 patition 中的部分消息
+      3. 使用事务来保证一个消息仅被消费一次
+
+  但是使用此 API 时，partition、offset、broker、leader 等对你不再透明，需要自己去管理。你需要做大量的额外工作：
+      1. 必须在应用程序中跟踪 offset，从而确定下一条应该消费哪条消息
+      2. 应用程序需要通过程序获知每个 Partition 的 leader 是谁
+      3. 需要处理 leader 的变更
+  使用 SimpleConsumer API 的一般流程如下：
+      1. 查找到一个“活着”的 broker，并且找出每个 partition 的 leader
+      2. 找出每个 partition 的 follower
+      3. 定义好请求，该请求应该能描述应用程序需要哪些数据
+      4. fetch 数据
+      5. 识别 leader 的变化，并对之作出必要的响应
+
+  以下针对 high-level Consumer API 进行说明。
+
+### 6.2 consumer group
+  如 2.2 节所说， kafka 的分配单位是 patition。每个 consumer 都属于一个 group，一个 partition 只能被同一个 group 内的一个 consumer 所消费（也就保障了一个消息只能被 group 内的一个 consuemr 所消费），但是多个 group 可以同时消费这个 partition。
+
+  kafka 的设计目标之一就是同时实现离线处理和实时处理，根据这一特性，可以使用 spark/Storm 这些实时处理系统对消息在线处理，同时使用 Hadoop 批处理系统进行离线处理，还可以将数据备份到另一个数据中心，只需要保证这三者属于不同的 consumer group。如下图所示：
+
+### 6.3 消费方式
+  consumer 采用 pull 模式从 broker 中读取数据。
+
+  push 模式很难适应消费速率不同的消费者，因为消息发送速率是由 broker 决定的。它的目标是尽可能以最快速度传递消息，但是这样很容易造成 consumer 来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而 pull 模式则可以根据 consumer 的消费能力以适当的速率消费消息。
+
+  对于 Kafka 而言，pull 模式更合适，它可简化 broker 的设计，consumer 可自主控制消费消息的速率，同时 consumer 可以自己控制消费方式——即可批量消费也可逐条消费，同时还能选择不同的提交方式从而实现不同的传输语义。
+
+### 6.4 consumer delivery guarantee
+  如果将 consumer 设置为 autocommit，consumer 一旦读到数据立即自动 commit。如果只讨论这一读取消息的过程，那 Kafka 确保了 Exactly once。
+
+  但实际使用中应用程序并非在 consumer 读取完数据就结束了，而是要进行进一步处理，而数据处理与 commit 的顺序在很大程度上决定了consumer delivery guarantee：
+
+  1. 读完消息先 commit 再处理消息。
+    这种模式下，如果 consumer 在 commit 后还没来得及处理消息就 crash 了，下次重新开始工作后就无法读到刚刚已提交而未处理的消息，这就对应于 At most once
+  2. 读完消息先处理再 commit。
+    这种模式下，如果在处理完消息之后 commit 之前 consumer crash 了，下次重新开始工作时还会处理刚刚未 commit 的消息，实际上该消息已经被处理过了。这就对应于 At least once。
+  3. 如果一定要做到 Exactly once，就需要协调 offset 和实际操作的输出。
+    精典的做法是引入两阶段提交。如果能让 offset 和操作输入存在同一个地方，会更简洁和通用。这种方式可能更好，因为许多输出系统可能不支持两阶段提交。比如，consumer 拿到数据后可能把数据放到 HDFS，如果把最新的 offset 和数据本身一起写到 HDFS，那就可以保证数据的输出和 offset 的更新要么都完成，要么都不完成，间接实现 Exactly once。（目前就 high-level API而言，offset 是存于Zookeeper 中的，无法存于HDFS，而SimpleConsuemr API的 offset 是由自己去维护的，可以将之存于 HDFS 中）
+
+  总之，Kafka 默认保证 At least once，并且允许通过设置 producer 异步提交来实现 At most once（见文章《kafka consumer防止数据丢失》http://kane-xie.iteye.com/blog/2225085）。而 Exactly once 要求与外部存储系统协作，幸运的是 kafka 提供的 offset 可以非常直接非常容易得使用这种方式。
+
+  更多关于 kafka 传输语义的信息请参考《Message Delivery Semantics》http://kafka.apache.org/documentation.html#semantics。
+
+### 6.5 consumer rebalance
+  当有 consumer 加入或退出、以及 partition 的改变（如 broker 加入或退出）时会触发 rebalance。consumer rebalance算法如下：
+      1. 将目标 topic 下的所有 partirtion 排序，存于PT
+      2. 对某 consumer group 下所有 consumer 排序，存于 CG，第 i 个consumer 记为 Ci
+      3. N=size(PT)/size(CG)，向上取整
+      4. 解除 Ci 对原来分配的 partition 的消费权（i从0开始）
+      5. 将第i*N到（i+1）* N-1个 partition 分配给 Ci
+  在 0.8.* 版本，每个 consumer 都只负责调整自己所消费的 partition，为了保证整个consumer group 的一致性，当一个 consumer 触发了 rebalance 时，该 consumer group 内的其它所有其它 consumer 也应该同时触发 rebalance。这会导致以下几个问题：
+      1. Herd effect
+      　　任何 broker 或者 consumer 的增减都会触发所有的 consumer 的 rebalance
+      2. Split Brain
+      　　每个 consumer 分别单独通过 zookeeper 判断哪些 broker 和 consumer 宕机了，那么不同 consumer 在同一时刻从 zookeeper 看到的 view 就可能不一样，这是由 zookeeper 的特性决定的，这就会造成不正确的 reblance 尝试。
+      3. 调整结果不可控
+      　　所有的 consumer 都并不知道其它 consumer 的 rebalance 是否成功，这可能会导致 kafka 工作在一个不正确的状态。
+  基于以上问题，kafka 设计者考虑在0.9.* 版本开始使用中心 coordinator 来控制 consumer rebalance，然后又从简便性和验证要求两方面考虑，计划在 consumer 客户端实现分配方案。（见文章《Kafka Detailed Consumer Coordinator Design》 https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Detailed+Consumer+Coordinator+Design#KafkaDetailedConsumerCoordinatorDesign-WARN:Thisisanobsoletedesign.Thedesignthat%27simplementedinKafka0.9.0isdescribedinthiswiki. 和《Kafka Client-side Assignment Proposal》https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Client-side+Assignment+Proposal），此处不再赘述。
+
+## 七、注意事项
+### 7.1 producer 无法发送消息的问题
+最开始在本机搭建了kafka伪集群，本地 producer 客户端成功发布消息至 broker。随后在服务器上搭建了 kafka 集群，在本机连接该集群，producer 却无法发布消息到 broker（奇怪也没有抛错）。最开始怀疑是 iptables 没开放，于是开放端口，结果还不行（又开始是代码问题、版本问题等等，倒腾了很久）。最后没办法，一项一项查看 server.properties 配置，发现以下两个配置：
+```
+# The address the socket server listens on. It will get the value returned from
+# java.net.InetAddress.getCanonicalHostName() if not configured.
+#   FORMAT:
+#     listeners = security_protocol://host_name:port
+#   EXAMPLE:
+#     listeners = PLAINTEXT://your.host.name:9092
+listeners=PLAINTEXT://:9092
+　# Hostname and port the broker will advertise to producers and consumers. If not set,
+　# it uses the value for "listeners" if configured. Otherwise, it will use the value
+　# returned from java.net.InetAddress.getCanonicalHostName().
+　#advertised.listeners=PLAINTEXT://your.host.name:9092
+```
+以上说的就是 advertised.listeners 是 broker 给 producer 和 consumer 连接使用的，如果没有设置，就使用 listeners，而如果 host_name 没有设置的话，就使用 java.net.InetAddress.getCanonicalHostName() 方法返回的主机名。
+
+修改方法：
+1. listeners=PLAINTEXT://121.10.26.XXX:9092
+2. advertised.listeners=PLAINTEXT://121.10.26.XXX:9092
+修改后重启服务，正常工作。关于更多 kafka 配置说明，见文章《Kafka学习整理三(borker(0.9.0及0.10.0)配置)》https://blog.csdn.net/louisliaoxh/article/details/51516084。
+
+## 八、参考文章
+1. 《Kafka剖析（一）：Kafka背景及架构介绍》    http://www.infoq.com/cn/articles/kafka-analysis-part-1/
+2. 《Kafka设计解析（二）：Kafka High Availability （上）》 http://www.infoq.com/cn/articles/kafka-analysis-part-2/
+3. 《Kafka设计解析（三）：Kafka High Availability （下）》 http://www.infoq.com/cn/articles/kafka-analysis-part-3/
+4. 《Kafka设计解析（四）：Kafka Consumer解析》 http://www.infoq.com/cn/articles/kafka-analysis-part-4/
+5. 《Kafka设计解析（五）：Kafka Benchmark》 http://www.infoq.com/cn/articles/kafka-analysis-part-5
+6. 《Kafka学习整理三(borker(0.9.0及0.10.0)配置)》 https://blog.csdn.net/louisliaoxh/article/details/51516084
+7. 《Using the High Level Consumer》  https://cwiki.apache.org/confluence/display/KAFKA/Consumer+Group+Example
+8. 《Using SimpleConsumer》 https://cwiki.apache.org/confluence/display/KAFKA/0.8.0+SimpleConsumer+Example
+9. 《Consumer Client Re-Design》    https://cwiki.apache.org/confluence/display/KAFKA/Consumer+Client+Re-Design
+10. 《Message Delivery Semantics》 http://kafka.apache.org/documentation.html#semantics 4.6
+11. 《Kafka Detailed Consumer Coordinator Design》 https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Detailed+Consumer+Coordinator+Design#KafkaDetailedConsumerCoordinatorDesign-WARN:Thisisanobsoletedesign.Thedesignthat%27simplementedinKafka0.9.0isdescribedinthiswiki.
+12. 《Kafka Client-side Assignment Proposal》 https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Client-side+Assignment+Proposal
+13. 《Kafka和DistributedLog技术对比》 http://www.infoq.com/cn/articles/technology-comparison-of-kafka-and-distributedlog?utm_campaign=rightbar_v2&utm_source=infoq&utm_medium=articles_link&utm_content=link_text
+14. 《kafka安装和启动》 http://orchome.com/6
+15. 《kafka consumer防止数据丢失》 http://kane-xie.iteye.com/blog/2225085
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/producer_write.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/producer_write.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/producer_write.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/producer_write.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/zookeeper_node.png" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/zookeeper_node.png"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/zookeeper_node.png"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/zookeeper_node.png"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\234\272\346\231\257.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\234\272\346\231\257.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\234\272\346\231\257.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\234\272\346\231\257.md"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\237\272\346\234\254\346\246\202\345\277\265.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\237\272\346\234\254\346\246\202\345\277\265.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\237\272\346\234\254\346\246\202\345\277\265.md"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\277\253\351\200\237\345\205\245\351\227\250.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\277\253\351\200\237\345\205\245\351\227\250.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\277\253\351\200\237\345\205\245\351\227\250.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/Kafka/\345\277\253\351\200\237\345\205\245\351\227\250.md"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/Spring Boot\346\225\264\345\220\210.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/Spring Boot\346\225\264\345\220\210.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/Spring Boot\346\225\264\345\220\210.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/Spring Boot\346\225\264\345\220\210.md"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/rabbitMQ\345\256\211\350\243\205.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/rabbitMQ\345\256\211\350\243\205.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/rabbitMQ\345\256\211\350\243\205.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RabbitMQ/rabbitMQ\345\256\211\350\243\205.md"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/all.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/all.md"
similarity index 100%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/all.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/all.md"
diff --git "a/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/\351\230\277\351\207\214 \346\266\210\346\201\257\351\230\237\345\210\227 RocketMQ.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/\351\230\277\351\207\214 \346\266\210\346\201\257\351\230\237\345\210\227 RocketMQ.md"
new file mode 100644
index 00000000..5cab87ae
--- /dev/null
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/RocketMQ/\351\230\277\351\207\214 \346\266\210\346\201\257\351\230\237\345\210\227 RocketMQ.md"	
@@ -0,0 +1,25 @@
+
+
+https://help.aliyun.com/document_detail/43490.html?spm=5176.10695662.1996646101.searchclickresult.36a418dcu3G3h3
+## 无序消息的重试
+对于无序消息（普通、定时、延时、事务消息），当消费者消费消息失败时，您可以通过设置返回状态达到消息重试的结果。
+
+无序消息的重试只针对集群消费方式生效；广播方式不提供失败重试特性，即消费失败后，失败消息不再重试，继续消费新的消息。
+
+注意：以下内容都只针对无序消息生效。
+
+重试次数
+消息队列 RocketMQ 默认允许每条消息最多重试 16 次，每次重试的间隔时间如下：
+
+第几次重试	与上次重试的间隔时间	第几次重试	与上次重试的间隔时间
+1	10 秒	9	7 分钟
+2	30 秒	10	8 分钟
+3	1 分钟	11	9 分钟
+4	2 分钟	12	10 分钟
+5	3 分钟	13	20 分钟
+6	4 分钟	14	30 分钟
+7	5 分钟	15	1 小时
+8	6 分钟	16	2 小时
+
+如果消息重试 16 次后仍然失败，消息将不再投递。如果严格按照上述重试时间间隔计算，某条消息在一直消费失败的前提下，将会在接下来的 4 小时 46 分钟之内进行 16 次重试，超过这个时间范围消息将不再重试投递。
+注意： 一条消息无论重试多少次，这些重试消息的 Message ID 不会改变。
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/me.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/me.txt"
similarity index 95%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/me.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/me.txt"
index 48634968..19611e6f 100644
--- "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/me.txt"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/me.txt"	
@@ -1,6 +1,6 @@
-
-就是一个 服务 IP：端口
-
-生产者将消息传到这个服务
-
+
+就是一个 服务 IP：端口
+
+生产者将消息传到这个服务
+
 消费者从这个服务取消息
\ No newline at end of file
diff --git "a/08 - Utils/\347\210\254\350\231\253/java.txt" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\345\244\247\345\236\213\347\275\221\347\253\231\346\236\266\346\236\204\344\271\213\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\351\230\237\345\210\227.txt"
similarity index 100%
rename from "08 - Utils/\347\210\254\350\231\253/java.txt"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\345\244\247\345\236\213\347\275\221\347\253\231\346\236\266\346\236\204\344\271\213\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\351\230\237\345\210\227.txt"
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227.md"
similarity index 98%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227.md"
index b7a8a760..3a5b25aa 100644
--- "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227.md"	
@@ -1,40 +1,40 @@
-https://github.com/Java-architect/JavaWeb/blob/master/docs/distributed/mq/%E5%88%86%E5%B8%83%E5%BC%8F%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97.md
-
-### 消息队列应用场景
-
- **异步处理**
- 场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式；2.并行方式。
-  * （1）串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端。
-  * （2）并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间。
-  假设三个业务节点每个使用 50 毫秒钟，不考虑网络等其他开销，则串行方式的时间是 150 毫秒，并行的时间可能是 100 毫秒。
-
-  因为 CPU 在单位时间内处理的请求数是一定的，假设 CPU1 秒内吞吐量是 100 次。则串行方式 1 秒内 CPU 可处理的请求量是 7 次（1000/150）。并行方式处理的请求量是 10 次（1000/100）。
-
-  小结：如以上案例描述，传统的方式系统的性能（并发量，吞吐量，响应时间）会有瓶颈。如何解决这个问题呢？
-
-  引入消息队列，将不是必须的业务逻辑，异步处理。改造后的架构如下：
-
-  按照以上约定，用户的响应时间相当于是注册信息写入数据库的时间，也就是 50 毫秒。注册邮件，发送短信写入消息队列后，直接返回，因此写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是 50 毫秒。因此架构改变后，系统的吞吐量提高到每秒 20 QPS。比串行提高了 3 倍，比并行提高了两倍。
-
- **应用解耦**
-
- **流量削锋**
-
- **日志处理**
-
- **消息通讯**
-
-关键
-### 消息的顺序问题
-
-  * 保证生产者 - MQServer - 消费者是一对一对一的关系。
-  * 通过合理的设计或者将问题分解来规避。如果硬要把时间花在解决问题本身，实际上不仅效率低下，而且也是一种浪费。从这个角度来看消息的顺序问题，我们可以得出两个结论：
-    1. 不关注乱序的应用实际大量存在
-    2. 队列无序并不意味着消息无序
-
-### 消息的重复问题
-
-  1. 消费端处理消息的业务逻辑保持幂等性。
-  2. 保证每条消息都有唯一编号且保证消息处理成功与去重表的日志同时出现。
-
-### 事务消息
+https://github.com/Java-architect/JavaWeb/blob/master/docs/distributed/mq/%E5%88%86%E5%B8%83%E5%BC%8F%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97.md
+
+### 消息队列应用场景
+
+ **异步处理**
+ 场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式；2.并行方式。
+  * （1）串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端。
+  * （2）并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间。
+  假设三个业务节点每个使用 50 毫秒钟，不考虑网络等其他开销，则串行方式的时间是 150 毫秒，并行的时间可能是 100 毫秒。
+
+  因为 CPU 在单位时间内处理的请求数是一定的，假设 CPU1 秒内吞吐量是 100 次。则串行方式 1 秒内 CPU 可处理的请求量是 7 次（1000/150）。并行方式处理的请求量是 10 次（1000/100）。
+
+  小结：如以上案例描述，传统的方式系统的性能（并发量，吞吐量，响应时间）会有瓶颈。如何解决这个问题呢？
+
+  引入消息队列，将不是必须的业务逻辑，异步处理。改造后的架构如下：
+
+  按照以上约定，用户的响应时间相当于是注册信息写入数据库的时间，也就是 50 毫秒。注册邮件，发送短信写入消息队列后，直接返回，因此写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是 50 毫秒。因此架构改变后，系统的吞吐量提高到每秒 20 QPS。比串行提高了 3 倍，比并行提高了两倍。
+
+ **应用解耦**
+
+ **流量削锋**
+
+ **日志处理**
+
+ **消息通讯**
+
+关键
+### 消息的顺序问题
+
+  * 保证生产者 - MQServer - 消费者是一对一对一的关系。
+  * 通过合理的设计或者将问题分解来规避。如果硬要把时间花在解决问题本身，实际上不仅效率低下，而且也是一种浪费。从这个角度来看消息的顺序问题，我们可以得出两个结论：
+    1. 不关注乱序的应用实际大量存在
+    2. 队列无序并不意味着消息无序
+
+### 消息的重复问题
+
+  1. 消费端处理消息的业务逻辑保持幂等性。
+  2. 保证每条消息都有唯一编号且保证消息处理成功与去重表的日志同时出现。
+
+### 事务消息
diff --git "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227\345\272\224\347\224\250\345\234\272\346\231\257.md" "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227\345\272\224\347\224\250\345\234\272\346\231\257.md"
similarity index 98%
rename from "04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227\345\272\224\347\224\250\345\234\272\346\231\257.md"
rename to "04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227\345\272\224\347\224\250\345\234\272\346\231\257.md"
index 70ec9454..ebb5069c 100644
--- "a/04 - Middleware/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227\345\272\224\347\224\250\345\234\272\346\231\257.md"	
+++ "b/04 - Middleware \344\270\255\351\227\264\344\273\266/\346\266\210\346\201\257\351\230\237\345\210\227/\346\266\210\346\201\257\351\230\237\345\210\227\345\272\224\347\224\250\345\234\272\346\231\257.md"	
@@ -1 +1 @@
-https://blog.csdn.net/shaobingj126/article/details/50585035
+https://blog.csdn.net/shaobingj126/article/details/50585035
diff --git a/05 - OS (linux)/CentOS.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/CentOS.md"
similarity index 100%
rename from 05 - OS (linux)/CentOS.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/CentOS.md"
diff --git a/05 - OS (linux)/FTP/all.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/FTP/all.md"
similarity index 96%
rename from 05 - OS (linux)/FTP/all.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/FTP/all.md"
index 20152295..523fc9e8 100644
--- a/05 - OS (linux)/FTP/all.md	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/FTP/all.md"	
@@ -1,135 +1,135 @@
-
-写权利
-/etc/vsftpd/vsftpd.conf
-
-```
-# Uncomment this to enable any form of FTP write command.
-write_enable=YES
-```
-
-windows访问vsftp服务器出现200,227错误 https://blog.csdn.net/w3045872817/article/details/78006480
-
-service vsftpd restart
-## **安装** https://www.linuxidc.com/Linux/2017-11/148518.htm
-### 1、安装并启动 FTP 服务
-
-yum install -y vsftpd
-1.2 启动 VSFTPD
-
-service vsftpd start
-启动后，可以看到系统已经监听了 21 端口：
-
-netstat -nltp | grep 21
-此时，访问 ftp://192.168.1.170 可浏览机器上的 /var/ftp目录了。
-
-### 2、配置 FTP 权限
-
-*2.1 了解 VSFTP 配置*
-vsftpd 的配置目录为 /etc/vsftpd，包含下列的配置文件：
-
-vsftpd.conf 为主要配置文件
-ftpusers 配置禁止访问 FTP 服务器的用户列表
-user_list 配置用户访问控制
-
-*2.2 阻止匿名访问和切换根目录*
-匿名访问和切换根目录都会给服务器带来安全风险，我们把这两个功能关闭。
-
-编辑 /etc/vsftpd/vsftpd.conf，找到下面两处配置并修改：
-
-```
-# 禁用匿名用户  12 YES 改为NO
-anonymous_enable=NO
-
-# 禁止切换根目录 101 行 删除#
-chroot_local_user=YES
-```
-编辑完成后保存配置，重新启动 FTP 服务
-
-service vsftpd restart
-
-*2.3 创建 FTP 用户*
-创建一个用户 ftpuser
-
-useradd ftpuser
-为用户 ftpuser 设置密码
-
-echo "javen205" | passwd ftpuser --stdin
-*2.4 限制该用户仅能通过 FTP 访问*
-限制用户 ftpuser只能通过 FTP 访问服务器，而不能直接登录服务器：
-
-usermod -s /sbin/nologin ftpuser
-*2.5 为用户分配主目录*
-为用户 ftpuser创建主目录并约定：
-
-/data/ftp 为主目录, 该目录不可上传文件
-/data/ftp/pub 文件只能上传到该目录下
-
-在/data中创建相关的目录
-
-mkdir -p /data/ftp/pub
-*2.5.1 创建登录欢迎文件*
-
-echo "Welcome to use FTP service." > /data/ftp/welcome.txt
-设置访问权限
-
-chmod a-w /data/ftp && chmod 777 -R /data/ftp/pub
-设置为用户的主目录：
-
-usermod -d /data/ftp ftpuser
-
-### 3、访问FTP
-根据您个人的工作环境，选择一种方式来访问已经搭建的 FTP 服务
-
-注意：记得关闭防火墙或者开放FTP默认端口(21)
-
-# 关闭SELinux服务
-setenforce 0
-# 关闭防火墙
-iptables -F
-通过 Windows 资源管理器访问
-Windows 用户可以复制下面的链接
-到资源管理器的地址栏访问：
-
-ftp://ftpuser:javen205@192.168.1.170
-其中ftpuser为登录FTP的用户名，javen205为登录FTP的密码
-
-通过 FTP 客户端工具访问
-
-## **用户 操作** https://blog.csdn.net/piaocoder/article/details/50719149 https://blog.csdn.net/firewolf1758/article/details/73822082
-### 1.环境：ftp为vsftp。被设置用户名为test。被限制路径为/home/test
-
-### 2.创建建用户：在root用户下：
-useradd -d /home/test test	#增加用户test，并制定test用户的主目录为/home/test
-passwd test	#为test用户设置密码
-
-### 3.更改用户相应的权限设置：
-usermod -s /sbin/nologin test	#限定用户test不能telnet，只能ftp
-usermod -s /bin/bash test	#用户test恢复正常
-usermod -d /home/test test      #更改用户test的主目录为/test
-
-### 4.限制用户只能访问/home/test，不能访问其他路径
-
-修改/etc/vsftpd/vsftpd.conf如下：
-chroot_list_enable=YES	#限制访问自身目录
-
-# (default follows)
-
-chroot_list_file=/etc/vsftpd/vsftpd.chroot_list
-
-编辑 vsftpd.chroot_list文件，将受限制的用户添加进去，每个用户名一行
-
-改完配置文件，不要忘记重启vsftpd服务器
-
-[root@localhost]# /etc/init.d/vsftpd restart
-
-### 5.如果需要允许用户修改密码，但是又没有telnet登录系统的权限：
-```
-usermod -s /usr/bin/passwd test      #用户telnet后将直接进入改密界面
-```
-### 6.如果要删除用户，用下面代码：
-```
-#在root用户下：
-userdel -r newuser
-#在普通用户下：
-sudo userdel -r newuser
-```
+
+写权利
+/etc/vsftpd/vsftpd.conf
+
+```
+# Uncomment this to enable any form of FTP write command.
+write_enable=YES
+```
+
+windows访问vsftp服务器出现200,227错误 https://blog.csdn.net/w3045872817/article/details/78006480
+
+service vsftpd restart
+## **安装** https://www.linuxidc.com/Linux/2017-11/148518.htm
+### 1、安装并启动 FTP 服务
+
+yum install -y vsftpd
+1.2 启动 VSFTPD
+
+service vsftpd start
+启动后，可以看到系统已经监听了 21 端口：
+
+netstat -nltp | grep 21
+此时，访问 ftp://192.168.1.170 可浏览机器上的 /var/ftp目录了。
+
+### 2、配置 FTP 权限
+
+*2.1 了解 VSFTP 配置*
+vsftpd 的配置目录为 /etc/vsftpd，包含下列的配置文件：
+
+vsftpd.conf 为主要配置文件
+ftpusers 配置禁止访问 FTP 服务器的用户列表
+user_list 配置用户访问控制
+
+*2.2 阻止匿名访问和切换根目录*
+匿名访问和切换根目录都会给服务器带来安全风险，我们把这两个功能关闭。
+
+编辑 /etc/vsftpd/vsftpd.conf，找到下面两处配置并修改：
+
+```
+# 禁用匿名用户  12 YES 改为NO
+anonymous_enable=NO
+
+# 禁止切换根目录 101 行 删除#
+chroot_local_user=YES
+```
+编辑完成后保存配置，重新启动 FTP 服务
+
+service vsftpd restart
+
+*2.3 创建 FTP 用户*
+创建一个用户 ftpuser
+
+useradd ftpuser
+为用户 ftpuser 设置密码
+
+echo "javen205" | passwd ftpuser --stdin
+*2.4 限制该用户仅能通过 FTP 访问*
+限制用户 ftpuser只能通过 FTP 访问服务器，而不能直接登录服务器：
+
+usermod -s /sbin/nologin ftpuser
+*2.5 为用户分配主目录*
+为用户 ftpuser创建主目录并约定：
+
+/data/ftp 为主目录, 该目录不可上传文件
+/data/ftp/pub 文件只能上传到该目录下
+
+在/data中创建相关的目录
+
+mkdir -p /data/ftp/pub
+*2.5.1 创建登录欢迎文件*
+
+echo "Welcome to use FTP service." > /data/ftp/welcome.txt
+设置访问权限
+
+chmod a-w /data/ftp && chmod 777 -R /data/ftp/pub
+设置为用户的主目录：
+
+usermod -d /data/ftp ftpuser
+
+### 3、访问FTP
+根据您个人的工作环境，选择一种方式来访问已经搭建的 FTP 服务
+
+注意：记得关闭防火墙或者开放FTP默认端口(21)
+
+# 关闭SELinux服务
+setenforce 0
+# 关闭防火墙
+iptables -F
+通过 Windows 资源管理器访问
+Windows 用户可以复制下面的链接
+到资源管理器的地址栏访问：
+
+ftp://ftpuser:javen205@192.168.1.170
+其中ftpuser为登录FTP的用户名，javen205为登录FTP的密码
+
+通过 FTP 客户端工具访问
+
+## **用户 操作** https://blog.csdn.net/piaocoder/article/details/50719149 https://blog.csdn.net/firewolf1758/article/details/73822082
+### 1.环境：ftp为vsftp。被设置用户名为test。被限制路径为/home/test
+
+### 2.创建建用户：在root用户下：
+useradd -d /home/test test	#增加用户test，并制定test用户的主目录为/home/test
+passwd test	#为test用户设置密码
+
+### 3.更改用户相应的权限设置：
+usermod -s /sbin/nologin test	#限定用户test不能telnet，只能ftp
+usermod -s /bin/bash test	#用户test恢复正常
+usermod -d /home/test test      #更改用户test的主目录为/test
+
+### 4.限制用户只能访问/home/test，不能访问其他路径
+
+修改/etc/vsftpd/vsftpd.conf如下：
+chroot_list_enable=YES	#限制访问自身目录
+
+# (default follows)
+
+chroot_list_file=/etc/vsftpd/vsftpd.chroot_list
+
+编辑 vsftpd.chroot_list文件，将受限制的用户添加进去，每个用户名一行
+
+改完配置文件，不要忘记重启vsftpd服务器
+
+[root@localhost]# /etc/init.d/vsftpd restart
+
+### 5.如果需要允许用户修改密码，但是又没有telnet登录系统的权限：
+```
+usermod -s /usr/bin/passwd test      #用户telnet后将直接进入改密界面
+```
+### 6.如果要删除用户，用下面代码：
+```
+#在root用户下：
+userdel -r newuser
+#在普通用户下：
+sudo userdel -r newuser
+```
diff --git "a/05 - OS (linux)/FTP/centos\346\267\273\345\212\240ftp\347\224\250\346\210\267\345\271\266\347\246\201\346\255\242\345\244\226\345\210\207\347\233\256\345\275\225.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/FTP/centos\346\267\273\345\212\240ftp\347\224\250\346\210\267\345\271\266\347\246\201\346\255\242\345\244\226\345\210\207\347\233\256\345\275\225.md"
similarity index 97%
rename from "05 - OS (linux)/FTP/centos\346\267\273\345\212\240ftp\347\224\250\346\210\267\345\271\266\347\246\201\346\255\242\345\244\226\345\210\207\347\233\256\345\275\225.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/FTP/centos\346\267\273\345\212\240ftp\347\224\250\346\210\267\345\271\266\347\246\201\346\255\242\345\244\226\345\210\207\347\233\256\345\275\225.md"
index e39a8a2e..99e7bd43 100644
--- "a/05 - OS (linux)/FTP/centos\346\267\273\345\212\240ftp\347\224\250\346\210\267\345\271\266\347\246\201\346\255\242\345\244\226\345\210\207\347\233\256\345\275\225.md"	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/FTP/centos\346\267\273\345\212\240ftp\347\224\250\346\210\267\345\271\266\347\246\201\346\255\242\345\244\226\345\210\207\347\233\256\345\275\225.md"	
@@ -1,48 +1,48 @@
-在linux中添加ftp用户，并设置相应的权限，操作步骤如下：
-### 1、环境：ftp为vsftp。
-  被限制用户名为ftpuser。被限制路径为/home/ftpuser
-
-### 2、建用户，命令行状态下，在root用户下：
-
-  运行命令：“useradd -d /home/ftpuser ftpuser”　　//增加用户ftpuser，并制定ftpuser用户的主目录为/home/ftpuser
-
-  运行命令：“passwd ftpuser”　　//为ftpuser设置密码，运行后输入两次相同密码
-
-### 3、更改用户相应的权限设置：
-
-    运行命令：“usermod -s /sbin/nologin ftpuser”　　//限定用户ftpuser不能telnet，只能ftp
-
-    运行命令：“usermod -s /sbin/bash ftpuser”　　//用户ftpuser恢复正常
-
-    运行命令：“usermod -d /ftpuser ftpuser”　　//更改用户ftpuser的主目录为/ftpuser
-
-### 4、限制用户只能访问/home/ftpuser，不能访问其他路径
-
-    修改/etc/vsftpd/vsftpd.conf如下：
-```
-  chroot_local_user=NO
-  chroot_list_enable=YES
-  # (default follows)
-  chroot_list_file=/etc/vsftpd/vsftpd.chroot_list
-```
- 编辑上面的内容
-```
-    第一行：chroot_local_user=NO
-
-    第二行：chroot_list_enable=YES　　//限制访问自身目录
-
-    第四行：编辑vsftpd.chroot_list。根据第三行说指定的目录，找到chroot_list文件。（因主机不同，文件名也许略有不同）
-
-    编辑vsftpd.chroot_list，将受限制的用户添加进去，每个用户名一行
-```
-说明：chroot_local_user=NO则所有用户不被限定在主目录内，chroot_list_enable=YES表示要启用chroot_list_file, 因为chroot_local_user=NO，即全体用户都“不被限定在主目录内”,所以总是作为“例外列表”的chroot_list_file这时列出的是那些“会被限制在主目录下”的用户。
-
-### 5、重启服务器
-
-    改完配置文件，不要忘记重启vsFTPd服务器
-
-    运行命令：`service vsftpd restart`
-
-### 6、如果需要允许用户修改密码，但是又没有telnet登录系统的权限：
-
-    运行命令：“usermod -s /usr/bin/passwd ftpuser”　　//用户telnet后将直接进入改密界面
+在linux中添加ftp用户，并设置相应的权限，操作步骤如下：
+### 1、环境：ftp为vsftp。
+  被限制用户名为ftpuser。被限制路径为/home/ftpuser
+
+### 2、建用户，命令行状态下，在root用户下：
+
+  运行命令：“useradd -d /home/ftpuser ftpuser”　　//增加用户ftpuser，并制定ftpuser用户的主目录为/home/ftpuser
+
+  运行命令：“passwd ftpuser”　　//为ftpuser设置密码，运行后输入两次相同密码
+
+### 3、更改用户相应的权限设置：
+
+    运行命令：“usermod -s /sbin/nologin ftpuser”　　//限定用户ftpuser不能telnet，只能ftp
+
+    运行命令：“usermod -s /sbin/bash ftpuser”　　//用户ftpuser恢复正常
+
+    运行命令：“usermod -d /ftpuser ftpuser”　　//更改用户ftpuser的主目录为/ftpuser
+
+### 4、限制用户只能访问/home/ftpuser，不能访问其他路径
+
+    修改/etc/vsftpd/vsftpd.conf如下：
+```
+  chroot_local_user=NO
+  chroot_list_enable=YES
+  # (default follows)
+  chroot_list_file=/etc/vsftpd/vsftpd.chroot_list
+```
+ 编辑上面的内容
+```
+    第一行：chroot_local_user=NO
+
+    第二行：chroot_list_enable=YES　　//限制访问自身目录
+
+    第四行：编辑vsftpd.chroot_list。根据第三行说指定的目录，找到chroot_list文件。（因主机不同，文件名也许略有不同）
+
+    编辑vsftpd.chroot_list，将受限制的用户添加进去，每个用户名一行
+```
+说明：chroot_local_user=NO则所有用户不被限定在主目录内，chroot_list_enable=YES表示要启用chroot_list_file, 因为chroot_local_user=NO，即全体用户都“不被限定在主目录内”,所以总是作为“例外列表”的chroot_list_file这时列出的是那些“会被限制在主目录下”的用户。
+
+### 5、重启服务器
+
+    改完配置文件，不要忘记重启vsFTPd服务器
+
+    运行命令：`service vsftpd restart`
+
+### 6、如果需要允许用户修改密码，但是又没有telnet登录系统的权限：
+
+    运行命令：“usermod -s /usr/bin/passwd ftpuser”　　//用户telnet后将直接进入改密界面
diff --git "a/05 - OS (linux)/Linux\344\274\201\344\270\232\350\277\220\347\273\264\344\272\272\345\221\230\346\234\200\345\270\270\347\224\250150\344\270\252\345\221\275\344\273\244\346\261\207\346\200\273.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/Linux\344\274\201\344\270\232\350\277\220\347\273\264\344\272\272\345\221\230\346\234\200\345\270\270\347\224\250150\344\270\252\345\221\275\344\273\244\346\261\207\346\200\273.md"
similarity index 100%
rename from "05 - OS (linux)/Linux\344\274\201\344\270\232\350\277\220\347\273\264\344\272\272\345\221\230\346\234\200\345\270\270\347\224\250150\344\270\252\345\221\275\344\273\244\346\261\207\346\200\273.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/Linux\344\274\201\344\270\232\350\277\220\347\273\264\344\272\272\345\221\230\346\234\200\345\270\270\347\224\250150\344\270\252\345\221\275\344\273\244\346\261\207\346\200\273.md"
diff --git "a/05 - OS (linux)/Linux\346\267\273\345\212\240\343\200\201\345\210\240\351\231\244\347\224\250\346\210\267\345\222\214\347\224\250\346\210\267\347\273\204.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/Linux\346\267\273\345\212\240\343\200\201\345\210\240\351\231\244\347\224\250\346\210\267\345\222\214\347\224\250\346\210\267\347\273\204.md"
similarity index 100%
rename from "05 - OS (linux)/Linux\346\267\273\345\212\240\343\200\201\345\210\240\351\231\244\347\224\250\346\210\267\345\222\214\347\224\250\346\210\267\347\273\204.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/Linux\346\267\273\345\212\240\343\200\201\345\210\240\351\231\244\347\224\250\346\210\267\345\222\214\347\224\250\346\210\267\347\273\204.md"
diff --git a/05 - OS (linux)/chkconfig service/# chkconfig   - 85 15.txt "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/chkconfig service/# chkconfig   - 85 15.txt"
similarity index 100%
rename from 05 - OS (linux)/chkconfig service/# chkconfig   - 85 15.txt
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/chkconfig service/# chkconfig   - 85 15.txt"
diff --git a/05 - OS (linux)/chkconfig service/all.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/chkconfig service/all.md"
similarity index 100%
rename from 05 - OS (linux)/chkconfig service/all.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/chkconfig service/all.md"
diff --git a/05 - OS (linux)/chmod.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/chmod.md"
similarity index 100%
rename from 05 - OS (linux)/chmod.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/chmod.md"
diff --git a/05 - OS (linux)/log.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/log.md"
similarity index 100%
rename from 05 - OS (linux)/log.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/log.md"
diff --git a/05 - OS (linux)/proc_uptime.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/proc_uptime.md"
similarity index 100%
rename from 05 - OS (linux)/proc_uptime.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/proc_uptime.md"
diff --git a/05 - OS (linux)/shell/bash zsh.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/shell/bash zsh.md"
similarity index 100%
rename from 05 - OS (linux)/shell/bash zsh.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/shell/bash zsh.md"
diff --git "a/05 - OS (linux)/systemctl/systemctl \350\256\276\347\275\256\350\207\252\345\256\232\344\271\211\346\234\215\345\212\241\347\256\241\347\220\206\357\274\210\344\273\245nginx\344\270\272\344\276\213\357\274\211.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/systemctl/systemctl \350\256\276\347\275\256\350\207\252\345\256\232\344\271\211\346\234\215\345\212\241\347\256\241\347\220\206\357\274\210\344\273\245nginx\344\270\272\344\276\213\357\274\211.md"
similarity index 100%
rename from "05 - OS (linux)/systemctl/systemctl \350\256\276\347\275\256\350\207\252\345\256\232\344\271\211\346\234\215\345\212\241\347\256\241\347\220\206\357\274\210\344\273\245nginx\344\270\272\344\276\213\357\274\211.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/systemctl/systemctl \350\256\276\347\275\256\350\207\252\345\256\232\344\271\211\346\234\215\345\212\241\347\256\241\347\220\206\357\274\210\344\273\245nginx\344\270\272\344\276\213\357\274\211.md"
diff --git "a/05 - OS (linux)/systemctl/systemctl\345\221\275\344\273\244.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/systemctl/systemctl\345\221\275\344\273\244.md"
similarity index 100%
rename from "05 - OS (linux)/systemctl/systemctl\345\221\275\344\273\244.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/systemctl/systemctl\345\221\275\344\273\244.md"
diff --git "a/05 - OS (linux)/systemctl/systemctl\347\256\241\347\220\206Redis\345\220\257\345\212\250\343\200\201\345\201\234\346\255\242\343\200\201\345\274\200\346\234\272\345\220\257\345\212\250.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/systemctl/systemctl\347\256\241\347\220\206Redis\345\220\257\345\212\250\343\200\201\345\201\234\346\255\242\343\200\201\345\274\200\346\234\272\345\220\257\345\212\250.md"
similarity index 100%
rename from "05 - OS (linux)/systemctl/systemctl\347\256\241\347\220\206Redis\345\220\257\345\212\250\343\200\201\345\201\234\346\255\242\343\200\201\345\274\200\346\234\272\345\220\257\345\212\250.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/systemctl/systemctl\347\256\241\347\220\206Redis\345\220\257\345\212\250\343\200\201\345\201\234\346\255\242\343\200\201\345\274\200\346\234\272\345\220\257\345\212\250.md"
diff --git a/05 - OS (linux)/vi-vim/me.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/me.md"
similarity index 100%
rename from 05 - OS (linux)/vi-vim/me.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/me.md"
diff --git a/05 - OS (linux)/vi-vim/readme.md "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/readme.md"
similarity index 98%
rename from 05 - OS (linux)/vi-vim/readme.md
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/readme.md"
index 9cd31eac..209b030c 100644
--- a/05 - OS (linux)/vi-vim/readme.md	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/readme.md"	
@@ -1,363 +1,363 @@
-vim 选择文本，删除，复制，粘贴
-
-文本的选择，对于编辑器来说，是很基本的东西，也经常被用到，总结如下：
-
-v 从光标当前位置开始，光标所经过的地方会被选中，再按一下v结束。
-
-V 从光标当前行开始，光标经过的行都会被选中，再按一下Ｖ结束。
-
-Ctrl + v 从光标当前位置开始，选中光标起点和终点所构成的矩形区域，再按一下Ｃtrl + v结束。
-
-ggVG 选中全部的文本， 其中gg为跳到行首，V选中整行，G末尾
-
-选中后就可以用编辑命令对其进行编辑，如
-d 删除
-
-y 复制 （默认是复制到"寄存器）
-
-p 粘贴 （默认从"寄存器取出内容粘贴）
-
-"+y 复制到系统剪贴板(也就是vim的+寄存器 " + y 是三个字符，即：先按" 然后 + 最后 p）
-
-"+p 从系统剪贴板粘贴
-
-vim命令总结
-
-### 1.删除字符
-要删除一个字符，只需要将光标移到该字符上按下"x"。
-
-### 2.删除一行
-删除一整行内容使用"dd"命令。删除后下面的行会移上来填补空缺。
-
-### 3.删除换行符
-在Vim中你可以把两行合并为一行，也就是说两行之间的换行符被删除了：命令是"J"。
-
-### 4.撤销
-如果你误删了过多的内容。显然你可以再输入一遍，但是命令"u" 更简便，它可以撤消上一次的操作。
-
-### 5.重做
-如果你撤消了多次，你还可以用CTRL-R(重做)来反转撤消的动作。换句话说，它是对撤消的撤消。撤消命令还有另一种形式，"U"命令，它一次撤消对一行的全部操作。第二次使用该命令则会撤消前一个"U"的操作。用"u"和CTRL-R你可以找回任何一个操作状态。
-
-### 6.追加
-"i"命令可以在当前光标之前插入文本。
-"a"命令可以在当前光标之后插入文本。
-"o"命令可以在当前行的下面另起一行，并使当前模式转为Insert模式。
-"O"命令(注意是大写的字母O)将在当前行的上面另起一行。
-
-### 7.使用命令计数
-假设你要向上移动9行。这可以用"kkkkkkkkk"或"9k"来完成。事实上，很多命令都可以接受一个数字作为重复执行同一命令的次数。比如刚 才的例子，要在行尾追加三个感叹号，当时用的命令是"a!!!"。另一个办法是用"3a!"命令。3说明该命令将被重复执行3次。同样，删除3个字符可以 用"3x"。指定的数字要紧挨在它所要修饰的命令前面。
-
-### 8.退出
-要退出Vim，用命令"ZZ"。该命令保存当前文件并退出Vim。
-
-### 9.放弃编辑
-丢弃所有的修改并退出，用命令":q!"。用":e!"命令放弃所有修改并重新载入该文件的原始内容。
-
-### 10.以Word为单位的移动
-使用"w"命令可以将光标向前移动一个word的首字符上；比如"3w"将光标向前移动3个words。"b"命令则将光标向后移动到前一个word的首字符上。
-"e"命令会将光标移动到下一个word的最后一个字符。命令"ge"，它将光标移动到前一个word的最后一个字符上。、
-
-### 11.移动到行首或行尾
-"$"命令将光标移动到当前行行尾。如果你的键盘上有一个键，它的作用也一样。"^"命令将光标移动到当前行的第一个非空白字符上。"0"命令则总 是把光标移动到当前行的第一个字符上。键也是如此。"$"命令还可接受一个计数，如"1$"会将光标移动到当前行行尾，"2$"则会移动到下一行的行尾， 如此类推。"0"命令却不能接受类似这样的计数，命令"^"前加上一个计数也没有任何效果。
-
-### 12.移动到指定字符上
-命令"fx"在当前行上查找下一个字符x（向右方向），可以带一个命令计数"F"命令向左方向搜索。"tx"命令形同"fx"命令，只不过它不是把 光标停留在被搜索字符上，而是在它之前的一个字符上。提示："t"意为"To"。该命令的反方向版是"Tx"。这4个命令都可以用";"来重复。以"," 也是重复同样的命令，但是方向与原命令的方向相反。
-
-### 13.以匹配一个括号为目的移动
-用命令"%"跳转到与当前光标下的括号相匹配的那一个括号上去。如果当前光标在"("上，它就向前跳转到与它匹配的")"上，如果当前在")"上，它就向后自动跳转到匹配的"("上去.
-
-### 14.移动到指定行
-用"G"命令指定一个命令计数，这个命令就会把光标定位到由命令计数指定的行上。比如"33G"就会把光标置于第33行上。没有指定命令计数作为参数的话, "G"会把光标定位到最后一行上。"gg"命令是跳转到第一行的快捷的方法。
-另一个移动到某行的方法是在命令"%"之前指定一个命令计数比如"50%"将会把光标定位在文件的中间. "90%"跳到接近文件尾的地方。
-命令"H","M","L",分别将光标跳转到第一行，中间行，结尾行部分。
-
-### 15.告诉你当前的位置
-使用CTRL-G命令。"set number"在每行的前面显示一个行号。相反关闭行号用命令":set nonumber"。":set ruler"在Vim窗口的右下角显示当前光标位置。
-
-### 16.滚屏
-CTRL-U显示文本的窗口向上滚动了半屏。CTRL-D命令将窗口向下移动半屏。一次滚动一行可以使用CTRL-E(向上滚动)和CTRL- Y(向下滚动)。要向前滚动一整屏使用命令CTRL-F。另外CTRL-B是它的反向版。"zz"命令会把当前行置为屏幕正中央，"zt"命令会把当前行 置于屏幕顶端，"zb"则把当前行置于屏幕底端.
-
-### 17.简单搜索
-"/string"命令可用于搜索一个字符串。要查找上次查找的字符串的下一个位置,使用"n"命令。如果你知道你要找的确切位置是目标字符串的第几次出现，还可以在"n"之前放置一个命令计数。"3n"会去查找目标字符串的第3次出现。
-"?"命令与"/"的工作相同，只是搜索方向相反."N"命令会重复前一次查找，但是与最初用"/"或"?"指定的搜索方向相反。
-如果查找内容忽略大小写，则用命令"set ignorecase", 返回精确匹配用命令"set noignorecase" 。
-
-### 18.在文本中查找下一个word
-把光标定位于这个word上然后按下""键。Vim将会取当前光标所在的word并将它作用目标字符串进行搜索。"#"命令是""的反向版。还可以在这两个命令前加一个命令计数:"3*"查找当前光标下的word的第三次出现。
-
-### 19.查找整个word
-如果你用"/the"来查找Vim也会匹配到"there"。要查找作为独立单词的"the"使用如下命令："/the>"。">"是 一个特殊的记法，它只匹配一个word的结束处。近似地，"<"匹配到一个word的开始处。这样查找作为一个word的"the"就可以 用:"/"。
-
-### 20.高亮显示搜索结果
-开启这一功能用":set hlsearch"，关闭这一功能：":set nohlsearch"。如果只是想去掉当前的高亮显示，可以使用下面的命令：":nohlsearch"(可以简写为noh)。
-
-### 21.匹配一行的开头与结尾
-^ 字符匹配一行的开头。字符匹配一行的末尾。所以"/was"只匹配位于一行末尾的单词was，所以"/^was"只匹配位于一行开始的单词was。
-
-### 22.匹配任何的单字符
-.这个字符可以匹配到任何字符。比如"c.m"可以匹配任何前一个字符是c，后一个字符是m的情况，不管中间的字符是什么。
-
-### 23.匹配特殊字符
-放一个反斜杠在特殊字符前面。如果你查找"ter。"，用命令"/ter。"
-
-### 24.使用标记
-当你用"G"命令从一个地方跳转到另一个地方时，Vim会记得你起跳的位置。这个位置在Vim中是一个标记。使用命令" "可以使你跳回到刚才的出发点。命令可以在两点之间来回跳转。CTRL-O命令是跳转到你更早些时间停置光标的位置(提示:O意为older). CTRL-I则是跳回到后来停置光标的更新的位置(提示：I在键盘上位于O前面)。
-注:使用CTRL-I 与按下键一样。
-
-### 25.具名标记
-命令"ma"将当前光标下的位置名之为标记"a"。从a到z一共可以使用26个自定义的标记。要跳转到一个你定义过的标记，使用命令" marks "marks就是定义的标记的名字。命令" 'a "使你跳转到a所在行的行首，"a "会精确定位a所在的位置。命令：":marks"用来查看标记的列表。
-命令delm！删除所有标记。
-
-### 26.操作符命令和位移
-"dw"命令可以删除一个word，"d4w"命令是删除4个word，依此类推。类似有"d2e"、"d$"。此类命令有一个固定的模式：操作符 命令+位移命令。首先键入一个操作符命令。比如"d"是一个删除操作符。接下来是一个位移命。比如"w"。这样任何移动光标命令所及之处，都是命令的作用 范围。
-
-### 27.改变文本
-操作符命令是"c"，改变命令。它的行为与"d"命令类似，不过在命令执行后会进入Insert模式。比如"cw"改变一个word。或者，更准确地说，它删除一个word并让你置身于Insert模式。
-"cc"命令可以改变整行。不过仍保持原来的缩进。
-"c$"改变当前光标到行尾的内容。
-快捷命令：x 代表dl(删除当前光标下的字符)
-X 代表dh(删除当前光标左边的字符)
-D 代表d$(删除到行尾的内容)
-C 代表c$(修改到行尾的内容)
-s 代表cl(修改一个字符)
-S 代表cc(修改一整行)
-命令"3dw"和"d3w"都是删除3个word。第一个命令"3dw"可以看作是删除一个word的操作执行3次；第二个命令"d3w"是一次删除3个 word。这是其中不明显的差异。事实上你可以在两处都放上命令记数，比如，"3d2w"是删除两个word，重复执行3次，总共是6个word。
-
-### 28.替换单个字符
-"r"命令不是一个操作符命令。它等待你键入下一个字符用以替换当前光标下的那个字符。"r"命令前辍以一个命令记数是将多个字符都替换为即将输入 的那个字符。要把一个字符替换为一个换行符使用"r"。它会删除一个字符并插入一个换行符。在此处使用命令记数只会删除指定个数的字符："4r"将把4个 字符替换为一个换行符。
-
-### 29.重复改动
-"."命令会重复上一次做出的改动。"."命令会重复你做出的所有修改，除了"u"命令CTRL-R和以冒号开头的命令。"."需要在Normal模式下执行，它重复的是命令，而不是被改动的内容，
-
-### 30.Visual模式
-按"v"可以进入Visual模式。移动光标以覆盖你想操纵的文本范围。同时被选中的文本会以高亮显示。最后键入操作符命令。
-
-### 31.移动文本
-以"d"或"x"这样的命令删除文本时，被删除的内容还是被保存了起来。你还可以用p命令把它取回来。"P"命令是把被去回的内容放在光标之 前，"p"则是放在光标之后。对于以"dd"删除的整行内容，"P"会把它置于当前行的上一行。"p"则是至于当前行的后一行。也可以对命令"p" 和"P"命令使用命令记数。它的效果是同样的内容被取回指定的次数。这样一来"dd"之后的"3p"就可以把被删除行的3 份副本放到当前位置。
-命令"xp"将光标所在的字符与后一个字符交换。
-
-### 32.复制文本（VIM编辑器内复制）
-"y"操作符命令会把文本复制到一个寄存器3中。然后可以用"p"命令把它取回。因为"y"是一个操作符命令，所以你可以用"yw"来复制一个 word. 同样可以使用命令记数。如下例中用"y2w"命令复制两个word，"yy"命令复制一整行，"Y"也是复制整行的内容，复制当前光标至行尾的命令 是"y$"。
-
-### 33.文本对象
-"diw" 删除当前光标所在的word(不包括空白字符) "daw" 删除当前光标所在的word(包括空白字符)
-
-### 34.快捷命令
-x 删除当前光标下的字符("dl"的快捷命令)
-X 删除当前光标之前的字符("dh"的快捷命令)
-D 删除自当前光标至行尾的内容("d$"的快捷命令)
-dw 删除自当前光标至下一个word的开头
-db 删除自当前光标至前一个word的开始
-diw 删除当前光标所在的word(不包括空白字符)
-daw 删除当前光标所在的word(包括空白字符)
-dG 删除当前行至文件尾的内容
-dgg 删除当前行至文件头的内容
-如果你用"c"命令代替"d"这些命令就都变成更改命令。使用"y"就是yank命令，如此类推。
-
-### 35.编辑另一个文件
-用命令":edit foo.txt"，也可简写为":e foo.txt"。
-
-### 36.文件列表
-可以在启动Vim时就指定要编辑多个文件，用命令"vim one.c two.c three.c"。Vim将在启动后只显示第一个文件，完成该文件的编辑后，可以用令：":next"或":n"要保存工作成果并继续下一个文件的编辑， 命令：":wnext"或":wn"可以合并这一过程。
-
-### 37.显示当前正在编辑的文件
-用命令":args"。
-
-### 38.移动到另一个文件
-用命令":previous" ":prev"回到上一个文件,合并保存步骤则是":wprevious" ":wprev"。要移到最后一个文件":last",到第一个":first".不过没有":wlast"或者":wfirst"这样的命令。可以 在":next"和":previous"命令前面使用一个命令计数。
-
-### 39.编辑另一个文件列表
-不用重新启动Vim，就可以重新定义一个文件列表。命令":args five.c six.c seven.h"定义了要编辑的三个文件。
-
-### 39.自动存盘
-命令":set autowrite","set aw"。自动把内容写回文件: 如果文件被修改过，在每 个:next、:rewind、:last、:first、:previous、:stop、:suspend、:tag、:!、:make、 CTRL-] 和 CTRL-^命令时进行。
-命令":set autowriteall","set awa"。和 'autowrite' 类似，但也适用于":edit"、":enew"、":quit"、":qall"、":exit"、":xit"、":recover" 和关闭 Vim 窗口。置位本选项也意味着 Vim 的行为就像打开 'autowrite' 一样。
-
-### 40.切换到另一文件
-要在两个文件间快速切换，使用CTRL-^。
-
-### 41.文件标记
-以大写字母命名的标记。它们是全局标记，它们可以用在任何文件中。比如，正在编辑"fab1.Java",用命令"50%mF"在文件的中间设置一 个名为F的标记。然后在"fab2.java"文件中，用命令"GnB"在最后一行设置名为B的标记。在可以用"F"命令跳转到文 件"fab1.java"的半中间。或者编辑另一个文件，"'B"命令会再把你带回文件"fab2.java"的最后一行。
-要知道某个标记所代表的位置是什么，可以将该标记的名字作为"marks"命令的参数":marks M"或者连续跟上几个参数":marks MJK"
-可以用CTRL-O和CTRL-I可以跳转到较早的位置和靠后的某位置。
-
-### 42.查看文件
-仅是查看文件，不向文件写入内容，可以用只读形式编辑文件。用命令：
-vim -R file。如果是想强制性地避免对文件进行修改，可以用命令：
-vim -M file。
-
-### 43.更改文件名
-将现有文件存成新的文件，用命令":sav(eas) move.c"。如果想改变当前正在编辑的文件名，但不想保存该文件，就可以用命令：":f(ile) move.c"。
-
-### 44.分割一个窗口
-打开一个新窗口最简单的办法就是使用命令：":split"。CTRL-W 命令可以切换当前活动窗口。
-
-### 45.关闭窗口
-用命令："close".可以关闭当前窗口。实际上,任何退出文件编辑的命令":quit"和"ZZ"都会关闭窗口，但是用":close"可以阻止你关闭最后一个Vim，以免以意外地整个关闭了Vim。
-
-### 46.关闭除当前窗口外的所有其他窗口
-用命令：":only",关闭除当前窗口外的所有其它窗口。如果这些窗口中有被修改过的，你会得到一个错误信息，同时那个窗口会被留下来。
-
-### 47.为另一个文件分隔出一个窗口
-命令":split two.c"可以打开第二个窗口同时在新打开的窗口中开始编辑作为
-参数的文件。如果要打开一个新窗口并开始编辑一个空的缓冲区，使用命令:":new"。
-
-### 48.垂直分割
-用命令":vsplit或：:vsplit two.c"。同样有一个对应的":vnew"命令，用于垂直分隔窗口并在其中打开一个新的空缓冲区。
-
-### 49.切换窗口
-CTRL-W h 到左边的窗口
-CTRL-W j 到下面的窗口
-CTRL-W k 到上面的窗口
-CTRL-W l 到右边的窗口
-CTRL-W t 到顶部窗口
-CTRL-W b 到底部窗口
-
-### 50.针对所有窗口操作的命令
-":qall"放弃所有操作并退出，":wall"保存所有，":wqall"保存所有并退出。
-
-### 51.为每一个文件打开一个窗口
-使用"-o"选项可以让Vim为每一个文件打开一个窗口：
-"vim -o one.txt two.txt three.txt"。
-
-### 52.使用vimdiff查看不同
-"vimdiff main.c~ main.c",另一种进入diff模式的办法可以在Vim运行中操作。编辑文件"main.c"，然后打开另一个分隔窗口显示其不同:
-":edit main.c"
-":vertical diffpatch main.c.diff"。
-
-### 53.页签
-命令":tabe(dit) thatfile"在一个窗口中打开"thatfile"，该窗口占据着整个的Vim显示区域。命令":tab split/new"结果是新建了一个拥有一个窗口的页签。以用"gt"命令在不同的页签间切换。
-
-这是我总结的一些基本用法,可能对初用者会有帮助,独乐乐不如众乐乐,是吧!
-
-说明：以下黑色为vi和vim均有的一般功能，而红色为Vim（Vi Improved）所特有功能。Vim一般的Unix和Linux下均有安装。
-
-### 三种状态
-Command： 任何输入都会作为编辑命令，而不会出现在屏幕上，任何输入都引起立即反映
-Insert： 任何输入的数据都置于编辑寄存器，按ESC，可跳回command方式
-Escape： 以“：”或者“/”为前导的指令，出现在屏幕的最下一行，任何输入都被当成特别指令。
-
-### 离开vi
-:q! 离开vi，并放弃刚在缓冲区内编辑的内容。
-:wq 将缓冲区内的资料写入磁盘中，并离开vi。
-:x 同wq。
-（注意—— :X 是文件加密，一定要与:x存盘退出相区别）
-
-### 进入输入模式
-a (append) 由游标之后加入资料。
-A 由该行之末加入资料。
-i (insert) 由游标之前加入资料。
-I 由该行之首加入资料。
-o (open) 新增一行於该行之下供输入资料之用。
-O 新增一行於该行之上供输入资料之用。
-
-### 删除与修改
-x 删除游标所在该字元。
-X 删除游标所在之前一字元。
-r 用接於此指令之后的字元取代(replace)游标所在字元。如：ra将游标所在字元以 a 取代之。
-R 进入取代状态，直到《ESC》为止。
-s 删除游标所在之字元，并进入输入模式直到《ESC》。
-S 删除游标所在之该行资料，并进入输入模式直到《ESC》。
-
-### 光标的移动
-0 移至该行之首
-$ 移至该行之末。
-e 移动到下个字的最後一个字母
-w 移动到下个字的第一个字母。
-b 移动到上个字的第一个字母。
-^ 移至该行的第一个字元处。
-H 移至视窗的第一行。
-M 移至视窗的中间那行。
-L 移至视窗的最后一行。
-G 移至该文件的最后一行。
-+ 移至下一列的第一个字元处。
-- 移至上一列的第一个字元处。
-:n 移至该文件的第 n 列。
-n+ 移至游标所在位置之后的第 n 列。
-n- 移至游标所在位置之前的第 n 列。
-Ctrl+g 显示该行之行号、文件名称、文件中最末行之行号、游标所在行号占总行号之百分比。
-
-### 视窗的移动
-Ctrl+f 视窗往下卷一页。
-Ctrl+b 视窗往上卷一页。
-Ctrl+d 视窗往下卷半页。
-Ctrl+u 视窗往上卷半页。
-Ctrl+e 视窗往下卷一行。
-Ctrl+y 视窗往上卷一行。
-
-### 剪切、复制、删除
-Operator + Scope = command
-Operator
-d 剪切
-y 复制。
-p 粘帖，与 d 和 y 配和使用。可将最后d或y的资料放置於游标所在位置之行列下。
-c 修改，类似delete与insert的组和。删除一个字组、句子等之资料，并插入新建资料。
-Scope
-e 由游标所在位置至该字串的最后一个字元。
-w 由游标所在位置至下一个字串的第一个字元。
-b 由游标所在位置至前一个字串的第一个字元。
-$ 由游标所在位置至该行的最后一个字元。
-0 由游标所在位置至该行的第一个字元。
-
-### 整行动作
-dd 删除整行。
-D 以行为单位，删除游标后之所有字元。
-cc 修改整行的内容。
-yy 使游标所在该行复制到记忆体缓冲区。
-
-### 取消前一动作(Undo)
-u 恢复最后一个指令之前的结果。
-U 恢复游标该行之所有改变。
-u 可以多次撤消指令，一次撤消一个操作，直至本次操作开始为止。
-Ctrl+r 可以恢复撤消前内容，按多次可恢复多次。
-
-### 查找与替换
-/字串 往游标之后寻找该字串。
-?字串 往游标之前寻找该字串。
-n 往下继续寻找下一个相同的字串。
-N 往上继续寻找下一个相同的字串。
-% 查找“(”，“)”，“{”，“}”的配对符。
-s 搜寻某行列范围。
-g 搜寻整个编辑缓冲区的资料。
-:1,$s/old/new/g 将文件中所有的『old』改成『new』。
-:10,20s/^/ / 将第10行至第20行资料的最前面插入5个空白。
-(vim)
-/字符串 后边输入查询内容可保存至缓冲区中，可用↑↓进行以往内容选择。
-另外：将光标移动在选定单词下方按*，则可以选中此单词作为查询字符，可以避免输入一长串字符的麻烦。
-
-### 大小写替换
-首先用按v开启选择功能，然后用↑↓←→键来选定所要替换的字符，若是小写变大写，则按U;反之按u;
-如果是选择单词，则可以在按v后，按w，最后按U/u,这样就可以将字符随意的改变大小写了，而不用删除后重新敲入。
-
-### 资料的连接
-句子的连接。将游标所在之下一行连接至游标该行的后面。
-环境的设定
-:set all 可设置的环境变量列表
-:set 环境变量的当前值
-:set nu 设定资料的行号。
-:set nonu 取消行号设定。
-:set ai 自动内缩。
-:set noai 取消自动内缩。
-:set ruler 会在屏幕右下角显示当前光标所处位置，并随光移动而改变，占用屏幕空间较小，使用也比较方便，推荐使用。
-:set hlsearch 在使用查找功能时，会高亮显示所有匹配的内容。
-:set nohlsearch 关闭此功能。
-:set incsearch 使Vim在输入字符串的过程中，光标就可定位显示匹配点。
-:set nowrapscan 关闭查找自动回环功能，即查找到文件结尾处，结束查找；默认状态是自动回环
-
-### ex指令
-读写资料
-:10,20w test 将第10行至第20行的资料写入test文件。
-:10,20w>>test 将第10行至第20行的资料加在test文件之后。
-:r test 将test文件的资料读入编辑缓冲区的最后。
-:e [filename] 编辑新的文件。
-:e! [filename] 放弃当前修改的文件，编辑新的文件。
-:sh 进入shell环境，使用exit退出，回到编辑器中。
-
-:!cmd 运行命令cmd后，返回到编辑器中。
-
-### 删除、复制及搬移
-:10,20d 删除第10行至第20行的资料。
-:10d 删除第10行的资料。
-:%d 删除整个编辑缓冲区。
-:10,20co30 将第10行至第20行的资料复制至第30行之后。
-:10,20mo30 将第10行至第20行的资料搬移至第30行之后。
+vim 选择文本，删除，复制，粘贴
+
+文本的选择，对于编辑器来说，是很基本的东西，也经常被用到，总结如下：
+
+v 从光标当前位置开始，光标所经过的地方会被选中，再按一下v结束。
+
+V 从光标当前行开始，光标经过的行都会被选中，再按一下Ｖ结束。
+
+Ctrl + v 从光标当前位置开始，选中光标起点和终点所构成的矩形区域，再按一下Ｃtrl + v结束。
+
+ggVG 选中全部的文本， 其中gg为跳到行首，V选中整行，G末尾
+
+选中后就可以用编辑命令对其进行编辑，如
+d 删除
+
+y 复制 （默认是复制到"寄存器）
+
+p 粘贴 （默认从"寄存器取出内容粘贴）
+
+"+y 复制到系统剪贴板(也就是vim的+寄存器 " + y 是三个字符，即：先按" 然后 + 最后 p）
+
+"+p 从系统剪贴板粘贴
+
+vim命令总结
+
+### 1.删除字符
+要删除一个字符，只需要将光标移到该字符上按下"x"。
+
+### 2.删除一行
+删除一整行内容使用"dd"命令。删除后下面的行会移上来填补空缺。
+
+### 3.删除换行符
+在Vim中你可以把两行合并为一行，也就是说两行之间的换行符被删除了：命令是"J"。
+
+### 4.撤销
+如果你误删了过多的内容。显然你可以再输入一遍，但是命令"u" 更简便，它可以撤消上一次的操作。
+
+### 5.重做
+如果你撤消了多次，你还可以用CTRL-R(重做)来反转撤消的动作。换句话说，它是对撤消的撤消。撤消命令还有另一种形式，"U"命令，它一次撤消对一行的全部操作。第二次使用该命令则会撤消前一个"U"的操作。用"u"和CTRL-R你可以找回任何一个操作状态。
+
+### 6.追加
+"i"命令可以在当前光标之前插入文本。
+"a"命令可以在当前光标之后插入文本。
+"o"命令可以在当前行的下面另起一行，并使当前模式转为Insert模式。
+"O"命令(注意是大写的字母O)将在当前行的上面另起一行。
+
+### 7.使用命令计数
+假设你要向上移动9行。这可以用"kkkkkkkkk"或"9k"来完成。事实上，很多命令都可以接受一个数字作为重复执行同一命令的次数。比如刚 才的例子，要在行尾追加三个感叹号，当时用的命令是"a!!!"。另一个办法是用"3a!"命令。3说明该命令将被重复执行3次。同样，删除3个字符可以 用"3x"。指定的数字要紧挨在它所要修饰的命令前面。
+
+### 8.退出
+要退出Vim，用命令"ZZ"。该命令保存当前文件并退出Vim。
+
+### 9.放弃编辑
+丢弃所有的修改并退出，用命令":q!"。用":e!"命令放弃所有修改并重新载入该文件的原始内容。
+
+### 10.以Word为单位的移动
+使用"w"命令可以将光标向前移动一个word的首字符上；比如"3w"将光标向前移动3个words。"b"命令则将光标向后移动到前一个word的首字符上。
+"e"命令会将光标移动到下一个word的最后一个字符。命令"ge"，它将光标移动到前一个word的最后一个字符上。、
+
+### 11.移动到行首或行尾
+"$"命令将光标移动到当前行行尾。如果你的键盘上有一个键，它的作用也一样。"^"命令将光标移动到当前行的第一个非空白字符上。"0"命令则总 是把光标移动到当前行的第一个字符上。键也是如此。"$"命令还可接受一个计数，如"1$"会将光标移动到当前行行尾，"2$"则会移动到下一行的行尾， 如此类推。"0"命令却不能接受类似这样的计数，命令"^"前加上一个计数也没有任何效果。
+
+### 12.移动到指定字符上
+命令"fx"在当前行上查找下一个字符x（向右方向），可以带一个命令计数"F"命令向左方向搜索。"tx"命令形同"fx"命令，只不过它不是把 光标停留在被搜索字符上，而是在它之前的一个字符上。提示："t"意为"To"。该命令的反方向版是"Tx"。这4个命令都可以用";"来重复。以"," 也是重复同样的命令，但是方向与原命令的方向相反。
+
+### 13.以匹配一个括号为目的移动
+用命令"%"跳转到与当前光标下的括号相匹配的那一个括号上去。如果当前光标在"("上，它就向前跳转到与它匹配的")"上，如果当前在")"上，它就向后自动跳转到匹配的"("上去.
+
+### 14.移动到指定行
+用"G"命令指定一个命令计数，这个命令就会把光标定位到由命令计数指定的行上。比如"33G"就会把光标置于第33行上。没有指定命令计数作为参数的话, "G"会把光标定位到最后一行上。"gg"命令是跳转到第一行的快捷的方法。
+另一个移动到某行的方法是在命令"%"之前指定一个命令计数比如"50%"将会把光标定位在文件的中间. "90%"跳到接近文件尾的地方。
+命令"H","M","L",分别将光标跳转到第一行，中间行，结尾行部分。
+
+### 15.告诉你当前的位置
+使用CTRL-G命令。"set number"在每行的前面显示一个行号。相反关闭行号用命令":set nonumber"。":set ruler"在Vim窗口的右下角显示当前光标位置。
+
+### 16.滚屏
+CTRL-U显示文本的窗口向上滚动了半屏。CTRL-D命令将窗口向下移动半屏。一次滚动一行可以使用CTRL-E(向上滚动)和CTRL- Y(向下滚动)。要向前滚动一整屏使用命令CTRL-F。另外CTRL-B是它的反向版。"zz"命令会把当前行置为屏幕正中央，"zt"命令会把当前行 置于屏幕顶端，"zb"则把当前行置于屏幕底端.
+
+### 17.简单搜索
+"/string"命令可用于搜索一个字符串。要查找上次查找的字符串的下一个位置,使用"n"命令。如果你知道你要找的确切位置是目标字符串的第几次出现，还可以在"n"之前放置一个命令计数。"3n"会去查找目标字符串的第3次出现。
+"?"命令与"/"的工作相同，只是搜索方向相反."N"命令会重复前一次查找，但是与最初用"/"或"?"指定的搜索方向相反。
+如果查找内容忽略大小写，则用命令"set ignorecase", 返回精确匹配用命令"set noignorecase" 。
+
+### 18.在文本中查找下一个word
+把光标定位于这个word上然后按下""键。Vim将会取当前光标所在的word并将它作用目标字符串进行搜索。"#"命令是""的反向版。还可以在这两个命令前加一个命令计数:"3*"查找当前光标下的word的第三次出现。
+
+### 19.查找整个word
+如果你用"/the"来查找Vim也会匹配到"there"。要查找作为独立单词的"the"使用如下命令："/the>"。">"是 一个特殊的记法，它只匹配一个word的结束处。近似地，"<"匹配到一个word的开始处。这样查找作为一个word的"the"就可以 用:"/"。
+
+### 20.高亮显示搜索结果
+开启这一功能用":set hlsearch"，关闭这一功能：":set nohlsearch"。如果只是想去掉当前的高亮显示，可以使用下面的命令：":nohlsearch"(可以简写为noh)。
+
+### 21.匹配一行的开头与结尾
+^ 字符匹配一行的开头。字符匹配一行的末尾。所以"/was"只匹配位于一行末尾的单词was，所以"/^was"只匹配位于一行开始的单词was。
+
+### 22.匹配任何的单字符
+.这个字符可以匹配到任何字符。比如"c.m"可以匹配任何前一个字符是c，后一个字符是m的情况，不管中间的字符是什么。
+
+### 23.匹配特殊字符
+放一个反斜杠在特殊字符前面。如果你查找"ter。"，用命令"/ter。"
+
+### 24.使用标记
+当你用"G"命令从一个地方跳转到另一个地方时，Vim会记得你起跳的位置。这个位置在Vim中是一个标记。使用命令" "可以使你跳回到刚才的出发点。命令可以在两点之间来回跳转。CTRL-O命令是跳转到你更早些时间停置光标的位置(提示:O意为older). CTRL-I则是跳回到后来停置光标的更新的位置(提示：I在键盘上位于O前面)。
+注:使用CTRL-I 与按下键一样。
+
+### 25.具名标记
+命令"ma"将当前光标下的位置名之为标记"a"。从a到z一共可以使用26个自定义的标记。要跳转到一个你定义过的标记，使用命令" marks "marks就是定义的标记的名字。命令" 'a "使你跳转到a所在行的行首，"a "会精确定位a所在的位置。命令：":marks"用来查看标记的列表。
+命令delm！删除所有标记。
+
+### 26.操作符命令和位移
+"dw"命令可以删除一个word，"d4w"命令是删除4个word，依此类推。类似有"d2e"、"d$"。此类命令有一个固定的模式：操作符 命令+位移命令。首先键入一个操作符命令。比如"d"是一个删除操作符。接下来是一个位移命。比如"w"。这样任何移动光标命令所及之处，都是命令的作用 范围。
+
+### 27.改变文本
+操作符命令是"c"，改变命令。它的行为与"d"命令类似，不过在命令执行后会进入Insert模式。比如"cw"改变一个word。或者，更准确地说，它删除一个word并让你置身于Insert模式。
+"cc"命令可以改变整行。不过仍保持原来的缩进。
+"c$"改变当前光标到行尾的内容。
+快捷命令：x 代表dl(删除当前光标下的字符)
+X 代表dh(删除当前光标左边的字符)
+D 代表d$(删除到行尾的内容)
+C 代表c$(修改到行尾的内容)
+s 代表cl(修改一个字符)
+S 代表cc(修改一整行)
+命令"3dw"和"d3w"都是删除3个word。第一个命令"3dw"可以看作是删除一个word的操作执行3次；第二个命令"d3w"是一次删除3个 word。这是其中不明显的差异。事实上你可以在两处都放上命令记数，比如，"3d2w"是删除两个word，重复执行3次，总共是6个word。
+
+### 28.替换单个字符
+"r"命令不是一个操作符命令。它等待你键入下一个字符用以替换当前光标下的那个字符。"r"命令前辍以一个命令记数是将多个字符都替换为即将输入 的那个字符。要把一个字符替换为一个换行符使用"r"。它会删除一个字符并插入一个换行符。在此处使用命令记数只会删除指定个数的字符："4r"将把4个 字符替换为一个换行符。
+
+### 29.重复改动
+"."命令会重复上一次做出的改动。"."命令会重复你做出的所有修改，除了"u"命令CTRL-R和以冒号开头的命令。"."需要在Normal模式下执行，它重复的是命令，而不是被改动的内容，
+
+### 30.Visual模式
+按"v"可以进入Visual模式。移动光标以覆盖你想操纵的文本范围。同时被选中的文本会以高亮显示。最后键入操作符命令。
+
+### 31.移动文本
+以"d"或"x"这样的命令删除文本时，被删除的内容还是被保存了起来。你还可以用p命令把它取回来。"P"命令是把被去回的内容放在光标之 前，"p"则是放在光标之后。对于以"dd"删除的整行内容，"P"会把它置于当前行的上一行。"p"则是至于当前行的后一行。也可以对命令"p" 和"P"命令使用命令记数。它的效果是同样的内容被取回指定的次数。这样一来"dd"之后的"3p"就可以把被删除行的3 份副本放到当前位置。
+命令"xp"将光标所在的字符与后一个字符交换。
+
+### 32.复制文本（VIM编辑器内复制）
+"y"操作符命令会把文本复制到一个寄存器3中。然后可以用"p"命令把它取回。因为"y"是一个操作符命令，所以你可以用"yw"来复制一个 word. 同样可以使用命令记数。如下例中用"y2w"命令复制两个word，"yy"命令复制一整行，"Y"也是复制整行的内容，复制当前光标至行尾的命令 是"y$"。
+
+### 33.文本对象
+"diw" 删除当前光标所在的word(不包括空白字符) "daw" 删除当前光标所在的word(包括空白字符)
+
+### 34.快捷命令
+x 删除当前光标下的字符("dl"的快捷命令)
+X 删除当前光标之前的字符("dh"的快捷命令)
+D 删除自当前光标至行尾的内容("d$"的快捷命令)
+dw 删除自当前光标至下一个word的开头
+db 删除自当前光标至前一个word的开始
+diw 删除当前光标所在的word(不包括空白字符)
+daw 删除当前光标所在的word(包括空白字符)
+dG 删除当前行至文件尾的内容
+dgg 删除当前行至文件头的内容
+如果你用"c"命令代替"d"这些命令就都变成更改命令。使用"y"就是yank命令，如此类推。
+
+### 35.编辑另一个文件
+用命令":edit foo.txt"，也可简写为":e foo.txt"。
+
+### 36.文件列表
+可以在启动Vim时就指定要编辑多个文件，用命令"vim one.c two.c three.c"。Vim将在启动后只显示第一个文件，完成该文件的编辑后，可以用令：":next"或":n"要保存工作成果并继续下一个文件的编辑， 命令：":wnext"或":wn"可以合并这一过程。
+
+### 37.显示当前正在编辑的文件
+用命令":args"。
+
+### 38.移动到另一个文件
+用命令":previous" ":prev"回到上一个文件,合并保存步骤则是":wprevious" ":wprev"。要移到最后一个文件":last",到第一个":first".不过没有":wlast"或者":wfirst"这样的命令。可以 在":next"和":previous"命令前面使用一个命令计数。
+
+### 39.编辑另一个文件列表
+不用重新启动Vim，就可以重新定义一个文件列表。命令":args five.c six.c seven.h"定义了要编辑的三个文件。
+
+### 39.自动存盘
+命令":set autowrite","set aw"。自动把内容写回文件: 如果文件被修改过，在每 个:next、:rewind、:last、:first、:previous、:stop、:suspend、:tag、:!、:make、 CTRL-] 和 CTRL-^命令时进行。
+命令":set autowriteall","set awa"。和 'autowrite' 类似，但也适用于":edit"、":enew"、":quit"、":qall"、":exit"、":xit"、":recover" 和关闭 Vim 窗口。置位本选项也意味着 Vim 的行为就像打开 'autowrite' 一样。
+
+### 40.切换到另一文件
+要在两个文件间快速切换，使用CTRL-^。
+
+### 41.文件标记
+以大写字母命名的标记。它们是全局标记，它们可以用在任何文件中。比如，正在编辑"fab1.Java",用命令"50%mF"在文件的中间设置一 个名为F的标记。然后在"fab2.java"文件中，用命令"GnB"在最后一行设置名为B的标记。在可以用"F"命令跳转到文 件"fab1.java"的半中间。或者编辑另一个文件，"'B"命令会再把你带回文件"fab2.java"的最后一行。
+要知道某个标记所代表的位置是什么，可以将该标记的名字作为"marks"命令的参数":marks M"或者连续跟上几个参数":marks MJK"
+可以用CTRL-O和CTRL-I可以跳转到较早的位置和靠后的某位置。
+
+### 42.查看文件
+仅是查看文件，不向文件写入内容，可以用只读形式编辑文件。用命令：
+vim -R file。如果是想强制性地避免对文件进行修改，可以用命令：
+vim -M file。
+
+### 43.更改文件名
+将现有文件存成新的文件，用命令":sav(eas) move.c"。如果想改变当前正在编辑的文件名，但不想保存该文件，就可以用命令：":f(ile) move.c"。
+
+### 44.分割一个窗口
+打开一个新窗口最简单的办法就是使用命令：":split"。CTRL-W 命令可以切换当前活动窗口。
+
+### 45.关闭窗口
+用命令："close".可以关闭当前窗口。实际上,任何退出文件编辑的命令":quit"和"ZZ"都会关闭窗口，但是用":close"可以阻止你关闭最后一个Vim，以免以意外地整个关闭了Vim。
+
+### 46.关闭除当前窗口外的所有其他窗口
+用命令：":only",关闭除当前窗口外的所有其它窗口。如果这些窗口中有被修改过的，你会得到一个错误信息，同时那个窗口会被留下来。
+
+### 47.为另一个文件分隔出一个窗口
+命令":split two.c"可以打开第二个窗口同时在新打开的窗口中开始编辑作为
+参数的文件。如果要打开一个新窗口并开始编辑一个空的缓冲区，使用命令:":new"。
+
+### 48.垂直分割
+用命令":vsplit或：:vsplit two.c"。同样有一个对应的":vnew"命令，用于垂直分隔窗口并在其中打开一个新的空缓冲区。
+
+### 49.切换窗口
+CTRL-W h 到左边的窗口
+CTRL-W j 到下面的窗口
+CTRL-W k 到上面的窗口
+CTRL-W l 到右边的窗口
+CTRL-W t 到顶部窗口
+CTRL-W b 到底部窗口
+
+### 50.针对所有窗口操作的命令
+":qall"放弃所有操作并退出，":wall"保存所有，":wqall"保存所有并退出。
+
+### 51.为每一个文件打开一个窗口
+使用"-o"选项可以让Vim为每一个文件打开一个窗口：
+"vim -o one.txt two.txt three.txt"。
+
+### 52.使用vimdiff查看不同
+"vimdiff main.c~ main.c",另一种进入diff模式的办法可以在Vim运行中操作。编辑文件"main.c"，然后打开另一个分隔窗口显示其不同:
+":edit main.c"
+":vertical diffpatch main.c.diff"。
+
+### 53.页签
+命令":tabe(dit) thatfile"在一个窗口中打开"thatfile"，该窗口占据着整个的Vim显示区域。命令":tab split/new"结果是新建了一个拥有一个窗口的页签。以用"gt"命令在不同的页签间切换。
+
+这是我总结的一些基本用法,可能对初用者会有帮助,独乐乐不如众乐乐,是吧!
+
+说明：以下黑色为vi和vim均有的一般功能，而红色为Vim（Vi Improved）所特有功能。Vim一般的Unix和Linux下均有安装。
+
+### 三种状态
+Command： 任何输入都会作为编辑命令，而不会出现在屏幕上，任何输入都引起立即反映
+Insert： 任何输入的数据都置于编辑寄存器，按ESC，可跳回command方式
+Escape： 以“：”或者“/”为前导的指令，出现在屏幕的最下一行，任何输入都被当成特别指令。
+
+### 离开vi
+:q! 离开vi，并放弃刚在缓冲区内编辑的内容。
+:wq 将缓冲区内的资料写入磁盘中，并离开vi。
+:x 同wq。
+（注意—— :X 是文件加密，一定要与:x存盘退出相区别）
+
+### 进入输入模式
+a (append) 由游标之后加入资料。
+A 由该行之末加入资料。
+i (insert) 由游标之前加入资料。
+I 由该行之首加入资料。
+o (open) 新增一行於该行之下供输入资料之用。
+O 新增一行於该行之上供输入资料之用。
+
+### 删除与修改
+x 删除游标所在该字元。
+X 删除游标所在之前一字元。
+r 用接於此指令之后的字元取代(replace)游标所在字元。如：ra将游标所在字元以 a 取代之。
+R 进入取代状态，直到《ESC》为止。
+s 删除游标所在之字元，并进入输入模式直到《ESC》。
+S 删除游标所在之该行资料，并进入输入模式直到《ESC》。
+
+### 光标的移动
+0 移至该行之首
+$ 移至该行之末。
+e 移动到下个字的最後一个字母
+w 移动到下个字的第一个字母。
+b 移动到上个字的第一个字母。
+^ 移至该行的第一个字元处。
+H 移至视窗的第一行。
+M 移至视窗的中间那行。
+L 移至视窗的最后一行。
+G 移至该文件的最后一行。
++ 移至下一列的第一个字元处。
+- 移至上一列的第一个字元处。
+:n 移至该文件的第 n 列。
+n+ 移至游标所在位置之后的第 n 列。
+n- 移至游标所在位置之前的第 n 列。
+Ctrl+g 显示该行之行号、文件名称、文件中最末行之行号、游标所在行号占总行号之百分比。
+
+### 视窗的移动
+Ctrl+f 视窗往下卷一页。
+Ctrl+b 视窗往上卷一页。
+Ctrl+d 视窗往下卷半页。
+Ctrl+u 视窗往上卷半页。
+Ctrl+e 视窗往下卷一行。
+Ctrl+y 视窗往上卷一行。
+
+### 剪切、复制、删除
+Operator + Scope = command
+Operator
+d 剪切
+y 复制。
+p 粘帖，与 d 和 y 配和使用。可将最后d或y的资料放置於游标所在位置之行列下。
+c 修改，类似delete与insert的组和。删除一个字组、句子等之资料，并插入新建资料。
+Scope
+e 由游标所在位置至该字串的最后一个字元。
+w 由游标所在位置至下一个字串的第一个字元。
+b 由游标所在位置至前一个字串的第一个字元。
+$ 由游标所在位置至该行的最后一个字元。
+0 由游标所在位置至该行的第一个字元。
+
+### 整行动作
+dd 删除整行。
+D 以行为单位，删除游标后之所有字元。
+cc 修改整行的内容。
+yy 使游标所在该行复制到记忆体缓冲区。
+
+### 取消前一动作(Undo)
+u 恢复最后一个指令之前的结果。
+U 恢复游标该行之所有改变。
+u 可以多次撤消指令，一次撤消一个操作，直至本次操作开始为止。
+Ctrl+r 可以恢复撤消前内容，按多次可恢复多次。
+
+### 查找与替换
+/字串 往游标之后寻找该字串。
+?字串 往游标之前寻找该字串。
+n 往下继续寻找下一个相同的字串。
+N 往上继续寻找下一个相同的字串。
+% 查找“(”，“)”，“{”，“}”的配对符。
+s 搜寻某行列范围。
+g 搜寻整个编辑缓冲区的资料。
+:1,$s/old/new/g 将文件中所有的『old』改成『new』。
+:10,20s/^/ / 将第10行至第20行资料的最前面插入5个空白。
+(vim)
+/字符串 后边输入查询内容可保存至缓冲区中，可用↑↓进行以往内容选择。
+另外：将光标移动在选定单词下方按*，则可以选中此单词作为查询字符，可以避免输入一长串字符的麻烦。
+
+### 大小写替换
+首先用按v开启选择功能，然后用↑↓←→键来选定所要替换的字符，若是小写变大写，则按U;反之按u;
+如果是选择单词，则可以在按v后，按w，最后按U/u,这样就可以将字符随意的改变大小写了，而不用删除后重新敲入。
+
+### 资料的连接
+句子的连接。将游标所在之下一行连接至游标该行的后面。
+环境的设定
+:set all 可设置的环境变量列表
+:set 环境变量的当前值
+:set nu 设定资料的行号。
+:set nonu 取消行号设定。
+:set ai 自动内缩。
+:set noai 取消自动内缩。
+:set ruler 会在屏幕右下角显示当前光标所处位置，并随光移动而改变，占用屏幕空间较小，使用也比较方便，推荐使用。
+:set hlsearch 在使用查找功能时，会高亮显示所有匹配的内容。
+:set nohlsearch 关闭此功能。
+:set incsearch 使Vim在输入字符串的过程中，光标就可定位显示匹配点。
+:set nowrapscan 关闭查找自动回环功能，即查找到文件结尾处，结束查找；默认状态是自动回环
+
+### ex指令
+读写资料
+:10,20w test 将第10行至第20行的资料写入test文件。
+:10,20w>>test 将第10行至第20行的资料加在test文件之后。
+:r test 将test文件的资料读入编辑缓冲区的最后。
+:e [filename] 编辑新的文件。
+:e! [filename] 放弃当前修改的文件，编辑新的文件。
+:sh 进入shell环境，使用exit退出，回到编辑器中。
+
+:!cmd 运行命令cmd后，返回到编辑器中。
+
+### 删除、复制及搬移
+:10,20d 删除第10行至第20行的资料。
+:10d 删除第10行的资料。
+:%d 删除整个编辑缓冲区。
+:10,20co30 将第10行至第20行的资料复制至第30行之后。
+:10,20mo30 将第10行至第20行的资料搬移至第30行之后。
diff --git "a/05 - OS (linux)/vi-vim/\345\270\270\347\224\250\345\221\275\344\273\244\351\200\237\346\237\245.png" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/\345\270\270\347\224\250\345\221\275\344\273\244\351\200\237\346\237\245.png"
similarity index 100%
rename from "05 - OS (linux)/vi-vim/\345\270\270\347\224\250\345\221\275\344\273\244\351\200\237\346\237\245.png"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/\345\270\270\347\224\250\345\221\275\344\273\244\351\200\237\346\237\245.png"
diff --git "a/05 - OS (linux)/vi-vim/\351\224\256\347\233\230\345\233\276.jpg" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/\351\224\256\347\233\230\345\233\276.jpg"
similarity index 100%
rename from "05 - OS (linux)/vi-vim/\351\224\256\347\233\230\345\233\276.jpg"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vi-vim/\351\224\256\347\233\230\345\233\276.jpg"
diff --git "a/05 - OS (linux)/vim \346\237\245\346\211\276\345\222\214\346\233\277\346\215\242.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vim \346\237\245\346\211\276\345\222\214\346\233\277\346\215\242.md"
similarity index 100%
rename from "05 - OS (linux)/vim \346\237\245\346\211\276\345\222\214\346\233\277\346\215\242.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/vim \346\237\245\346\211\276\345\222\214\346\233\277\346\215\242.md"
diff --git "a/05 - OS (linux)/\342\200\234\345\206\231\346\227\266\345\244\215\345\210\266\342\200\234\346\212\200\346\234\257.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\342\200\234\345\206\231\346\227\266\345\244\215\345\210\266\342\200\234\346\212\200\346\234\257.md"
similarity index 100%
rename from "05 - OS (linux)/\342\200\234\345\206\231\346\227\266\345\244\215\345\210\266\342\200\234\346\212\200\346\234\257.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\342\200\234\345\206\231\346\227\266\345\244\215\345\210\266\342\200\234\346\212\200\346\234\257.md"
diff --git "a/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\345\210\251\347\224\250vim\346\237\245\350\257\242\346\227\245\345\277\227.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\345\210\251\347\224\250vim\346\237\245\350\257\242\346\227\245\345\277\227.md"
new file mode 100644
index 00000000..3a057565
--- /dev/null
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\345\210\251\347\224\250vim\346\237\245\350\257\242\346\227\245\345\277\227.md"	
@@ -0,0 +1,33 @@
+vim 操作到 [readme.md](https://github.com/loveincode/notes/blob/master/05%20-%20OS%20(linux)%20%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/vi-vim/readme.md)
+
+/查询内容 回车
+
+n 下一个搜到的值
+
+# cat
+cat xxx.log |grep '查询值' -A 1
+
+-A 后边
+-B 前边
+-C 前后
+
+# tail
+tail 命令
+
+
+# less
+less -N catalina.out
+
+/keyword　　向下查找
+n    向下匹配下一处匹配文本
+N    向上匹配下一处匹配文本
+
+?keyword　　向上查找
+n    向上匹配下一处匹配文本
+N    向下匹配下一处匹配文本
+
+F    　　　　实时滚动文档
+Ctrl + c　　退出实时滚动模式
+
+类似效果：
+tail -f catalina.out
diff --git "a/05 - OS (linux)/\345\270\270\347\224\250\345\237\272\347\241\200\345\221\275\344\273\244.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\345\270\270\347\224\250\345\237\272\347\241\200\345\221\275\344\273\244.md"
similarity index 100%
rename from "05 - OS (linux)/\345\270\270\347\224\250\345\237\272\347\241\200\345\221\275\344\273\244.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\345\270\270\347\224\250\345\237\272\347\241\200\345\221\275\344\273\244.md"
diff --git "a/05 - OS (linux)/\346\220\234\347\264\242\346\226\207\344\273\266.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\220\234\347\264\242\346\226\207\344\273\266.md"
similarity index 100%
rename from "05 - OS (linux)/\346\220\234\347\264\242\346\226\207\344\273\266.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\220\234\347\264\242\346\226\207\344\273\266.md"
diff --git "a/05 - OS (linux)/\346\226\207\344\273\266\346\223\215\344\275\234 touch\343\200\201cp\343\200\201 In\343\200\201mv\343\200\201rm.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\226\207\344\273\266\346\223\215\344\275\234 touch\343\200\201cp\343\200\201 In\343\200\201mv\343\200\201rm.md"
similarity index 100%
rename from "05 - OS (linux)/\346\226\207\344\273\266\346\223\215\344\275\234 touch\343\200\201cp\343\200\201 In\343\200\201mv\343\200\201rm.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\226\207\344\273\266\346\223\215\344\275\234 touch\343\200\201cp\343\200\201 In\343\200\201mv\343\200\201rm.md"
diff --git "a/05 - OS (linux)/\346\226\207\346\234\254 \346\223\215\344\275\234 grep\343\200\201sed \344\273\245\345\217\212 awk \345\221\275\344\273\244.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\226\207\346\234\254 \346\223\215\344\275\234 grep\343\200\201sed \344\273\245\345\217\212 awk \345\221\275\344\273\244.md"
similarity index 100%
rename from "05 - OS (linux)/\346\226\207\346\234\254 \346\223\215\344\275\234 grep\343\200\201sed \344\273\245\345\217\212 awk \345\221\275\344\273\244.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\226\207\346\234\254 \346\223\215\344\275\234 grep\343\200\201sed \344\273\245\345\217\212 awk \345\221\275\344\273\244.md"
diff --git "a/05 - OS (linux)/\346\227\266\351\227\264.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\227\266\351\227\264.md"
similarity index 95%
rename from "05 - OS (linux)/\346\227\266\351\227\264.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\227\266\351\227\264.md"
index 5b0742fe..4b2853ce 100644
--- "a/05 - OS (linux)/\346\227\266\351\227\264.md"	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\227\266\351\227\264.md"	
@@ -1,46 +1,46 @@
-一、查看和修改Linux的时区
-
-1. 查看当前时区
-命令 ： "date -R"
-
-2. 修改设置Linux服务器时区
-方法 A
-命令 ： "tzselect"
-
-方法 B 仅限于RedHat Linux 和 CentOS
-命令 ： "timeconfig"
-
-方法 C 适用于Debian
-命令 ： "dpkg-reconfigure tzdata"
-
-3. 复制相应的时区文件，替换系统时区文件；或者创建链接文件
-cp /usr/share/zoneinfo/$主时区/$次时区 /etc/localtime
-
-例如：在设置中国时区使用亚洲/上海（+8）
-
-cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
-
-二、查看和修改Linux的时间
-
-1. 查看时间和日期
-命令 ： "date"
-
-2.设置时间和日期
-例如：将系统日期设定成2009年11月3日的命令
-
-命令 ： "date -s 11/03/2009"
-
-将系统时间设定成下午5点55分55秒的命令
-
-命令 ： "date -s 17:55:55"
-
-3. 将当前时间和日期写入BIOS，避免重启后失效
-命令 ： "hwclock -w"
-
-注：
-
-date
-不加参数可以直接看到当前日期时间
-
-cal
-不加参数可以直接看到本月月历
+一、查看和修改Linux的时区
+
+1. 查看当前时区
+命令 ： "date -R"
+
+2. 修改设置Linux服务器时区
+方法 A
+命令 ： "tzselect"
+
+方法 B 仅限于RedHat Linux 和 CentOS
+命令 ： "timeconfig"
+
+方法 C 适用于Debian
+命令 ： "dpkg-reconfigure tzdata"
+
+3. 复制相应的时区文件，替换系统时区文件；或者创建链接文件
+cp /usr/share/zoneinfo/$主时区/$次时区 /etc/localtime
+
+例如：在设置中国时区使用亚洲/上海（+8）
+
+cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
+
+二、查看和修改Linux的时间
+
+1. 查看时间和日期
+命令 ： "date"
+
+2.设置时间和日期
+例如：将系统日期设定成2009年11月3日的命令
+
+命令 ： "date -s 11/03/2009"
+
+将系统时间设定成下午5点55分55秒的命令
+
+命令 ： "date -s 17:55:55"
+
+3. 将当前时间和日期写入BIOS，避免重启后失效
+命令 ： "hwclock -w"
+
+注：
+
+date
+不加参数可以直接看到当前日期时间
+
+cal
+不加参数可以直接看到本月月历
diff --git "a/05 - OS (linux)/\346\230\276\347\244\272/linux\345\221\275\344\273\244\350\241\214\351\242\234\350\211\262.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\230\276\347\244\272/linux\345\221\275\344\273\244\350\241\214\351\242\234\350\211\262.md"
similarity index 100%
rename from "05 - OS (linux)/\346\230\276\347\244\272/linux\345\221\275\344\273\244\350\241\214\351\242\234\350\211\262.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\230\276\347\244\272/linux\345\221\275\344\273\244\350\241\214\351\242\234\350\211\262.md"
diff --git "a/05 - OS (linux)/\346\230\276\347\244\272/zsh oh my zsh.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\230\276\347\244\272/zsh oh my zsh.md"
similarity index 100%
rename from "05 - OS (linux)/\346\230\276\347\244\272/zsh oh my zsh.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\230\276\347\244\272/zsh oh my zsh.md"
diff --git "a/05 - OS (linux)/\346\230\276\347\244\272/\346\230\276\347\244\272\345\275\251\350\211\262\347\233\256\345\275\225\345\210\227\350\241\250.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\230\276\347\244\272/\346\230\276\347\244\272\345\275\251\350\211\262\347\233\256\345\275\225\345\210\227\350\241\250.md"
similarity index 100%
rename from "05 - OS (linux)/\346\230\276\347\244\272/\346\230\276\347\244\272\345\275\251\350\211\262\347\233\256\345\275\225\345\210\227\350\241\250.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\346\230\276\347\244\272/\346\230\276\347\244\272\345\275\251\350\211\262\347\233\256\345\275\225\345\210\227\350\241\250.md"
diff --git "a/05 - OS (linux)/\347\216\257\345\242\203 - java jdk tomcat.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - java jdk tomcat.md"
similarity index 100%
rename from "05 - OS (linux)/\347\216\257\345\242\203 - java jdk tomcat.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - java jdk tomcat.md"
diff --git "a/05 - OS (linux)/\347\216\257\345\242\203 - mysql.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - mysql.md"
similarity index 100%
rename from "05 - OS (linux)/\347\216\257\345\242\203 - mysql.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - mysql.md"
diff --git "a/05 - OS (linux)/\347\216\257\345\242\203 - \346\267\273\345\212\240mysql\350\207\252\345\220\257\345\212\250.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - \346\267\273\345\212\240mysql\350\207\252\345\220\257\345\212\250.md"
similarity index 100%
rename from "05 - OS (linux)/\347\216\257\345\242\203 - \346\267\273\345\212\240mysql\350\207\252\345\220\257\345\212\250.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - \346\267\273\345\212\240mysql\350\207\252\345\220\257\345\212\250.md"
diff --git "a/05 - OS (linux)/\347\216\257\345\242\203 - \346\267\273\345\212\240redis\351\205\215\347\275\256\350\207\252\345\220\257\345\212\250.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - \346\267\273\345\212\240redis\351\205\215\347\275\256\350\207\252\345\220\257\345\212\250.md"
similarity index 100%
rename from "05 - OS (linux)/\347\216\257\345\242\203 - \346\267\273\345\212\240redis\351\205\215\347\275\256\350\207\252\345\220\257\345\212\250.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - \346\267\273\345\212\240redis\351\205\215\347\275\256\350\207\252\345\220\257\345\212\250.md"
diff --git "a/05 - OS (linux)/\347\216\257\345\242\203 - \346\267\273\345\212\240tomcat\344\270\272\346\234\215\345\212\241 \345\274\200\345\220\257\350\207\252\345\212\250\345\220\257\345\212\250.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - \346\267\273\345\212\240tomcat\344\270\272\346\234\215\345\212\241 \345\274\200\345\220\257\350\207\252\345\212\250\345\220\257\345\212\250.md"
similarity index 100%
rename from "05 - OS (linux)/\347\216\257\345\242\203 - \346\267\273\345\212\240tomcat\344\270\272\346\234\215\345\212\241 \345\274\200\345\220\257\350\207\252\345\212\250\345\220\257\345\212\250.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\216\257\345\242\203 - \346\267\273\345\212\240tomcat\344\270\272\346\234\215\345\212\241 \345\274\200\345\220\257\350\207\252\345\212\250\345\220\257\345\212\250.md"
diff --git "a/05 - OS (linux)/\347\233\221\346\265\213\347\250\213\345\272\217\345\221\275\344\273\244\357\274\232ps\343\200\201top.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\233\221\346\265\213\347\250\213\345\272\217\345\221\275\344\273\244\357\274\232ps\343\200\201top.md"
similarity index 100%
rename from "05 - OS (linux)/\347\233\221\346\265\213\347\250\213\345\272\217\345\221\275\344\273\244\357\274\232ps\343\200\201top.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\233\221\346\265\213\347\250\213\345\272\217\345\221\275\344\273\244\357\274\232ps\343\200\201top.md"
diff --git "a/05 - OS (linux)/\347\233\256\345\275\225\347\273\223\346\236\204.jpg" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\233\256\345\275\225\347\273\223\346\236\204.jpg"
similarity index 100%
rename from "05 - OS (linux)/\347\233\256\345\275\225\347\273\223\346\236\204.jpg"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\233\256\345\275\225\347\273\223\346\236\204.jpg"
diff --git "a/05 - OS (linux)/\347\243\201\347\233\230.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\243\201\347\233\230.md"
similarity index 98%
rename from "05 - OS (linux)/\347\243\201\347\233\230.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\243\201\347\233\230.md"
index 93c8e6ed..c5625e54 100644
--- "a/05 - OS (linux)/\347\243\201\347\233\230.md"	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\243\201\347\233\230.md"	
@@ -1,106 +1,106 @@
-挂载：
-linux下面所有的文件、目录、设备都有一个路径，这个路径永远以/开头，用/分隔，如果一个路径是另一个路径的前缀，则这两个路径有逻辑上的父子关系。
-但是并不是所有逻辑上的父子关系都必须要是同一个设备，决定不同路径对应到哪个设备的机制就叫做 **mount（挂载）**。
-通过mount，可以设置当前的路径与设备的对应关系。每个设备会设置一个挂载点，挂载点是一个空目录。一般来说必须有一个设备挂载在/这个根路径下面，叫做rootfs。
-其他挂载点可以是/tmp，/boot，/dev等等，通过在rootfs上面创建一个空目录然后用mount命令就可以将设备挂载到这个目录上。
-挂载之后，这个目录下的子路径，就会映射到被挂载的设备里面。当访问一个路径时，会选择一个能最大匹配当前路径前缀的挂载点。
-比如说，有/var的挂载点，也有/var/run的挂载点的情况下，访问/var/run/test.pid，就会匹配到/var/run挂载点设备下面的/test.pid。
-同一个设备可以有多个挂载点，同一个挂载点同时只能加载一个设备。
-访问非挂载点的路径的时候，按照前面所说，其实是访问最接近的一个挂载点，如果没有其他挂载点那么就是rootfs上的目录或者文件了。
-实际上并不只有linux支持挂载点，Windows也是一样支持的。
-去控制面板/管理工具/计算机管理 里面，挑一个磁盘（比如D盘），然后给它分一个新的挂载点试试，比如C:\data
-
-
-查看linux 系统服务器上的 磁盘 情况 fdisk -l
-
- linux centos 磁盘分区命令    
- 倘若我们挂载  /dev/xvdc1    10G 磁盘，
- 那么我们可以先格式化分区   
- 输入  fdisk /dev/xvdc1  
- 依次输入:   n    p    1   二次回车   w   即可。
-Command (m for help):**n**  
-Command action  
-　　   e    extended                  //输入e为创建扩展分区  
-　　   p    primary partition (1-4)      //输入p为创建逻辑分区  
-**p**  
-Partion number(1-4)：**1**      //在这里输入l，就进入划分逻辑分区阶段了；  
-First cylinder (51-125, default 51):   //注：这个就是分区的Start 值；这里最好直接按回车，如果您输入了一个非默认的数字，会造成空间浪费；  
-Using default value 51  
-Last cylinder or +size or +sizeM or +sizeK (51-125, default 125): +200M 注：这个是定义分区大小的，+200M 就是大小为200M ；当然您也可以根据p提示的单位cylinder的大小来算，然后来指定 End的数值。回头看看是怎么算的；还是用+200M这个办法来添加，这样能直观一点。如果您想添加一个10G左右大小的分区，请输入 +10000M ；  
-
-Command (m for help): **w**                     //最后输入w回车保存。
-
-
- linux centos **格式化磁盘命令**   #mkfs.ext4 /dev/xvdc1
-
- linux centos **挂载磁盘命令**  **#mount** /dev/xvdc1 /mydisk   意思是将服务器上  /dev/xvdc1绑定到   你所创建的目录  mydisk文件目录上。
-
- linux centos **配置挂载开机启动 ,关键步骤**
- echo "/dev/sdb1              /data                  ext4    defaults        0 0" >> /etc/fstab
-该命令及其重要，因为挂载磁盘操作挂载成功后，重启服务器后会丢失挂载，以至于挂载失效，即要写入开启挂载启动项。
-该命令中，ext4 是  对应  你的格式化磁盘的  类型格式，如  我这边的磁盘  格式化时  用了   ext4  格式进行格式。
-
-**df(disk free)**
-功能说明:显示磁盘的相关信息。
-语 法:df [-ahHiklmPT][--block-size=<区块大小>][-t <文件系统类型>][-x <文件系统类型>][--help][--no-sync][--sync][--version][文件或设备]
-补充说明:df可显示磁盘的文件系统与使用情形。
-
-参 数:
--a或--all 包含全部的文件系统。
---block-size=<区块大小> 以指定的区块大小来显示区块数目。
--h或--human-readable 以可读性较高的方式来显示信息。
--H或--si 与-h参数相同,但在计算时是以1000 Bytes为换算单位而非1024 Bytes。
--i或--inodes 显示inode的信息。
--k或--kilobytes 指定区块大小为1024字节。
--l或--local 仅显示本地端的文件系统。
--m或--megabytes 指定区块大小为1048576字节。
---no-sync 在取得磁盘使用信息前,不要执行sync指令,此为预设值。
--P或--portability 使用POSIX的输出格式。
---sync 在取得磁盘使用信息前,先执行sync指令。
--t<文件系统类型>或--type=<文件系统类型> 仅显示指定文件系统类型的磁盘信息。
--T或--print-type 显示文件系统的类型。
--x<文件系统类型>或--exclude-type=<文件系统类型> 不要显示指定文件系统类型的磁盘信息。
---help 显示帮助。
---version 显示版本信息。
-[文件或设备] 指定磁盘设备。  
-
-**fdisk**
-用法：
- fdisk [选项] <磁盘>    更改分区表
- fdisk [选项] -l <磁盘> 列出分区表
- fdisk -s <分区>        给出分区大小(块数)
-
-选项：
- -b <大小>             扇区大小(512、1024、2048或4096)
- -c[=<模式>]           兼容模式：“dos”或“nondos”(默认)
- -h                    打印此帮助文本
- -u[=<单位>]           显示单位：“cylinders”(柱面)或“sectors”(扇区，默认)
- -v                    打印程序版本
- -C <数字>             指定柱面数
- -H <数字>             指定磁头数
- -S <数字>             指定每个磁道的扇区数
-
- **du(disk usage)**
- 功能说明:显示目录或文件的大小。
- 语 法:du [-abcDhHklmsSx][-L <符号连接>][-X <文件>][--block-size][--exclude=<目录或文件>][--max-depth=<目录层数>][--help][--version][目录或文件]
- 补充说明:du会显示指定的目录或文件所占用的磁盘空间。
-
- 参 数:
- -a或-all 显示目录中个别文件的大小。
- -b或-bytes 显示目录或文件大小时,以byte为单位。
- -c或--total 除了显示个别目录或文件的大小外,同时也显示所有目录或文件的总和。
- -D或--dereference-args 显示指定符号连接的源文件大小。
- -h或--human-readable 以K,M,G为单位,提高信息的可读性。
- -H或--si 与-h参数相同,但是K,M,G是以1000为换算单位。
- -k或--kilobytes 以1024 bytes为单位。
- -l或--count-links 重复计算硬件连接的文件。
- -L<符号连接>或--dereference<符号连接> 显示选项中所指定符号连接的源文件大小。
- -m或--megabytes 以1MB为单位。
- -s或--summarize 仅显示总计。
- -S或--separate-dirs 显示个别目录的大小时,并不含其子目录的大小。
- -x或--one-file-xystem 以一开始处理时的文件系统为准,若遇上其它不同的文件系统目录则略过。
- -X<文件>或--exclude-from=<文件> 在<文件>指定目录或文件。
- --exclude=<目录或文件> 略过指定的目录或文件。
- --max-depth=<目录层数> 超过指定层数的目录后,予以忽略。
- --help 显示帮助。
- --version 显示版本信息。    
+挂载：
+linux下面所有的文件、目录、设备都有一个路径，这个路径永远以/开头，用/分隔，如果一个路径是另一个路径的前缀，则这两个路径有逻辑上的父子关系。
+但是并不是所有逻辑上的父子关系都必须要是同一个设备，决定不同路径对应到哪个设备的机制就叫做 **mount（挂载）**。
+通过mount，可以设置当前的路径与设备的对应关系。每个设备会设置一个挂载点，挂载点是一个空目录。一般来说必须有一个设备挂载在/这个根路径下面，叫做rootfs。
+其他挂载点可以是/tmp，/boot，/dev等等，通过在rootfs上面创建一个空目录然后用mount命令就可以将设备挂载到这个目录上。
+挂载之后，这个目录下的子路径，就会映射到被挂载的设备里面。当访问一个路径时，会选择一个能最大匹配当前路径前缀的挂载点。
+比如说，有/var的挂载点，也有/var/run的挂载点的情况下，访问/var/run/test.pid，就会匹配到/var/run挂载点设备下面的/test.pid。
+同一个设备可以有多个挂载点，同一个挂载点同时只能加载一个设备。
+访问非挂载点的路径的时候，按照前面所说，其实是访问最接近的一个挂载点，如果没有其他挂载点那么就是rootfs上的目录或者文件了。
+实际上并不只有linux支持挂载点，Windows也是一样支持的。
+去控制面板/管理工具/计算机管理 里面，挑一个磁盘（比如D盘），然后给它分一个新的挂载点试试，比如C:\data
+
+
+查看linux 系统服务器上的 磁盘 情况 fdisk -l
+
+ linux centos 磁盘分区命令    
+ 倘若我们挂载  /dev/xvdc1    10G 磁盘，
+ 那么我们可以先格式化分区   
+ 输入  fdisk /dev/xvdc1  
+ 依次输入:   n    p    1   二次回车   w   即可。
+Command (m for help):**n**  
+Command action  
+　　   e    extended                  //输入e为创建扩展分区  
+　　   p    primary partition (1-4)      //输入p为创建逻辑分区  
+**p**  
+Partion number(1-4)：**1**      //在这里输入l，就进入划分逻辑分区阶段了；  
+First cylinder (51-125, default 51):   //注：这个就是分区的Start 值；这里最好直接按回车，如果您输入了一个非默认的数字，会造成空间浪费；  
+Using default value 51  
+Last cylinder or +size or +sizeM or +sizeK (51-125, default 125): +200M 注：这个是定义分区大小的，+200M 就是大小为200M ；当然您也可以根据p提示的单位cylinder的大小来算，然后来指定 End的数值。回头看看是怎么算的；还是用+200M这个办法来添加，这样能直观一点。如果您想添加一个10G左右大小的分区，请输入 +10000M ；  
+
+Command (m for help): **w**                     //最后输入w回车保存。
+
+
+ linux centos **格式化磁盘命令**   #mkfs.ext4 /dev/xvdc1
+
+ linux centos **挂载磁盘命令**  **#mount** /dev/xvdc1 /mydisk   意思是将服务器上  /dev/xvdc1绑定到   你所创建的目录  mydisk文件目录上。
+
+ linux centos **配置挂载开机启动 ,关键步骤**
+ echo "/dev/sdb1              /data                  ext4    defaults        0 0" >> /etc/fstab
+该命令及其重要，因为挂载磁盘操作挂载成功后，重启服务器后会丢失挂载，以至于挂载失效，即要写入开启挂载启动项。
+该命令中，ext4 是  对应  你的格式化磁盘的  类型格式，如  我这边的磁盘  格式化时  用了   ext4  格式进行格式。
+
+**df(disk free)**
+功能说明:显示磁盘的相关信息。
+语 法:df [-ahHiklmPT][--block-size=<区块大小>][-t <文件系统类型>][-x <文件系统类型>][--help][--no-sync][--sync][--version][文件或设备]
+补充说明:df可显示磁盘的文件系统与使用情形。
+
+参 数:
+-a或--all 包含全部的文件系统。
+--block-size=<区块大小> 以指定的区块大小来显示区块数目。
+-h或--human-readable 以可读性较高的方式来显示信息。
+-H或--si 与-h参数相同,但在计算时是以1000 Bytes为换算单位而非1024 Bytes。
+-i或--inodes 显示inode的信息。
+-k或--kilobytes 指定区块大小为1024字节。
+-l或--local 仅显示本地端的文件系统。
+-m或--megabytes 指定区块大小为1048576字节。
+--no-sync 在取得磁盘使用信息前,不要执行sync指令,此为预设值。
+-P或--portability 使用POSIX的输出格式。
+--sync 在取得磁盘使用信息前,先执行sync指令。
+-t<文件系统类型>或--type=<文件系统类型> 仅显示指定文件系统类型的磁盘信息。
+-T或--print-type 显示文件系统的类型。
+-x<文件系统类型>或--exclude-type=<文件系统类型> 不要显示指定文件系统类型的磁盘信息。
+--help 显示帮助。
+--version 显示版本信息。
+[文件或设备] 指定磁盘设备。  
+
+**fdisk**
+用法：
+ fdisk [选项] <磁盘>    更改分区表
+ fdisk [选项] -l <磁盘> 列出分区表
+ fdisk -s <分区>        给出分区大小(块数)
+
+选项：
+ -b <大小>             扇区大小(512、1024、2048或4096)
+ -c[=<模式>]           兼容模式：“dos”或“nondos”(默认)
+ -h                    打印此帮助文本
+ -u[=<单位>]           显示单位：“cylinders”(柱面)或“sectors”(扇区，默认)
+ -v                    打印程序版本
+ -C <数字>             指定柱面数
+ -H <数字>             指定磁头数
+ -S <数字>             指定每个磁道的扇区数
+
+ **du(disk usage)**
+ 功能说明:显示目录或文件的大小。
+ 语 法:du [-abcDhHklmsSx][-L <符号连接>][-X <文件>][--block-size][--exclude=<目录或文件>][--max-depth=<目录层数>][--help][--version][目录或文件]
+ 补充说明:du会显示指定的目录或文件所占用的磁盘空间。
+
+ 参 数:
+ -a或-all 显示目录中个别文件的大小。
+ -b或-bytes 显示目录或文件大小时,以byte为单位。
+ -c或--total 除了显示个别目录或文件的大小外,同时也显示所有目录或文件的总和。
+ -D或--dereference-args 显示指定符号连接的源文件大小。
+ -h或--human-readable 以K,M,G为单位,提高信息的可读性。
+ -H或--si 与-h参数相同,但是K,M,G是以1000为换算单位。
+ -k或--kilobytes 以1024 bytes为单位。
+ -l或--count-links 重复计算硬件连接的文件。
+ -L<符号连接>或--dereference<符号连接> 显示选项中所指定符号连接的源文件大小。
+ -m或--megabytes 以1MB为单位。
+ -s或--summarize 仅显示总计。
+ -S或--separate-dirs 显示个别目录的大小时,并不含其子目录的大小。
+ -x或--one-file-xystem 以一开始处理时的文件系统为准,若遇上其它不同的文件系统目录则略过。
+ -X<文件>或--exclude-from=<文件> 在<文件>指定目录或文件。
+ --exclude=<目录或文件> 略过指定的目录或文件。
+ --max-depth=<目录层数> 超过指定层数的目录后,予以忽略。
+ --help 显示帮助。
+ --version 显示版本信息。    
diff --git "a/05 - OS (linux)/\347\256\241\351\201\223.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\256\241\351\201\223.md"
similarity index 100%
rename from "05 - OS (linux)/\347\256\241\351\201\223.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\347\256\241\351\201\223.md"
diff --git "a/05 - OS (linux)/\350\267\257\347\224\261.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\350\267\257\347\224\261.md"
similarity index 100%
rename from "05 - OS (linux)/\350\267\257\347\224\261.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\350\267\257\347\224\261.md"
diff --git "a/05 - OS (linux)/\351\205\215\347\275\256.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\205\215\347\275\256.md"
similarity index 96%
rename from "05 - OS (linux)/\351\205\215\347\275\256.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\205\215\347\275\256.md"
index fd229d06..1577807f 100644
--- "a/05 - OS (linux)/\351\205\215\347\275\256.md"	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\205\215\347\275\256.md"	
@@ -1,37 +1,37 @@
-cat /proc/cpuinfo 查看CPU信息
-
-free -m 查看内存使用量和交换区使用量
-
-df -h 查看各分区使用情况
-du -sh 查看指定目录的大小
-
-fdisk -l 查看所有分区
-
-uptime  查看系统运行时间、用户数、负载 
-
-cat /proc/loadavg  查看系统负载 磁盘和分区
-
-netstat -lntp 查看所有监听端口
-
-ps -ef 查看所有进程
-
-iptables -L 查看防火墙设置
-
-grep MemTotal /proc/meminfo 查看内存总量
-
-grep MemFree /proc/meminfo  查看空闲内存量
-
-Ismod 列出加载的内核模块
-
-cat /proc/loadavg # 查看系统负载磁盘和分区
-mount | column -t # 查看挂接的分区状态
-swapon -s # 查看所有交换分区
-hdparm -i /dev/hda # 查看磁盘参数(仅适用于IDE设备)
-dmesg | grep IDE # 查看启动时IDE设备检测状况网络
-ifconfig # 查看所有网络接口的属性
-cut -d: -f1 /etc/passwd # 查看系统所有用户
-cut -d: -f1 /etc/group # 查看系统所有组
-crontab -l # 查看当前用户的计划任务 服务
-chkconfig –list # 列出所有系统服务
-chkconfig –list | grep on # 列出所有启动的系统服务 程序
-rpm -qa # 查看所有安装的软件包
+cat /proc/cpuinfo 查看CPU信息
+
+free -m 查看内存使用量和交换区使用量
+
+df -h 查看各分区使用情况
+du -sh 查看指定目录的大小
+
+fdisk -l 查看所有分区
+
+uptime  查看系统运行时间、用户数、负载 
+
+cat /proc/loadavg  查看系统负载 磁盘和分区
+
+netstat -lntp 查看所有监听端口
+
+ps -ef 查看所有进程
+
+iptables -L 查看防火墙设置
+
+grep MemTotal /proc/meminfo 查看内存总量
+
+grep MemFree /proc/meminfo  查看空闲内存量
+
+Ismod 列出加载的内核模块
+
+cat /proc/loadavg # 查看系统负载磁盘和分区
+mount | column -t # 查看挂接的分区状态
+swapon -s # 查看所有交换分区
+hdparm -i /dev/hda # 查看磁盘参数(仅适用于IDE设备)
+dmesg | grep IDE # 查看启动时IDE设备检测状况网络
+ifconfig # 查看所有网络接口的属性
+cut -d: -f1 /etc/passwd # 查看系统所有用户
+cut -d: -f1 /etc/group # 查看系统所有组
+crontab -l # 查看当前用户的计划任务 服务
+chkconfig –list # 列出所有系统服务
+chkconfig –list | grep on # 列出所有启动的系统服务 程序
+rpm -qa # 查看所有安装的软件包
diff --git "a/05 - OS (linux)/\351\205\215\347\275\256\347\275\221\345\205\263.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\205\215\347\275\256\347\275\221\345\205\263.md"
similarity index 100%
rename from "05 - OS (linux)/\351\205\215\347\275\256\347\275\221\345\205\263.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\205\215\347\275\256\347\275\221\345\205\263.md"
diff --git "a/05 - OS (linux)/\351\230\262\347\201\253\345\242\231.md" "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\230\262\347\201\253\345\242\231.md"
similarity index 96%
rename from "05 - OS (linux)/\351\230\262\347\201\253\345\242\231.md"
rename to "05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\230\262\347\201\253\345\242\231.md"
index 061bc5f5..874d8edd 100644
--- "a/05 - OS (linux)/\351\230\262\347\201\253\345\242\231.md"	
+++ "b/05 - OS (linux) \346\223\215\344\275\234\347\263\273\347\273\237/\351\230\262\347\201\253\345\242\231.md"	
@@ -1,18 +1,18 @@
-防火墙原因
-1. 打开防火墙配置文件
-vi  /etc/sysconfig/iptables
-2. 增加下面一行
--A INPUT -m state --state NEW -m tcp -p tcp --dport **** -j ACCEPT
-3. 重启防火墙
-service  iptables restart
-
-1、安装iptable iptable-service
-
-#先检查是否安装了iptables
-service iptables status
-#安装iptables
-yum install -y iptables
-#升级iptables（安装的最新版本则不需要）
-yum update iptables
-#安装iptables-services
-yum install iptables-services
+防火墙原因
+1. 打开防火墙配置文件
+vi  /etc/sysconfig/iptables
+2. 增加下面一行
+-A INPUT -m state --state NEW -m tcp -p tcp --dport **** -j ACCEPT
+3. 重启防火墙
+service  iptables restart
+
+1、安装iptable iptable-service
+
+#先检查是否安装了iptables
+service iptables status
+#安装iptables
+yum install -y iptables
+#升级iptables（安装的最新版本则不需要）
+yum update iptables
+#安装iptables-services
+yum install iptables-services
diff --git a/06 - DB (mysql)/HBase/wiki.md "b/06 - DB \346\225\260\346\215\256\345\272\223/HBase/wiki.md"
similarity index 99%
rename from 06 - DB (mysql)/HBase/wiki.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/HBase/wiki.md"
index b968eef6..337bc81e 100644
--- a/06 - DB (mysql)/HBase/wiki.md	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/HBase/wiki.md"	
@@ -1,5 +1,5 @@
-HBase是一个 **分布式的、面向列** 的开源数据库，该技术来源于 Fay Chang 所撰写的Google论文“Bigtable：一个结构化数据的分布式存储系统”。
-就像Bigtable利用了Google文件系统（File System）所提供的分布式数据存储一样，HBase在Hadoop之上提供了类似于Bigtable的能力。
-HBase是Apache的Hadoop项目的子项目。
-HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。
-另一个不同的是HBase基于列的而不是基于行的模式。
+HBase是一个 **分布式的、面向列** 的开源数据库，该技术来源于 Fay Chang 所撰写的Google论文“Bigtable：一个结构化数据的分布式存储系统”。
+就像Bigtable利用了Google文件系统（File System）所提供的分布式数据存储一样，HBase在Hadoop之上提供了类似于Bigtable的能力。
+HBase是Apache的Hadoop项目的子项目。
+HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。
+另一个不同的是HBase基于列的而不是基于行的模式。
diff --git "a/06 - DB (mysql)/MongoDB/MongoDB\344\275\277\347\224\250\345\234\272\346\231\257.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/MongoDB/MongoDB\344\275\277\347\224\250\345\234\272\346\231\257.md"
similarity index 98%
rename from "06 - DB (mysql)/MongoDB/MongoDB\344\275\277\347\224\250\345\234\272\346\231\257.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/MongoDB/MongoDB\344\275\277\347\224\250\345\234\272\346\231\257.md"
index 487d025d..911c8ded 100644
--- "a/06 - DB (mysql)/MongoDB/MongoDB\344\275\277\347\224\250\345\234\272\346\231\257.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/MongoDB/MongoDB\344\275\277\347\224\250\345\234\272\346\231\257.md"	
@@ -1,45 +1,45 @@
-http://www.mongoing.com/archives/3609
-什么场景应该用MongoDB ？
-
-案例1
-> 1. 用在应用服务器的 **日志记录**，查找起来比文本灵活，导出也很方便。也是给应用练手，从外围系统开始使用MongoDB。
-> 2. 用在一些第三方信息的获取或者抓取，因为MongoDB的schema-less，所有格式灵活，不用为了各种格式不一样的信息专门设计统一的格式，极大得减少开发的工作。
-
-案例2
-> mongodb之前有用过，主要用来存储一些监控数据，No schema 对开发人员来说，真的很方便，**增加字段不用改表结构**，而且学习成本极低。
-
-案例3
-> 使用MongoDB做了O2O快递应用，·将送快递骑手、快递商家的信息（包含位置信息）存储在 MongoDB，然后通过 MongoDB 的地理位置查询，这样很方便的实现了查找附近的商家、骑手等功能，使得快递骑手能就近接单，目前在使用MongoDB 上没遇到啥大的问题，官网的文档比较详细，很给力。
-
-使用 MongoDB 通常能让你以更低的成本解决问题（包括学习、开发、运维等成本）
-
-下面是 MongoDB 的主要特性，大家可以对照自己的业务需求看看，匹配的越多，用 MongoDB 就越合适。
-
-MONGODB特性	                  优势
-`事务支持`	                   MongoDB 目前只支持单`文档事务`，需要复杂事务支持的场景暂时不适合
-`灵活的文档模型`	              `JSON `格式存储最接近真实对象模型，对开发者友好，方便快速开发迭代
-`高可用复制集`                 满足数据高可靠、服务高可用的需求，运维简单，故障自动切换
-`可扩展分片集群`	              海量数据存储，服务能力水平扩展
-`高性能`         	            mmapv1、wiredtiger、mongorocks（rocksdb）、in-memory 等多引擎支持满足各种场景需求
-`强大的索引支持`	              地理位置索引可用于构建 各种 O2O 应用、文本索引解决搜索的需求、TTL索引解决历史数据自动过期的需求
-`Gridfs`	                    解决文件存储的需求
-`aggregation & mapreduce`	    解决数据分析场景需求，用户可以自己写查询语句或脚本，将请求都分发到 MongoDB 上完成
-
-### 实际的应用案例
-`游戏场景`，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、更新
-`物流场景`，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。
-`社交场景`，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能
-`物联网场景`，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析
-`视频直播`，使用 MongoDB 存储用户信息、礼物信息等
-
-### 选择题来辅助决策
-
-应用特征	                                           YES / NO
-应用不需要事务及复杂 join 支持	                       必须 Yes
-新应用，需求会变，数据模型无法确定，想快速迭代开发	        ？
-应用需要2000-3000以上的读写QPS（更高也可以）	           ？
-应用需要TB甚至 PB 级别数据存储	                         ?
-应用发展迅速，需要能快速水平扩展	                        ?
-应用要求存储的数据不丢失	                               ?
-应用需要99.999%高可用	                                 ?
-应用需要大量的地理位置查询、文本查询	                    ？
+http://www.mongoing.com/archives/3609
+什么场景应该用MongoDB ？
+
+案例1
+> 1. 用在应用服务器的 **日志记录**，查找起来比文本灵活，导出也很方便。也是给应用练手，从外围系统开始使用MongoDB。
+> 2. 用在一些第三方信息的获取或者抓取，因为MongoDB的schema-less，所有格式灵活，不用为了各种格式不一样的信息专门设计统一的格式，极大得减少开发的工作。
+
+案例2
+> mongodb之前有用过，主要用来存储一些监控数据，No schema 对开发人员来说，真的很方便，**增加字段不用改表结构**，而且学习成本极低。
+
+案例3
+> 使用MongoDB做了O2O快递应用，·将送快递骑手、快递商家的信息（包含位置信息）存储在 MongoDB，然后通过 MongoDB 的地理位置查询，这样很方便的实现了查找附近的商家、骑手等功能，使得快递骑手能就近接单，目前在使用MongoDB 上没遇到啥大的问题，官网的文档比较详细，很给力。
+
+使用 MongoDB 通常能让你以更低的成本解决问题（包括学习、开发、运维等成本）
+
+下面是 MongoDB 的主要特性，大家可以对照自己的业务需求看看，匹配的越多，用 MongoDB 就越合适。
+
+MONGODB特性	                  优势
+`事务支持`	                   MongoDB 目前只支持单`文档事务`，需要复杂事务支持的场景暂时不适合
+`灵活的文档模型`	              `JSON `格式存储最接近真实对象模型，对开发者友好，方便快速开发迭代
+`高可用复制集`                 满足数据高可靠、服务高可用的需求，运维简单，故障自动切换
+`可扩展分片集群`	              海量数据存储，服务能力水平扩展
+`高性能`         	            mmapv1、wiredtiger、mongorocks（rocksdb）、in-memory 等多引擎支持满足各种场景需求
+`强大的索引支持`	              地理位置索引可用于构建 各种 O2O 应用、文本索引解决搜索的需求、TTL索引解决历史数据自动过期的需求
+`Gridfs`	                    解决文件存储的需求
+`aggregation & mapreduce`	    解决数据分析场景需求，用户可以自己写查询语句或脚本，将请求都分发到 MongoDB 上完成
+
+### 实际的应用案例
+`游戏场景`，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、更新
+`物流场景`，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。
+`社交场景`，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能
+`物联网场景`，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析
+`视频直播`，使用 MongoDB 存储用户信息、礼物信息等
+
+### 选择题来辅助决策
+
+应用特征	                                           YES / NO
+应用不需要事务及复杂 join 支持	                       必须 Yes
+新应用，需求会变，数据模型无法确定，想快速迭代开发	        ？
+应用需要2000-3000以上的读写QPS（更高也可以）	           ？
+应用需要TB甚至 PB 级别数据存储	                         ?
+应用发展迅速，需要能快速水平扩展	                        ?
+应用要求存储的数据不丢失	                               ?
+应用需要99.999%高可用	                                 ?
+应用需要大量的地理位置查询、文本查询	                    ？
diff --git "a/06 - DB (mysql)/MongoDB/linux\345\256\211\350\243\205.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/MongoDB/linux\345\256\211\350\243\205.md"
similarity index 98%
rename from "06 - DB (mysql)/MongoDB/linux\345\256\211\350\243\205.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/MongoDB/linux\345\256\211\350\243\205.md"
index 68439735..e26aa5ee 100644
--- "a/06 - DB (mysql)/MongoDB/linux\345\256\211\350\243\205.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/MongoDB/linux\345\256\211\350\243\205.md"	
@@ -1,6 +1,6 @@
-curl -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.6.tgz    # 下载
-tar -zxvf mongodb-linux-x86_64-3.0.6.tgz                                   # 解压
-
-mv  mongodb-linux-x86_64-3.0.6/ /usr/local/mongodb                         # 将解压包拷贝到指定目录
-
-export PATH=<mongodb-install-directory>/bin:$PATH  <mongodb-install-directory> 为你 MongoDB 的安装路径。如本文的 /usr/local/mongodb 
+curl -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.6.tgz    # 下载
+tar -zxvf mongodb-linux-x86_64-3.0.6.tgz                                   # 解压
+
+mv  mongodb-linux-x86_64-3.0.6/ /usr/local/mongodb                         # 将解压包拷贝到指定目录
+
+export PATH=<mongodb-install-directory>/bin:$PATH  <mongodb-install-directory> 为你 MongoDB 的安装路径。如本文的 /usr/local/mongodb 
diff --git "a/06 - DB (mysql)/Mysql/MySQL\345\215\201\345\244\247\347\273\217\345\205\270\351\224\231\350\257\257\346\241\210\344\276\213\b.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/MySQL\345\215\201\345\244\247\347\273\217\345\205\270\351\224\231\350\257\257\346\241\210\344\276\213\b.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/MySQL\345\215\201\345\244\247\347\273\217\345\205\270\351\224\231\350\257\257\346\241\210\344\276\213\b.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/MySQL\345\215\201\345\244\247\347\273\217\345\205\270\351\224\231\350\257\257\346\241\210\344\276\213\b.md"
diff --git a/06 - DB (mysql)/Mysql/Mysql.md "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/Mysql.md"
similarity index 100%
rename from 06 - DB (mysql)/Mysql/Mysql.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/Mysql.md"
diff --git "a/06 - DB (mysql)/Mysql/SQL\346\237\245\350\257\242\344\274\230\345\214\22630\346\235\241\347\273\217\351\252\214.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/SQL\346\237\245\350\257\242\344\274\230\345\214\22630\346\235\241\347\273\217\351\252\214.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/SQL\346\237\245\350\257\242\344\274\230\345\214\22630\346\235\241\347\273\217\351\252\214.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/SQL\346\237\245\350\257\242\344\274\230\345\214\22630\346\235\241\347\273\217\351\252\214.md"
diff --git "a/06 - DB (mysql)/Mysql/Sql\346\211\247\350\241\214\350\256\241\345\210\222\350\257\246\350\247\243.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/Sql\346\211\247\350\241\214\350\256\241\345\210\222\350\257\246\350\247\243.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/Sql\346\211\247\350\241\214\350\256\241\345\210\222\350\257\246\350\247\243.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/Sql\346\211\247\350\241\214\350\256\241\345\210\222\350\257\246\350\247\243.md"
diff --git "a/06 - DB (mysql)/Mysql/WampServer \344\277\256\346\224\271mysql\345\257\206\347\240\201.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/WampServer \344\277\256\346\224\271mysql\345\257\206\347\240\201.txt"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/WampServer \344\277\256\346\224\271mysql\345\257\206\347\240\201.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/WampServer \344\277\256\346\224\271mysql\345\257\206\347\240\201.txt"
diff --git a/06 - DB (mysql)/Mysql/all.md "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/all.md"
similarity index 100%
rename from 06 - DB (mysql)/Mysql/all.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/all.md"
diff --git a/06 - DB (mysql)/Mysql/explain.md "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/explain.md"
similarity index 98%
rename from 06 - DB (mysql)/Mysql/explain.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/explain.md"
index bb5f35d0..be6ae9e9 100644
--- a/06 - DB (mysql)/Mysql/explain.md	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/explain.md"	
@@ -1,20 +1,20 @@
-explain select * from Task;
-+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
-| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra |
-+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
-|  1 | SIMPLE      | Task  | NULL       | ALL  | NULL          | NULL | NULL    | NULL |    5 |   100.00 | NULL  |
-+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
-1 row in set, 1 warning (0.00 sec)
-它的输出格式细节可以关注 MySQL explain format(http://dev.mysql.com/doc/refman/5.6/en/explain-output.html)，
-在输出中最要注意的是：
-
-1. type：ALL是效率最差，最要注意的
-
-2. key：是否有使用Key，key长度如何
-
-3. Extra：最好不要出现filesort以及temporary，最主要是要关注在orderby和groupby。
-
-
-SQL优化是个很复杂的过程，有可能出现拆东墙补西墙的情况：
-比如给数据库表加入了索引之后，确实查询快了，可是存储空间加多了，插入删除操作耗时也增加了，如果在一个写多读少的系统中，执行这种优化可能会起到反效果。
-所以优化完之后千万不能大意，要持续监控系统，防止出现引入新瓶颈的情况。
+explain select * from Task;
++----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
+| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra |
++----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
+|  1 | SIMPLE      | Task  | NULL       | ALL  | NULL          | NULL | NULL    | NULL |    5 |   100.00 | NULL  |
++----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
+1 row in set, 1 warning (0.00 sec)
+它的输出格式细节可以关注 MySQL explain format(http://dev.mysql.com/doc/refman/5.6/en/explain-output.html)，
+在输出中最要注意的是：
+
+1. type：ALL是效率最差，最要注意的
+
+2. key：是否有使用Key，key长度如何
+
+3. Extra：最好不要出现filesort以及temporary，最主要是要关注在orderby和groupby。
+
+
+SQL优化是个很复杂的过程，有可能出现拆东墙补西墙的情况：
+比如给数据库表加入了索引之后，确实查询快了，可是存储空间加多了，插入删除操作耗时也增加了，如果在一个写多读少的系统中，执行这种优化可能会起到反效果。
+所以优化完之后千万不能大意，要持续监控系统，防止出现引入新瓶颈的情况。
diff --git a/06 - DB (mysql)/Mysql/log.md "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/log.md"
similarity index 97%
rename from 06 - DB (mysql)/Mysql/log.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/log.md"
index ca2fca6d..3be15552 100644
--- a/06 - DB (mysql)/Mysql/log.md	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/log.md"	
@@ -1,50 +1,50 @@
-set global general_log=on;
-show global variables like "%genera%";
-
-
-查看MySQL慢日志参数
-show variables like '%slow_query%';
-+---------------------------+----------------------------------------+
-| Variable_name             | Value                                  |
-+---------------------------+----------------------------------------+
-| slow_query_log            | OFF                                    |
-| slow_query_log_file       | /usr/local/mysql/data/cloudlu-slow.log |
-+---------------------------+----------------------------------------+
-这里告诉我们慢日志的日志存放位置，慢日志是否有开启。
-在MySQL中，没有index的查询以及超过指定时间同时超过指定扫描行数的查询需要记录在慢日志查询里面。
-
-show global variables like '%indexes%';
-+----------------------------------------+-------+
-| Variable_name                          | Value |
-+----------------------------------------+-------+
-| log_queries_not_using_indexes          | OFF   |
-| log_throttle_queries_not_using_indexes | 0     |
-+----------------------------------------+-------+
-第一个参数表示是否开启记录没有index的查询，
-第二个参数用来做日志记录的流量控制，一分钟可以记录多少条，默认0是表示不限制。
-
-超过指定时长的查询开关
-show global variables like '%long_query%';
-+-----------------+-----------+
-| Variable_name   | Value     |
-+-----------------+-----------+
-| long_query_time | 10.000000 |
-+-----------------+-----------+
-就一个参数指定超过多少时长的查询需要被记录
-
-超过指定行数的扫描查询开关
-show variables like  '%min_examined_row_limit%';
-+------------------------+-------+
-| Variable_name          | Value |
-+------------------------+-------+
-| min_examined_row_limit | 0     |
-+------------------------+-------+
-默认是0，代表不限制扫描行数
-
-设置开启MySQL慢日志参数
-set global long_query_time=0.1;
-set global log_queries_not_using_indexes=on;
-set global slow_query_log = on;
-
-第一是超过什么时长的日志是有问题的，这个由系统需求来决定。
-第二是没有使用indexes的日志每分钟要记录多少条，要防止日志太多对性能产生影响。
+set global general_log=on;
+show global variables like "%genera%";
+
+
+查看MySQL慢日志参数
+show variables like '%slow_query%';
++---------------------------+----------------------------------------+
+| Variable_name             | Value                                  |
++---------------------------+----------------------------------------+
+| slow_query_log            | OFF                                    |
+| slow_query_log_file       | /usr/local/mysql/data/cloudlu-slow.log |
++---------------------------+----------------------------------------+
+这里告诉我们慢日志的日志存放位置，慢日志是否有开启。
+在MySQL中，没有index的查询以及超过指定时间同时超过指定扫描行数的查询需要记录在慢日志查询里面。
+
+show global variables like '%indexes%';
++----------------------------------------+-------+
+| Variable_name                          | Value |
++----------------------------------------+-------+
+| log_queries_not_using_indexes          | OFF   |
+| log_throttle_queries_not_using_indexes | 0     |
++----------------------------------------+-------+
+第一个参数表示是否开启记录没有index的查询，
+第二个参数用来做日志记录的流量控制，一分钟可以记录多少条，默认0是表示不限制。
+
+超过指定时长的查询开关
+show global variables like '%long_query%';
++-----------------+-----------+
+| Variable_name   | Value     |
++-----------------+-----------+
+| long_query_time | 10.000000 |
++-----------------+-----------+
+就一个参数指定超过多少时长的查询需要被记录
+
+超过指定行数的扫描查询开关
+show variables like  '%min_examined_row_limit%';
++------------------------+-------+
+| Variable_name          | Value |
++------------------------+-------+
+| min_examined_row_limit | 0     |
++------------------------+-------+
+默认是0，代表不限制扫描行数
+
+设置开启MySQL慢日志参数
+set global long_query_time=0.1;
+set global log_queries_not_using_indexes=on;
+set global slow_query_log = on;
+
+第一是超过什么时长的日志是有问题的，这个由系统需求来决定。
+第二是没有使用indexes的日志每分钟要记录多少条，要防止日志太多对性能产生影响。
diff --git "a/06 - DB (mysql)/Mysql/mysqldump\345\244\207\344\273\275\346\201\242\345\244\215\346\225\260\346\215\256\345\272\223.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysqldump\345\244\207\344\273\275\346\201\242\345\244\215\346\225\260\346\215\256\345\272\223.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/mysqldump\345\244\207\344\273\275\346\201\242\345\244\215\346\225\260\346\215\256\345\272\223.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysqldump\345\244\207\344\273\275\346\201\242\345\244\215\346\225\260\346\215\256\345\272\223.md"
diff --git "a/06 - DB (mysql)/Mysql/mysql\345\270\270\347\224\250\345\221\275\344\273\244.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysql\345\270\270\347\224\250\345\221\275\344\273\244.md"
similarity index 97%
rename from "06 - DB (mysql)/Mysql/mysql\345\270\270\347\224\250\345\221\275\344\273\244.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysql\345\270\270\347\224\250\345\221\275\344\273\244.md"
index 8fd680c4..a6043280 100644
--- "a/06 - DB (mysql)/Mysql/mysql\345\270\270\347\224\250\345\221\275\344\273\244.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysql\345\270\270\347\224\250\345\221\275\344\273\244.md"	
@@ -1,406 +1,406 @@
-mysql
-	mysql -u root -h 127.0.0.1 -p
-	mysql -u`root` -p`password` `databasename`
-
-	create [database]
-
-	drop [database]
-
-	use [database]
-
-	CREATE TABLE IF NOT EXISTS table_name (
-		column_name column_type
-	)ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-	如果你不想字段为 NULL 可以设置字段的属性为 NOT NULL， 在操作数据库时如果输入该字段的数据为NULL ，就会报错。
-	AUTO_INCREMENT定义列为自增的属性，一般用于主键，数值会自动加1。
-	PRIMARY KEY关键字用于定义列为主键。 您可以使用多列来定义主键，列间以逗号分隔。
-	ENGINE 设置存储引擎，CHARSET 设置编码。
-
-	DROP TABLE table_name ;
-
-	describe [tablename] 查看表结构
-
-	SELECT VERSION( )	服务器版本信息
-	SELECT DATABASE( )	当前数据库名 (或者返回空)
-	SELECT USER( )	当前用户名
-	SHOW STATUS	服务器状态
-	SHOW VARIABLES	服务器配置变量
-
-	SHOW [tablename] STATUS 查看数据表类型
-  SHOW DATABASES
-	show tables 查看所有表
-	show table status where comment='view';  查看所有视图
-
-	`SHOW INDEX FROM table_name;` 显示索引信息
-
-	执行sql文件
-	`source` /var/xxxx.sql;
-
-### 字段修改
-	ALTER
-	删除，添加表字段
-		**ALTER** TABLE testalter_tbl **DROP** i;			```使用了 ALTER 命令及 DROP 子句来删除以上创建表的 i 字段```
-		如果数据表中只剩余一个字段则无法使用DROP来删除字段。
-		**ALTER** TABLE testalter_tbl **ADD**  i INT; ```使用 ADD 子句来向数据表中添加列，如下实例在表 testalter_tbl 中添加 i 字段，并定义数据类型:```
-		自动添加到数据表字段的末尾
-		提供的关键字 **FIRST** (设定位第一列)， **AFTER** 字段名（设定位于某个字段之后）。
-		**ALTER** TABLE testalter_tbl **ADD** i INT **FIRST**;
-		**ALTER** TABLE testalter_tbl **ADD** i INT **AFTER** c;
-
-	修改字段类型及名称
-		**ALTER** TABLE testalter_tbl **MODIFY** c CHAR(10); ```字段 c 的类型从 CHAR(1) 改为 CHAR(10)```
-		**ALTER** TABLE testalter_tbl **CHANGE** i j BIGINT; ```在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型。```
-
-	ALTER TABLE 对 Null 值和默认值的影响
-		**ALTER** TABLE testalter_tbl **MODIFY** j BIGINT **NOT NULL** **DEFAULT** 100; ```如果你不设置默认值，MySQL会自动设置该字段默认为 NULL。```
-
-	修改字段默认值
-		**ALTER** TABLE testalter_tbl **ALTER** i **SET** DEFAULT 1000; ```修改字段的默认值```
-		**ALTER** TABLE testalter_tbl **ALTER** i **DROP** DEFAULT;			```删除字段的默认值```
-
-	修改数据表类型
-		**ALTER** TABLE testalter_tbl **ENGINE** = **MYISAM**;
-
-	修改表名
-	  **ALTER** TABLE testalter_tbl **RENAME** TO alter_tbl;
-
-	修改表结构(添加索引)
-		**ALTER** table tableName **ADD** **INDEX** indexName(columnName)
-
-	**外键约束 取消**
-	SET `FOREIGN_KEY_CHECKS`=0;
-	来禁用外键约束.
-			然后这块执行我们的插入语句....
-	之后再用
-	SET `FOREIGN_KEY_CHECKS`=1;
-	来启动外键约束.
-
-	INSERT uuid()
-
-	INSERT INTO table_name ( field1, field2,...fieldN )
-                       VALUES
-                       ( value1, value2,...valueN );
-
-	**INSERT** **INTO** Task (TaskID,TaskName,TaskTypeID,TaskPriority,CreateTime,ModifyTime,StartTime,Period,ExeCount,InstantTotalCount,QualityIndex,TaskDescribe,DetectionChannel)
-			values(uuid(),"全局轮询任务",1,4,"1511332788644" ,"1511332788644","1511332788644",4,0,0,"11111111111111000000000000000000","全局巡检任务",3)
-
-
-	**UPDATE** table_name **SET** field1=new-value1, field2=new-value2
-			[WHERE Clause]
-
-	**DELETE** **FROM** table_name [WHERE Clause]
-
-	SELECT column_name,column_name
-			FROM table_name
-					[WHERE Clause]
-							[LIMIT N][ OFFSET M]
-
-	你可以使用 WHERE 语句来包含任何条件。
-	你可以使用 LIMIT 属性来设定返回的记录数。
-	你可以通过OFFSET指定SELECT语句开始查询的数据偏移量。默认情况下偏移量为0。
-
-	SELECT field1, field2,...fieldN FROM table_name1, table_name2...
-			WHERE condition1 [AND [OR]] condition2.....
-
-	**Like 子句**
-	```
-	*
-	_ : 表示任意单个字符。匹配单个任意字符，它常用来限制表达式的字符长度语句：（可以代表一个中文字符）
-	% ：表示任意个或多个字符。可匹配任意类型和长度的字符。
-
-	如果我就真的要查%或者_，怎么办呢？使用escape，转义字符后面的%或_就不作为通配符了，注意前面没有转义字符的%和_仍然起通配符作用
-	like '%/_20%' escape "/"
-	```
-
-  **ORDER BY** field1, [field2...] [**ASC** [**DESC**]]
-
-	SELECT column_name, **function**(column_name)
-			FROM table_name
-					WHERE column_name operator value
-							**GROUP BY** column_name;
-	**COUNT**, **SUM**, **AVG**,
-
-	**UNION** [ALL | DISTINCT]
-	DISTINCT: 可选，删除结果集中重复的数据。默认情况下 UNION 操作符已经删除了重复数据，所以 DISTINCT 修饰符对结果没啥影响。
-	ALL: 可选，返回所有结果集，包含重复数据。
-
-	**INNER JOIN**（内连接,或等值连接）：获取两个表中字段匹配关系的记录。
-	**LEFT JOIN**（左连接）：获取左表所有记录，即使右表没有对应匹配的记录。
-	**RIGHT JOIN**（右连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录。
-
-	**IS NULL**: 当列的值是 NULL,此运算符返回 true。
-	**IS NOT NULL**: 当列的值不为 NULL, 运算符返回 true。
-	**<=>**: 比较操作符（不同于=运算符），当比较的的两个值为 NULL 时返回 true。
-
-	**普通索引** 这是最基本的索引，它没有任何限制。
-	创建索引
-	CREATE INDEX indexName ON mytable(username(length));
-	如果是CHAR，VARCHAR类型，length可以小于字段实际长度；如果是BLOB和TEXT类型，必须指定 length。
-	修改表结构(添加索引)
-	ALTER table tableName ADD INDEX indexName(columnName)
-	删除索引的语法
-	DROP INDEX [indexName] ON mytable;
-
-	**唯一索引** 它与前面的普通索引类似，不同的就是：索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。
-	创建索引
-		CREATE UNIQUE INDEX indexName ON mytable(username(length))
-	修改表结构
-		ALTER table mytable ADD UNIQUE [indexName] (username(length))
-
-	主键只能作用于一个列上，**添加主键索引** 时，你需要确保该主键默认不为空（NOT NULL）。实例如下：
-	ALTER TABLE testalter_tbl MODIFY i INT NOT NULL;
-
-	ALTER TABLE `test2` ADD PRIMARY KEY ( `id` )
-  ALTER TABLE testalter_tbl ADD PRIMARY KEY (i);
-	使用 ALTER 命令 **删除主键**：
-	ALTER TABLE GroupChannel DROP PRIMARY KEY;
-	alter table GroupChannel add primary key(TreeID,ChannelID,GroupID,SyncRoundNum);
-
-  **添加索引**
-	ALTER TABLE `test2` ADD INDEX ( `id` )
-	ALTER TABLE testalter_tbl ADD INDEX (c);
- 	ALTER 命令中使用 DROP 子句来 **删除索引**
-	ALTER TABLE testalter_tbl DROP INDEX c;
-
-	**临时表** **TEMPORARY**
-
-	**复制表**
-	结构 SHOW CREATE TABLE
-	数据 INSERT INTO... SELECT 语句
-
-	**序列**
-	使用AUTO_INCREMENT
-	获取AUTO_INCREMENT值
-	LAST_INSERT_ID( ) 函数 获取最后的插入表中的自增列的值
-
-	重置序列
-
-	如果你删除了数据表中的多条记录，并希望对剩下数据的AUTO_INCREMENT列进行重新排列，那么你可以通过删除自增的列，然后重新添加来实现。 不过该操作要非常小心，如果在删除的同时又有新记录添加，有可能会出现数据混乱。操作如下所示：
-
-		mysql> ALTER TABLE insect DROP id;
-		mysql> ALTER TABLE insect
-		    -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
-		    -> ADD PRIMARY KEY (id);
-
-	设置序列的开始值
-
-	一般情况下序列的开始值为1，但如果你需要指定一个开始值100，那我们可以通过以下语句来实现：
-
-	mysql> CREATE TABLE insect
-	    -> (
-	    -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-	    -> PRIMARY KEY (id),
-	    -> name VARCHAR(30) NOT NULL,
-	    -> date DATE NOT NULL,
-	    -> origin VARCHAR(30) NOT NULL
-	)engine=innodb auto_increment=100 charset=utf8;
-	或者你也可以在表创建成功后，通过以下语句来实现：
-
-	mysql> ALTER TABLE t AUTO_INCREMENT = 100;
-
-	**处理重复数据**
-
-	防止表中出现重复数据
-
-	可以在MySQL数据表中设置指定的字段为 **PRIMARY KEY**（主键） 或者 **UNIQUE**（唯一） 索引来保证数据的唯一性。
-
-	CREATE TABLE person_tbl
-	(
-	   first_name CHAR(20) NOT NULL,
-	   last_name CHAR(20) NOT NULL,
-	   sex CHAR(10),
-	   **PRIMARY KEY** (last_name, first_name)
-	);
-
-	CREATE TABLE person_tbl
-	(
-	   first_name CHAR(20) NOT NULL,
-	   last_name CHAR(20) NOT NULL,
-	   sex CHAR(10)
-	   **UNIQUE** (last_name, first_name)
-	);
-
-	如果我们设置了 **唯一索引** ，那么在插入重复数据时，SQL语句将无法执行成功,并抛出错。
-
-	**INSERT IGNORE INTO** 与INSERT INTO的区别就是INSERT IGNORE会忽略数据库中已经存在的数据，如果数据库没有数据，就插入新的数据，如果有数据的话就跳过这条数据。这样就可以保留数据库中已经存在数据，达到在间隙中插入数据的目的。
-
-	以下实例使用了INSERT IGNORE INTO，执行后不会出错，也不会向数据表中插入重复数据：
-
-	mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
-    -> VALUES( 'Jay', 'Thomas');
-	Query OK, 1 row affected (0.00 sec)
-	mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
-	    -> VALUES( 'Jay', 'Thomas');
-	Query OK, 0 rows affected (0.00 sec)
-
-	INSERT IGNORE INTO当插入数据时，在设置了记录的唯一性后，如果插入重复数据，将不返回错误，只以警告形式返回。 而REPLACE INTO into如果存在primary 或 unique相同的记录，则先删除掉。再插入新记录。
-
-	统计重复数据
-
-	以下我们将统计表中 first_name 和 last_name的重复记录数：
-
-	mysql> SELECT COUNT( * ) as repetitions, last_name, first_name
-	    -> FROM person_tbl
-	    -> **GROUP BY** last_name, first_name
-	    -> **HAVING** repetitions > 1;
-	以上查询语句将返回 person_tbl 表中重复的记录数。 一般情况下，查询重复的值，请执行以下操作：
-
-	1. 确定哪一列包含的值可能会重复。
-	2. 在列选择列表使用COUNT( * )列出的那些列。
-	3. 在GROUP BY子句中列出的列。
-	4. HAVING子句设置重复数大于1。
-
-	过滤重复数据
-	如果你需要读取不重复的数据可以在 SELECT 语句中使用 **DISTINCT** 关键字来过滤重复数据。
-
-	mysql> SELECT **DISTINCT** last_name, first_name
-	    -> FROM person_tbl;
-	你也可以使用 GROUP BY 来读取数据表中不重复的数据：
-	mysql> SELECT last_name, first_name
-	    -> FROM person_tbl
-	    -> GROUP BY (last_name, first_name);
-
-	删除重复数据
-	如果你想删除数据表中的重复数据，你可以使用以下的SQL语句：
-
-	mysql> CREATE TABLE tmp SELECT last_name, first_name, sex FROM person_tbl  GROUP BY (last_name, first_name, sex);
-	mysql> DROP TABLE person_tbl;
-	mysql> ALTER TABLE tmp RENAME TO person_tbl;
-
-	当然你也可以在数据表中添加 INDEX（索引） 和 PRIMAY KEY（主键）这种简单的方法来删除表中的重复记录。方法如下：
-
-	mysql> ALTER IGNORE TABLE person_tbl
-	    -> ADD PRIMARY KEY (last_name, first_name);
-
-	SQL注入
-	SQL注入，就是通过把 **SQL命令** 插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。
-
-	我们永远不要信任用户的输入，我们必须认定用户输入的数据都是不安全的，我们都需要对用户输入的数据进行过滤处理。
-
-	以下实例中，输入的用户名必须为字母、数字及下划线的组合，且用户名长度为 8 到 20 个字符之间：
-	``` mysql
-		if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches))
-		{
-		   $result = mysqli_query($conn, "SELECT * FROM users
-		                          WHERE username=$matches[0]");
-		}
-		 else
-		{
-		   echo "username 输入异常";
-		}
-	```
-	让我们看下在没有过滤特殊字符时，出现的SQL情况：
-
-	// 设定$name 中插入了我们不需要的SQL语句
-	$name = "Qadir'; DELETE FROM users;";
-	mysqli_query($conn, "SELECT * FROM users WHERE name='{$name}'");
-
-	Like语句中的注入
-	like查询时，如果用户输入的值有"_"和"%"，则会出现这种情况：用户本来只是想查询"abcd_"，查询结果中却有"abcd_"、"abcde"、"abcdf"等等；用户要查询"30%"（注：百分之三十）时也会出现问题。
-
-
-
-	**导出数据**
-
-	使用 **SELECT ... INTO 	OUTFILE** 语句导出数据
-
-	SELECT ... INTO OUTFILE 语句有以下属性:
-	**LOAD DATA INFILE** 是SELECT ... INTO OUTFILE的逆操作，SELECT句法。为了将一个数据库的数据写入一个文件，使用SELECT ... INTO OUTFILE，为了将文件读回数据库，使用LOAD DATA INFILE。
-	SELECT...INTO OUTFILE 'file_name'形式的SELECT可以把被选择的行写入一个文件中。该文件被创建到服务器主机上，因此您必须拥有FILE权限，才能使用此语法。
-	输出不能是一个 **已存在** 的文件。防止文件数据被篡改。
-	你需要有一个登陆服务器的账号来检索文件。否则 SELECT ... INTO OUTFILE 不会起任何作用。
-	在UNIX中，该文件被创建后是可读的，权限由MySQL服务器所拥有。这意味着，虽然你就可以读取该文件，但可能无法将其删除。
-
-	**导出表作为原始数据** **mysqldump**
-	mysqldump是mysql用于转存储数据库的实用程序。它主要产生一个SQL脚本，其中包含从头重新创建数据库所必需的命令CREATE TABLE INSERT等。
-
-	使用mysqldump导出数据需要使用 --tab 选项来指定导出文件指定的目录，该目标必须是可写的。
-	以下实例将数据表 runoob_tbl 导出到 /tmp 目录中：
-
-		$ mysqldump -u root -p --no-create-info \
-		            --tab=/tmp RUNOOB runoob_tbl
-		password ******
-
-		**导出SQL格式的数据**
-	导出SQL格式的数据到指定文件，如下所示：
-
-	$ mysqldump -u root -p RUNOOB runoob_tbl > dump.txt
-	password ******
-
-	如果你需要导出整个数据库的数据，可以使用以下命令：
-
-	$ mysqldump -u root -p RUNOOB > database_dump.txt
-	password ******
-
-	如果需要备份所有数据库，可以使用以下命令：
-
-	$ mysqldump -u root -p --all-databases > database_dump.txt
-	password ******
-	--all-databases 选项在 MySQL 3.23.12 及以后版本加入。 该方法可用于实现数据库的备份策略。
-
-	将数据表及数据库拷贝至其他主机
-	如果你需要将数据拷贝至其他的 MySQL 服务器上, 你可以在 mysqldump 命令中指定数据库名及数据表。
-
-	在源主机上执行以下命令，将数据备份至 dump.txt 文件中:
-
-	$ mysqldump -u root -p database_name table_name > dump.txt
-	password *****
-	如果完整备份数据库，则无需使用特定的表名称。
-
-	如果你需要将备份的数据库导入到MySQL服务器中，可以使用以下命令，使用以下命令你需要确认数据库已经创建：
-
-
-	$ mysql -u root -p database_name < dump.txt
-	password *****
-	你也可以使用以下命令将导出的数据直接导入到远程的服务器上，但请确保两台服务器是相通的，是可以相互访问的：</p>
-	$ mysqldump -u root -p database_name \
-	       | mysql -h other-host.com database_name
-				 以上命令中使用了管道来将导出的数据导入到指定的远程主机上。
-
-	**导入数据**
-
-	使用 **LOAD DATA** 导入数据
-	MySQL 中提供了LOAD DATA INFILE语句来插入数据。 以下实例中将从当前目录中读取文件 dump.txt ，将该文件中的数据插入到当前数据库的 mytbl 表中。
-
-	mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;
-	　如果指定LOCAL关键词，则表明从客户主机上按路径读取文件。如果没有指定，则文件在服务器上按路径读取文件。
-
-	你能明确地在LOAD DATA语句中指出列值的分隔符和行尾标记，但是默认标记是定位符和换行符。
-
-	两个命令的 FIELDS 和 LINES 子句的语法是一样的。两个子句都是可选的，但是如果两个同时被指定，FIELDS 子句必须出现在 LINES 子句之前。
-
-	如果用户指定一个 FIELDS 子句，它的子句 （TERMINATED BY、[OPTIONALLY] ENCLOSED BY 和 ESCAPED BY) 也是可选的，不过，用户必须至少指定它们中的一个。
-
-	mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
-	  -> FIELDS TERMINATED BY ':'
-	  -> LINES TERMINATED BY '\r\n';
-	LOAD DATA 默认情况下是按照数据文件中列的顺序插入数据的，如果数据文件中的列与插入表中的列不一致，则需要指定列的顺序。
-
-	如，在数据文件中的列顺序是 a,b,c，但在插入表的列顺序为b,c,a，则数据导入语法如下：
-
-	mysql> LOAD DATA LOCAL INFILE 'dump.txt'
-	    -> INTO TABLE mytbl (b, c, a);
-
-	**使用 mysqlimport 导入数据**
-	mysqlimport客户端提供了LOAD DATA INFILEQL语句的一个命令行接口。mysqlimport的大多数选项直接对应LOAD DATA INFILE子句。
-
-	从文件 dump.txt 中将数据导入到 mytbl 数据表中, 可以使用以下命令：
-
-	$ mysqlimport -u root -p --local database_name dump.txt
-	password *****
-	mysqlimport命令可以指定选项来设置指定格式,命令语句格式如下：
-
-	$ mysqlimport -u root -p --local --fields-terminated-by=":" \
-	   --lines-terminated-by="\r\n"  database_name dump.txt
-	password *****
-	mysqlimport 语句中使用 --columns 选项来设置列的顺序：
-
-	$ mysqlimport -u root -p --local --columns=b,c,a \
-	    database_name dump.txt
-	password *****
-
-	CONCAT()函数 解决数字过长丢真，加字符使其变为字符串格式
-	```
-		CONCAT('`',【字段名】)
-	```
+mysql
+	mysql -u root -h 127.0.0.1 -p
+	mysql -u`root` -p`password` `databasename`
+
+	create [database]
+
+	drop [database]
+
+	use [database]
+
+	CREATE TABLE IF NOT EXISTS table_name (
+		column_name column_type
+	)ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+	如果你不想字段为 NULL 可以设置字段的属性为 NOT NULL， 在操作数据库时如果输入该字段的数据为NULL ，就会报错。
+	AUTO_INCREMENT定义列为自增的属性，一般用于主键，数值会自动加1。
+	PRIMARY KEY关键字用于定义列为主键。 您可以使用多列来定义主键，列间以逗号分隔。
+	ENGINE 设置存储引擎，CHARSET 设置编码。
+
+	DROP TABLE table_name ;
+
+	describe [tablename] 查看表结构
+
+	SELECT VERSION( )	服务器版本信息
+	SELECT DATABASE( )	当前数据库名 (或者返回空)
+	SELECT USER( )	当前用户名
+	SHOW STATUS	服务器状态
+	SHOW VARIABLES	服务器配置变量
+
+	SHOW [tablename] STATUS 查看数据表类型
+  SHOW DATABASES
+	show tables 查看所有表
+	show table status where comment='view';  查看所有视图
+
+	`SHOW INDEX FROM table_name;` 显示索引信息
+
+	执行sql文件
+	`source` /var/xxxx.sql;
+
+### 字段修改
+	ALTER
+	删除，添加表字段
+		**ALTER** TABLE testalter_tbl **DROP** i;			```使用了 ALTER 命令及 DROP 子句来删除以上创建表的 i 字段```
+		如果数据表中只剩余一个字段则无法使用DROP来删除字段。
+		**ALTER** TABLE testalter_tbl **ADD**  i INT; ```使用 ADD 子句来向数据表中添加列，如下实例在表 testalter_tbl 中添加 i 字段，并定义数据类型:```
+		自动添加到数据表字段的末尾
+		提供的关键字 **FIRST** (设定位第一列)， **AFTER** 字段名（设定位于某个字段之后）。
+		**ALTER** TABLE testalter_tbl **ADD** i INT **FIRST**;
+		**ALTER** TABLE testalter_tbl **ADD** i INT **AFTER** c;
+
+	修改字段类型及名称
+		**ALTER** TABLE testalter_tbl **MODIFY** c CHAR(10); ```字段 c 的类型从 CHAR(1) 改为 CHAR(10)```
+		**ALTER** TABLE testalter_tbl **CHANGE** i j BIGINT; ```在 CHANGE 关键字之后，紧跟着的是你要修改的字段名，然后指定新字段名及类型。```
+
+	ALTER TABLE 对 Null 值和默认值的影响
+		**ALTER** TABLE testalter_tbl **MODIFY** j BIGINT **NOT NULL** **DEFAULT** 100; ```如果你不设置默认值，MySQL会自动设置该字段默认为 NULL。```
+
+	修改字段默认值
+		**ALTER** TABLE testalter_tbl **ALTER** i **SET** DEFAULT 1000; ```修改字段的默认值```
+		**ALTER** TABLE testalter_tbl **ALTER** i **DROP** DEFAULT;			```删除字段的默认值```
+
+	修改数据表类型
+		**ALTER** TABLE testalter_tbl **ENGINE** = **MYISAM**;
+
+	修改表名
+	  **ALTER** TABLE testalter_tbl **RENAME** TO alter_tbl;
+
+	修改表结构(添加索引)
+		**ALTER** table tableName **ADD** **INDEX** indexName(columnName)
+
+	**外键约束 取消**
+	SET `FOREIGN_KEY_CHECKS`=0;
+	来禁用外键约束.
+			然后这块执行我们的插入语句....
+	之后再用
+	SET `FOREIGN_KEY_CHECKS`=1;
+	来启动外键约束.
+
+	INSERT uuid()
+
+	INSERT INTO table_name ( field1, field2,...fieldN )
+                       VALUES
+                       ( value1, value2,...valueN );
+
+	**INSERT** **INTO** Task (TaskID,TaskName,TaskTypeID,TaskPriority,CreateTime,ModifyTime,StartTime,Period,ExeCount,InstantTotalCount,QualityIndex,TaskDescribe,DetectionChannel)
+			values(uuid(),"全局轮询任务",1,4,"1511332788644" ,"1511332788644","1511332788644",4,0,0,"11111111111111000000000000000000","全局巡检任务",3)
+
+
+	**UPDATE** table_name **SET** field1=new-value1, field2=new-value2
+			[WHERE Clause]
+
+	**DELETE** **FROM** table_name [WHERE Clause]
+
+	SELECT column_name,column_name
+			FROM table_name
+					[WHERE Clause]
+							[LIMIT N][ OFFSET M]
+
+	你可以使用 WHERE 语句来包含任何条件。
+	你可以使用 LIMIT 属性来设定返回的记录数。
+	你可以通过OFFSET指定SELECT语句开始查询的数据偏移量。默认情况下偏移量为0。
+
+	SELECT field1, field2,...fieldN FROM table_name1, table_name2...
+			WHERE condition1 [AND [OR]] condition2.....
+
+	**Like 子句**
+	```
+	*
+	_ : 表示任意单个字符。匹配单个任意字符，它常用来限制表达式的字符长度语句：（可以代表一个中文字符）
+	% ：表示任意个或多个字符。可匹配任意类型和长度的字符。
+
+	如果我就真的要查%或者_，怎么办呢？使用escape，转义字符后面的%或_就不作为通配符了，注意前面没有转义字符的%和_仍然起通配符作用
+	like '%/_20%' escape "/"
+	```
+
+  **ORDER BY** field1, [field2...] [**ASC** [**DESC**]]
+
+	SELECT column_name, **function**(column_name)
+			FROM table_name
+					WHERE column_name operator value
+							**GROUP BY** column_name;
+	**COUNT**, **SUM**, **AVG**,
+
+	**UNION** [ALL | DISTINCT]
+	DISTINCT: 可选，删除结果集中重复的数据。默认情况下 UNION 操作符已经删除了重复数据，所以 DISTINCT 修饰符对结果没啥影响。
+	ALL: 可选，返回所有结果集，包含重复数据。
+
+	**INNER JOIN**（内连接,或等值连接）：获取两个表中字段匹配关系的记录。
+	**LEFT JOIN**（左连接）：获取左表所有记录，即使右表没有对应匹配的记录。
+	**RIGHT JOIN**（右连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录。
+
+	**IS NULL**: 当列的值是 NULL,此运算符返回 true。
+	**IS NOT NULL**: 当列的值不为 NULL, 运算符返回 true。
+	**<=>**: 比较操作符（不同于=运算符），当比较的的两个值为 NULL 时返回 true。
+
+	**普通索引** 这是最基本的索引，它没有任何限制。
+	创建索引
+	CREATE INDEX indexName ON mytable(username(length));
+	如果是CHAR，VARCHAR类型，length可以小于字段实际长度；如果是BLOB和TEXT类型，必须指定 length。
+	修改表结构(添加索引)
+	ALTER table tableName ADD INDEX indexName(columnName)
+	删除索引的语法
+	DROP INDEX [indexName] ON mytable;
+
+	**唯一索引** 它与前面的普通索引类似，不同的就是：索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。
+	创建索引
+		CREATE UNIQUE INDEX indexName ON mytable(username(length))
+	修改表结构
+		ALTER table mytable ADD UNIQUE [indexName] (username(length))
+
+	主键只能作用于一个列上，**添加主键索引** 时，你需要确保该主键默认不为空（NOT NULL）。实例如下：
+	ALTER TABLE testalter_tbl MODIFY i INT NOT NULL;
+
+	ALTER TABLE `test2` ADD PRIMARY KEY ( `id` )
+  ALTER TABLE testalter_tbl ADD PRIMARY KEY (i);
+	使用 ALTER 命令 **删除主键**：
+	ALTER TABLE GroupChannel DROP PRIMARY KEY;
+	alter table GroupChannel add primary key(TreeID,ChannelID,GroupID,SyncRoundNum);
+
+  **添加索引**
+	ALTER TABLE `test2` ADD INDEX ( `id` )
+	ALTER TABLE testalter_tbl ADD INDEX (c);
+ 	ALTER 命令中使用 DROP 子句来 **删除索引**
+	ALTER TABLE testalter_tbl DROP INDEX c;
+
+	**临时表** **TEMPORARY**
+
+	**复制表**
+	结构 SHOW CREATE TABLE
+	数据 INSERT INTO... SELECT 语句
+
+	**序列**
+	使用AUTO_INCREMENT
+	获取AUTO_INCREMENT值
+	LAST_INSERT_ID( ) 函数 获取最后的插入表中的自增列的值
+
+	重置序列
+
+	如果你删除了数据表中的多条记录，并希望对剩下数据的AUTO_INCREMENT列进行重新排列，那么你可以通过删除自增的列，然后重新添加来实现。 不过该操作要非常小心，如果在删除的同时又有新记录添加，有可能会出现数据混乱。操作如下所示：
+
+		mysql> ALTER TABLE insect DROP id;
+		mysql> ALTER TABLE insect
+		    -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
+		    -> ADD PRIMARY KEY (id);
+
+	设置序列的开始值
+
+	一般情况下序列的开始值为1，但如果你需要指定一个开始值100，那我们可以通过以下语句来实现：
+
+	mysql> CREATE TABLE insect
+	    -> (
+	    -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
+	    -> PRIMARY KEY (id),
+	    -> name VARCHAR(30) NOT NULL,
+	    -> date DATE NOT NULL,
+	    -> origin VARCHAR(30) NOT NULL
+	)engine=innodb auto_increment=100 charset=utf8;
+	或者你也可以在表创建成功后，通过以下语句来实现：
+
+	mysql> ALTER TABLE t AUTO_INCREMENT = 100;
+
+	**处理重复数据**
+
+	防止表中出现重复数据
+
+	可以在MySQL数据表中设置指定的字段为 **PRIMARY KEY**（主键） 或者 **UNIQUE**（唯一） 索引来保证数据的唯一性。
+
+	CREATE TABLE person_tbl
+	(
+	   first_name CHAR(20) NOT NULL,
+	   last_name CHAR(20) NOT NULL,
+	   sex CHAR(10),
+	   **PRIMARY KEY** (last_name, first_name)
+	);
+
+	CREATE TABLE person_tbl
+	(
+	   first_name CHAR(20) NOT NULL,
+	   last_name CHAR(20) NOT NULL,
+	   sex CHAR(10)
+	   **UNIQUE** (last_name, first_name)
+	);
+
+	如果我们设置了 **唯一索引** ，那么在插入重复数据时，SQL语句将无法执行成功,并抛出错。
+
+	**INSERT IGNORE INTO** 与INSERT INTO的区别就是INSERT IGNORE会忽略数据库中已经存在的数据，如果数据库没有数据，就插入新的数据，如果有数据的话就跳过这条数据。这样就可以保留数据库中已经存在数据，达到在间隙中插入数据的目的。
+
+	以下实例使用了INSERT IGNORE INTO，执行后不会出错，也不会向数据表中插入重复数据：
+
+	mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
+    -> VALUES( 'Jay', 'Thomas');
+	Query OK, 1 row affected (0.00 sec)
+	mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
+	    -> VALUES( 'Jay', 'Thomas');
+	Query OK, 0 rows affected (0.00 sec)
+
+	INSERT IGNORE INTO当插入数据时，在设置了记录的唯一性后，如果插入重复数据，将不返回错误，只以警告形式返回。 而REPLACE INTO into如果存在primary 或 unique相同的记录，则先删除掉。再插入新记录。
+
+	统计重复数据
+
+	以下我们将统计表中 first_name 和 last_name的重复记录数：
+
+	mysql> SELECT COUNT( * ) as repetitions, last_name, first_name
+	    -> FROM person_tbl
+	    -> **GROUP BY** last_name, first_name
+	    -> **HAVING** repetitions > 1;
+	以上查询语句将返回 person_tbl 表中重复的记录数。 一般情况下，查询重复的值，请执行以下操作：
+
+	1. 确定哪一列包含的值可能会重复。
+	2. 在列选择列表使用COUNT( * )列出的那些列。
+	3. 在GROUP BY子句中列出的列。
+	4. HAVING子句设置重复数大于1。
+
+	过滤重复数据
+	如果你需要读取不重复的数据可以在 SELECT 语句中使用 **DISTINCT** 关键字来过滤重复数据。
+
+	mysql> SELECT **DISTINCT** last_name, first_name
+	    -> FROM person_tbl;
+	你也可以使用 GROUP BY 来读取数据表中不重复的数据：
+	mysql> SELECT last_name, first_name
+	    -> FROM person_tbl
+	    -> GROUP BY (last_name, first_name);
+
+	删除重复数据
+	如果你想删除数据表中的重复数据，你可以使用以下的SQL语句：
+
+	mysql> CREATE TABLE tmp SELECT last_name, first_name, sex FROM person_tbl  GROUP BY (last_name, first_name, sex);
+	mysql> DROP TABLE person_tbl;
+	mysql> ALTER TABLE tmp RENAME TO person_tbl;
+
+	当然你也可以在数据表中添加 INDEX（索引） 和 PRIMAY KEY（主键）这种简单的方法来删除表中的重复记录。方法如下：
+
+	mysql> ALTER IGNORE TABLE person_tbl
+	    -> ADD PRIMARY KEY (last_name, first_name);
+
+	SQL注入
+	SQL注入，就是通过把 **SQL命令** 插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。
+
+	我们永远不要信任用户的输入，我们必须认定用户输入的数据都是不安全的，我们都需要对用户输入的数据进行过滤处理。
+
+	以下实例中，输入的用户名必须为字母、数字及下划线的组合，且用户名长度为 8 到 20 个字符之间：
+	``` mysql
+		if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches))
+		{
+		   $result = mysqli_query($conn, "SELECT * FROM users
+		                          WHERE username=$matches[0]");
+		}
+		 else
+		{
+		   echo "username 输入异常";
+		}
+	```
+	让我们看下在没有过滤特殊字符时，出现的SQL情况：
+
+	// 设定$name 中插入了我们不需要的SQL语句
+	$name = "Qadir'; DELETE FROM users;";
+	mysqli_query($conn, "SELECT * FROM users WHERE name='{$name}'");
+
+	Like语句中的注入
+	like查询时，如果用户输入的值有"_"和"%"，则会出现这种情况：用户本来只是想查询"abcd_"，查询结果中却有"abcd_"、"abcde"、"abcdf"等等；用户要查询"30%"（注：百分之三十）时也会出现问题。
+
+
+
+	**导出数据**
+
+	使用 **SELECT ... INTO 	OUTFILE** 语句导出数据
+
+	SELECT ... INTO OUTFILE 语句有以下属性:
+	**LOAD DATA INFILE** 是SELECT ... INTO OUTFILE的逆操作，SELECT句法。为了将一个数据库的数据写入一个文件，使用SELECT ... INTO OUTFILE，为了将文件读回数据库，使用LOAD DATA INFILE。
+	SELECT...INTO OUTFILE 'file_name'形式的SELECT可以把被选择的行写入一个文件中。该文件被创建到服务器主机上，因此您必须拥有FILE权限，才能使用此语法。
+	输出不能是一个 **已存在** 的文件。防止文件数据被篡改。
+	你需要有一个登陆服务器的账号来检索文件。否则 SELECT ... INTO OUTFILE 不会起任何作用。
+	在UNIX中，该文件被创建后是可读的，权限由MySQL服务器所拥有。这意味着，虽然你就可以读取该文件，但可能无法将其删除。
+
+	**导出表作为原始数据** **mysqldump**
+	mysqldump是mysql用于转存储数据库的实用程序。它主要产生一个SQL脚本，其中包含从头重新创建数据库所必需的命令CREATE TABLE INSERT等。
+
+	使用mysqldump导出数据需要使用 --tab 选项来指定导出文件指定的目录，该目标必须是可写的。
+	以下实例将数据表 runoob_tbl 导出到 /tmp 目录中：
+
+		$ mysqldump -u root -p --no-create-info \
+		            --tab=/tmp RUNOOB runoob_tbl
+		password ******
+
+		**导出SQL格式的数据**
+	导出SQL格式的数据到指定文件，如下所示：
+
+	$ mysqldump -u root -p RUNOOB runoob_tbl > dump.txt
+	password ******
+
+	如果你需要导出整个数据库的数据，可以使用以下命令：
+
+	$ mysqldump -u root -p RUNOOB > database_dump.txt
+	password ******
+
+	如果需要备份所有数据库，可以使用以下命令：
+
+	$ mysqldump -u root -p --all-databases > database_dump.txt
+	password ******
+	--all-databases 选项在 MySQL 3.23.12 及以后版本加入。 该方法可用于实现数据库的备份策略。
+
+	将数据表及数据库拷贝至其他主机
+	如果你需要将数据拷贝至其他的 MySQL 服务器上, 你可以在 mysqldump 命令中指定数据库名及数据表。
+
+	在源主机上执行以下命令，将数据备份至 dump.txt 文件中:
+
+	$ mysqldump -u root -p database_name table_name > dump.txt
+	password *****
+	如果完整备份数据库，则无需使用特定的表名称。
+
+	如果你需要将备份的数据库导入到MySQL服务器中，可以使用以下命令，使用以下命令你需要确认数据库已经创建：
+
+
+	$ mysql -u root -p database_name < dump.txt
+	password *****
+	你也可以使用以下命令将导出的数据直接导入到远程的服务器上，但请确保两台服务器是相通的，是可以相互访问的：</p>
+	$ mysqldump -u root -p database_name \
+	       | mysql -h other-host.com database_name
+				 以上命令中使用了管道来将导出的数据导入到指定的远程主机上。
+
+	**导入数据**
+
+	使用 **LOAD DATA** 导入数据
+	MySQL 中提供了LOAD DATA INFILE语句来插入数据。 以下实例中将从当前目录中读取文件 dump.txt ，将该文件中的数据插入到当前数据库的 mytbl 表中。
+
+	mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;
+	　如果指定LOCAL关键词，则表明从客户主机上按路径读取文件。如果没有指定，则文件在服务器上按路径读取文件。
+
+	你能明确地在LOAD DATA语句中指出列值的分隔符和行尾标记，但是默认标记是定位符和换行符。
+
+	两个命令的 FIELDS 和 LINES 子句的语法是一样的。两个子句都是可选的，但是如果两个同时被指定，FIELDS 子句必须出现在 LINES 子句之前。
+
+	如果用户指定一个 FIELDS 子句，它的子句 （TERMINATED BY、[OPTIONALLY] ENCLOSED BY 和 ESCAPED BY) 也是可选的，不过，用户必须至少指定它们中的一个。
+
+	mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
+	  -> FIELDS TERMINATED BY ':'
+	  -> LINES TERMINATED BY '\r\n';
+	LOAD DATA 默认情况下是按照数据文件中列的顺序插入数据的，如果数据文件中的列与插入表中的列不一致，则需要指定列的顺序。
+
+	如，在数据文件中的列顺序是 a,b,c，但在插入表的列顺序为b,c,a，则数据导入语法如下：
+
+	mysql> LOAD DATA LOCAL INFILE 'dump.txt'
+	    -> INTO TABLE mytbl (b, c, a);
+
+	**使用 mysqlimport 导入数据**
+	mysqlimport客户端提供了LOAD DATA INFILEQL语句的一个命令行接口。mysqlimport的大多数选项直接对应LOAD DATA INFILE子句。
+
+	从文件 dump.txt 中将数据导入到 mytbl 数据表中, 可以使用以下命令：
+
+	$ mysqlimport -u root -p --local database_name dump.txt
+	password *****
+	mysqlimport命令可以指定选项来设置指定格式,命令语句格式如下：
+
+	$ mysqlimport -u root -p --local --fields-terminated-by=":" \
+	   --lines-terminated-by="\r\n"  database_name dump.txt
+	password *****
+	mysqlimport 语句中使用 --columns 选项来设置列的顺序：
+
+	$ mysqlimport -u root -p --local --columns=b,c,a \
+	    database_name dump.txt
+	password *****
+
+	CONCAT()函数 解决数字过长丢真，加字符使其变为字符串格式
+	```
+		CONCAT('`',【字段名】)
+	```
diff --git "a/06 - DB (mysql)/Mysql/mysql\346\200\247\350\203\275\350\260\203\344\274\230\344\270\216\346\265\213\350\257\225.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysql\346\200\247\350\203\275\350\260\203\344\274\230\344\270\216\346\265\213\350\257\225.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/mysql\346\200\247\350\203\275\350\260\203\344\274\230\344\270\216\346\265\213\350\257\225.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/mysql\346\200\247\350\203\275\350\260\203\344\274\230\344\270\216\346\265\213\350\257\225.md"
diff --git a/06 - DB (mysql)/Mysql/replace_into.md "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/replace_into.md"
similarity index 100%
rename from 06 - DB (mysql)/Mysql/replace_into.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/replace_into.md"
diff --git "a/06 - DB (mysql)/Mysql/sql\346\263\250\345\205\245.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/sql\346\263\250\345\205\245.md"
similarity index 97%
rename from "06 - DB (mysql)/Mysql/sql\346\263\250\345\205\245.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/sql\346\263\250\345\205\245.md"
index 708fbb79..5719311c 100644
--- "a/06 - DB (mysql)/Mysql/sql\346\263\250\345\205\245.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/sql\346\263\250\345\205\245.md"	
@@ -1,22 +1,22 @@
-拼接sql
-
-Statement
-PrepareStatement
-
-hibernate
-:name setstring(name,value)
-?  setstring(0,value)
-
-Mybatis
-
-#
-$
-（1）变量的传递，必须使用#，使用#{}就等于使用了PrepareStatement这种占位符的形式,提高效率。可以防止sql注入等等问题。#方式一般用于传入添加，修改的值或查询，删除的where条件 id值
-
-select * from t_user where name = #{param}
-
-(2)$只是只是简单的字符串拼接，要特别小心sql注入问题，对应非变量部分，只能用$。$方式一般用于传入数据库对象，比如这种group by 字段 ,order by 字段，表名，字段名等没法使用占位符的就需要使用${}
-
-select count(* ), from t_user group by ${param}
-
-（3）能同时使用#和$的时候，最好用#。
+拼接sql
+
+Statement
+PrepareStatement
+
+hibernate
+:name setstring(name,value)
+?  setstring(0,value)
+
+Mybatis
+
+#
+$
+（1）变量的传递，必须使用#，使用#{}就等于使用了PrepareStatement这种占位符的形式,提高效率。可以防止sql注入等等问题。#方式一般用于传入添加，修改的值或查询，删除的where条件 id值
+
+select * from t_user where name = #{param}
+
+(2)$只是只是简单的字符串拼接，要特别小心sql注入问题，对应非变量部分，只能用$。$方式一般用于传入数据库对象，比如这种group by 字段 ,order by 字段，表名，字段名等没法使用占位符的就需要使用${}
+
+select count(* ), from t_user group by ${param}
+
+（3）能同时使用#和$的时候，最好用#。
diff --git "a/06 - DB (mysql)/Mysql/\344\270\244\350\241\250\350\201\224\350\241\250\344\274\230\345\214\226.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\344\270\244\350\241\250\350\201\224\350\241\250\344\274\230\345\214\226.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/\344\270\244\350\241\250\350\201\224\350\241\250\344\274\230\345\214\226.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\344\270\244\350\241\250\350\201\224\350\241\250\344\274\230\345\214\226.md"
diff --git "a/06 - DB (mysql)/Mysql/\345\206\205\345\244\226\351\223\276\346\216\245.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\345\206\205\345\244\226\351\223\276\346\216\245.md"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/\345\206\205\345\244\226\351\223\276\346\216\245.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\345\206\205\345\244\226\351\223\276\346\216\245.md"
diff --git "a/06 - DB (mysql)/Mysql/\345\257\206\347\240\201\351\231\220\345\210\266.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\345\257\206\347\240\201\351\231\220\345\210\266.txt"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/\345\257\206\347\240\201\351\231\220\345\210\266.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\345\257\206\347\240\201\351\231\220\345\210\266.txt"
diff --git "a/06 - DB (mysql)/Mysql/\350\267\250\345\237\237\350\256\277\351\227\256.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\350\267\250\345\237\237\350\256\277\351\227\256.txt"
similarity index 100%
rename from "06 - DB (mysql)/Mysql/\350\267\250\345\237\237\350\256\277\351\227\256.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/Mysql/\350\267\250\345\237\237\350\256\277\351\227\256.txt"
diff --git a/06 - DB (mysql)/RDBMS VS NoSQL.md "b/06 - DB \346\225\260\346\215\256\345\272\223/RDBMS VS NoSQL.md"
similarity index 98%
rename from 06 - DB (mysql)/RDBMS VS NoSQL.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/RDBMS VS NoSQL.md"
index f57004b0..36d9eea4 100644
--- a/06 - DB (mysql)/RDBMS VS NoSQL.md	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/RDBMS VS NoSQL.md"	
@@ -1,85 +1,85 @@
-## RDBMS
-RDBMS (Relational Database Management System) 关系型数据库管理系统。主要代表：SQL Server，Oracle，MySQL(开源)，PostgreSQL(开源)。
-  RDBMS 是 SQL  (Structured Query Language)的基础，同样也是所有现代数据库系统的基础，比如 MS SQL Server、IBM DB2、Oracle、MySQL 以及 Microsoft Access。
-  RDBMS 中的数据存储在被称为表的数据库对象中。
-  表是相关的数据项的集合，它由列和行组成。
-## NoSQL
-NoSQL（Not Only SQL）泛指非关系型数据库。主要代表：MongoDB，Redis，CouchDB。
-  用于超大规模数据的存储
-  这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。
-
-### RDBMS
-- 高度组织化结构化数据
-- 结构化查询语言（SQL） (SQL)
-- 数据和关系都存储在单独的表中。
-- 数据操纵语言，数据定义语言
-- 严格的一致性
-- 基础事务
-
-### NoSQL
-- 代表着不仅仅是SQL
-- 没有声明性查询语言
-- 没有预定义的模式
-- 键 - 值对存储，列存储，文档存储，图形数据库
-- 最终一致性，而非ACID属性
-- 非结构化和不可预知的数据
-- CAP定理
-- 高性能，高可用性和可伸缩性
-
-### NoSQL的优点/缺点
-优点:
-
-- 高可扩展性
-- 分布式计算
-- 低成本
-- 架构的灵活性，半结构化数据
-- 没有复杂的关系
-缺点:
-
-- 没有标准化
-- 有限的查询功能（到目前为止）
-- 最终一致是不直观的程序
-
-### CAP定理（CAP theorem）
-在计算机科学中, CAP定理（CAP theorem）, 又被称作 布鲁尔定理（Brewer's theorem）, 它指出对于一个分布式计算系统来说，`不可能同时满足以下三点`:
-
-`一致性(Consistency)` (所有节点在同一时间具有相同的数据)
-`可用性(Availability)` (保证每个请求不管成功或者失败都有响应)
-`分隔容忍(Partition tolerance)` (系统中任意信息的丢失或失败不会影响系统的继续运作)
-CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，`最多只能同时较好的满足两个`。
-
-因此，根据 CAP 原理将 `NoSQL` 数据库分成了满足 `CA` 原则、满足 `CP` 原则和满足 `AP` 原则三 大类：
-
-`CA` - 单点集群，满足一致性，可用性的系统，通常在可扩展性上不太强大。
-`CP` - 满足一致性，分区容忍性的系统，通常性能不是特别高。
-`AP` - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。
-
-### BASE
-BASE：Basically Available, Soft-state, Eventually Consistent。 由 Eric Brewer 定义。
-CAP理论的核心是：一个分布式系统不可能同时很好的满足`一致性，可用性和分区容错性`这三个需求，最多只能同时较好的满足两个。
-BASE是NoSQL数据库通常对可用性及一致性的弱要求原则:
-
-`Basically Availble` --基本可用
-`Soft-state --软状态/柔性事务。` "Soft state" 可以理解为"无连接"的, 而 "Hard state" 是"面向连接"的
-`Eventual Consistency` -- 最终一致性， 也是是 ACID 的最终目的。
-
-### ACID vs BASE
-ACID	                 BASE
-原子性(Atomicity)	   基本可用(Basically Available)
-一致性(Consistency)	 软状态/柔性事务(Soft state)
-隔离性(Isolation)     最终一致性 (Eventual consistency)
-持久性 (Durable)	 
-
-## NoSQL 数据库分类
-类型	                           部分代表                   特点
-`列存储`               `Hbase` `Cassandra` `Hypertable`      顾名思义，是按列存储数据的。最大的特点是方便`存储结构化`和`半结构化`数据，方便做数据`压缩`，对针对`某一列`或者某`几列`的查询有非常大的`IO`优势。
-
-`文档存储`          `MongoDB` `CouchDB`                      文档存储一般用类似`json`的格式存储，存储的内容是文档型的。这样也就有有机会对某些字段建立索引，实现关系数据库的某些功能。
-
-`key-value存储`     `Tokyo Cabinet` / `Tyrant`  `Berkeley DB` `MemcacheDB`  `Redis` 可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能）
-
-`图存储`           `Neo4J`   `FlockDB`                       图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。
-
-`对象存储`          `db4o`  `Versant`                        通过类似`面向对象语言`的语法操作数据库，通过对象的方式存取数据。
-
-`xml数据库`         `Berkeley DB XML`  `BaseX`               高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。
+## RDBMS
+RDBMS (Relational Database Management System) 关系型数据库管理系统。主要代表：SQL Server，Oracle，MySQL(开源)，PostgreSQL(开源)。
+  RDBMS 是 SQL  (Structured Query Language)的基础，同样也是所有现代数据库系统的基础，比如 MS SQL Server、IBM DB2、Oracle、MySQL 以及 Microsoft Access。
+  RDBMS 中的数据存储在被称为表的数据库对象中。
+  表是相关的数据项的集合，它由列和行组成。
+## NoSQL
+NoSQL（Not Only SQL）泛指非关系型数据库。主要代表：MongoDB，Redis，CouchDB。
+  用于超大规模数据的存储
+  这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。
+
+### RDBMS
+- 高度组织化结构化数据
+- 结构化查询语言（SQL） (SQL)
+- 数据和关系都存储在单独的表中。
+- 数据操纵语言，数据定义语言
+- 严格的一致性
+- 基础事务
+
+### NoSQL
+- 代表着不仅仅是SQL
+- 没有声明性查询语言
+- 没有预定义的模式
+- 键 - 值对存储，列存储，文档存储，图形数据库
+- 最终一致性，而非ACID属性
+- 非结构化和不可预知的数据
+- CAP定理
+- 高性能，高可用性和可伸缩性
+
+### NoSQL的优点/缺点
+优点:
+
+- 高可扩展性
+- 分布式计算
+- 低成本
+- 架构的灵活性，半结构化数据
+- 没有复杂的关系
+缺点:
+
+- 没有标准化
+- 有限的查询功能（到目前为止）
+- 最终一致是不直观的程序
+
+### CAP定理（CAP theorem）
+在计算机科学中, CAP定理（CAP theorem）, 又被称作 布鲁尔定理（Brewer's theorem）, 它指出对于一个分布式计算系统来说，`不可能同时满足以下三点`:
+
+`一致性(Consistency)` (所有节点在同一时间具有相同的数据)
+`可用性(Availability)` (保证每个请求不管成功或者失败都有响应)
+`分隔容忍(Partition tolerance)` (系统中任意信息的丢失或失败不会影响系统的继续运作)
+CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，`最多只能同时较好的满足两个`。
+
+因此，根据 CAP 原理将 `NoSQL` 数据库分成了满足 `CA` 原则、满足 `CP` 原则和满足 `AP` 原则三 大类：
+
+`CA` - 单点集群，满足一致性，可用性的系统，通常在可扩展性上不太强大。
+`CP` - 满足一致性，分区容忍性的系统，通常性能不是特别高。
+`AP` - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。
+
+### BASE
+BASE：Basically Available, Soft-state, Eventually Consistent。 由 Eric Brewer 定义。
+CAP理论的核心是：一个分布式系统不可能同时很好的满足`一致性，可用性和分区容错性`这三个需求，最多只能同时较好的满足两个。
+BASE是NoSQL数据库通常对可用性及一致性的弱要求原则:
+
+`Basically Availble` --基本可用
+`Soft-state --软状态/柔性事务。` "Soft state" 可以理解为"无连接"的, 而 "Hard state" 是"面向连接"的
+`Eventual Consistency` -- 最终一致性， 也是是 ACID 的最终目的。
+
+### ACID vs BASE
+ACID	                 BASE
+原子性(Atomicity)	   基本可用(Basically Available)
+一致性(Consistency)	 软状态/柔性事务(Soft state)
+隔离性(Isolation)     最终一致性 (Eventual consistency)
+持久性 (Durable)	 
+
+## NoSQL 数据库分类
+类型	                           部分代表                   特点
+`列存储`               `Hbase` `Cassandra` `Hypertable`      顾名思义，是按列存储数据的。最大的特点是方便`存储结构化`和`半结构化`数据，方便做数据`压缩`，对针对`某一列`或者某`几列`的查询有非常大的`IO`优势。
+
+`文档存储`          `MongoDB` `CouchDB`                      文档存储一般用类似`json`的格式存储，存储的内容是文档型的。这样也就有有机会对某些字段建立索引，实现关系数据库的某些功能。
+
+`key-value存储`     `Tokyo Cabinet` / `Tyrant`  `Berkeley DB` `MemcacheDB`  `Redis` 可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能）
+
+`图存储`           `Neo4J`   `FlockDB`                       图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。
+
+`对象存储`          `db4o`  `Versant`                        通过类似`面向对象语言`的语法操作数据库，通过对象的方式存取数据。
+
+`xml数据库`         `Berkeley DB XML`  `BaseX`               高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。
diff --git a/06 - DB (mysql)/README.md "b/06 - DB \346\225\260\346\215\256\345\272\223/README.md"
similarity index 100%
rename from 06 - DB (mysql)/README.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/README.md"
diff --git a/06 - DB (mysql)/SQL.md "b/06 - DB \346\225\260\346\215\256\345\272\223/SQL.md"
similarity index 100%
rename from 06 - DB (mysql)/SQL.md
rename to "06 - DB \346\225\260\346\215\256\345\272\223/SQL.md"
diff --git a/06 - DB (mysql)/img/dxfl1.jpg "b/06 - DB \346\225\260\346\215\256\345\272\223/img/dxfl1.jpg"
similarity index 100%
rename from 06 - DB (mysql)/img/dxfl1.jpg
rename to "06 - DB \346\225\260\346\215\256\345\272\223/img/dxfl1.jpg"
diff --git a/06 - DB (mysql)/img/dxfl2.png "b/06 - DB \346\225\260\346\215\256\345\272\223/img/dxfl2.png"
similarity index 100%
rename from 06 - DB (mysql)/img/dxfl2.png
rename to "06 - DB \346\225\260\346\215\256\345\272\223/img/dxfl2.png"
diff --git "a/06 - DB (mysql)/sql\345\215\225\345\274\225\345\217\267.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/sql\345\215\225\345\274\225\345\217\267.md"
similarity index 100%
rename from "06 - DB (mysql)/sql\345\215\225\345\274\225\345\217\267.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/sql\345\215\225\345\274\225\345\217\267.md"
diff --git a/06 - DB (mysql)/uuidtest.py "b/06 - DB \346\225\260\346\215\256\345\272\223/uuidtest.py"
similarity index 97%
rename from 06 - DB (mysql)/uuidtest.py
rename to "06 - DB \346\225\260\346\215\256\345\272\223/uuidtest.py"
index b09dcac9..051b7f3d 100644
--- a/06 - DB (mysql)/uuidtest.py	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/uuidtest.py"	
@@ -1,38 +1,38 @@
-# -*- coding: UTF-8 -*-
-import random as r
-import uuid
-import MySQLdb
-import time
-
-first=('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S')
-middle=('a','b','c','d','e','f','g','h','i')
-last=('1','2','3','4','5','6','7','8','9','10','11','12')
-
-#first=('张','王','李','赵','金','艾','单','龚','钱','周','吴','郑','孔','曺','严','华','吕','徐','何')
-#middle=('芳','军','建','明','辉','芬','红','丽','功')
-#last=('明','芳','民','敏','丽','辰','楷','龙','雪','凡','锋','芝')
-
-conn = MySQLdb.connect(host='127.0.0.1', port=33060, user='root', passwd='kdc',db='vas')
-
-for i in range(10000):
-  name1=r.choice(first)+r.choice(middle)+r.choice(last)
-  suuid1 = ''.join(str(uuid.uuid4()).split('-'))
-  cur1 = conn.cursor()
-  cur1.execute("select GroupID from GroupStdTree where GroupTreeID = 'defaultcbaa5c3d2394438db3c3480fc'")
-  data=cur1.fetchall()
-  GroupID=[]
-  if data:
-    for rec in data:
-      GroupID.append(rec[0])
-  cur1.close()
-  suuid2 = r.choice(GroupID)
-  print i
-  print name1
-  print suuid1 +" "+ suuid2
-  cur2 = conn.cursor()
-  cur2.execute("insert into GroupStdTree (`GroupID`, `ParentGroupID`, `GroupTreeID`, `PlatGroupID`, `PlatParentGroupID`, `GroupName`, `SyncRoundNum`) SELECT %s, %s, 'defaultcbaa5c3d2394438db3c3480fc', %s, %s, %s,3 ;",(suuid1,suuid2,suuid1,suuid2,name1))
-  conn.commit()
-  cur2.callproc('VAS_PROC_GROUP_PLAT_BIN_GROUP_AddNode',(suuid1,suuid2,3,'defaultcbaa5c3d2394438db3c3480fc','cbaa5c3d2394438db3c3480fc2da3d2c'))
-  cur2.close()
-
-conn.close()
+# -*- coding: UTF-8 -*-
+import random as r
+import uuid
+import MySQLdb
+import time
+
+first=('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S')
+middle=('a','b','c','d','e','f','g','h','i')
+last=('1','2','3','4','5','6','7','8','9','10','11','12')
+
+#first=('张','王','李','赵','金','艾','单','龚','钱','周','吴','郑','孔','曺','严','华','吕','徐','何')
+#middle=('芳','军','建','明','辉','芬','红','丽','功')
+#last=('明','芳','民','敏','丽','辰','楷','龙','雪','凡','锋','芝')
+
+conn = MySQLdb.connect(host='127.0.0.1', port=33060, user='root', passwd='kdc',db='vas')
+
+for i in range(10000):
+  name1=r.choice(first)+r.choice(middle)+r.choice(last)
+  suuid1 = ''.join(str(uuid.uuid4()).split('-'))
+  cur1 = conn.cursor()
+  cur1.execute("select GroupID from GroupStdTree where GroupTreeID = 'defaultcbaa5c3d2394438db3c3480fc'")
+  data=cur1.fetchall()
+  GroupID=[]
+  if data:
+    for rec in data:
+      GroupID.append(rec[0])
+  cur1.close()
+  suuid2 = r.choice(GroupID)
+  print i
+  print name1
+  print suuid1 +" "+ suuid2
+  cur2 = conn.cursor()
+  cur2.execute("insert into GroupStdTree (`GroupID`, `ParentGroupID`, `GroupTreeID`, `PlatGroupID`, `PlatParentGroupID`, `GroupName`, `SyncRoundNum`) SELECT %s, %s, 'defaultcbaa5c3d2394438db3c3480fc', %s, %s, %s,3 ;",(suuid1,suuid2,suuid1,suuid2,name1))
+  conn.commit()
+  cur2.callproc('VAS_PROC_GROUP_PLAT_BIN_GROUP_AddNode',(suuid1,suuid2,3,'defaultcbaa5c3d2394438db3c3480fc','cbaa5c3d2394438db3c3480fc2da3d2c'))
+  cur2.close()
+
+conn.close()
diff --git "a/06 - DB (mysql)/\345\210\206\345\272\223\345\210\206\350\241\250(sharding).md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\345\210\206\345\272\223\345\210\206\350\241\250-\344\270\255\351\227\264\344\273\266(sharding).md"
similarity index 100%
rename from "06 - DB (mysql)/\345\210\206\345\272\223\345\210\206\350\241\250(sharding).md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\345\210\206\345\272\223\345\210\206\350\241\250-\344\270\255\351\227\264\344\273\266(sharding).md"
diff --git "a/06 - DB (mysql)/\345\270\270\347\224\250\350\257\255\345\217\245" "b/06 - DB \346\225\260\346\215\256\345\272\223/\345\270\270\347\224\250\350\257\255\345\217\245"
similarity index 100%
rename from "06 - DB (mysql)/\345\270\270\347\224\250\350\257\255\345\217\245"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\345\270\270\347\224\250\350\257\255\345\217\245"
diff --git "a/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/Mysql\347\264\242\345\274\225\350\277\233\351\230\266\345\205\245\351\227\250.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/Mysql\347\264\242\345\274\225\350\277\233\351\230\266\345\205\245\351\227\250.md"
new file mode 100644
index 00000000..69d53f34
--- /dev/null
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/Mysql\347\264\242\345\274\225\350\277\233\351\230\266\345\205\245\351\227\250.md"	
@@ -0,0 +1,110 @@
+Mysql索引进阶入门
+### 1. 索引操作
+[MySQL 索引 菜鸟](https://www.runoob.com/mysql/mysql-index.html)
+
+### 2. 索引类型
+
+* **PRIMARY**
+    唯一且不能为空；一张表只能有一个主键索引  
+* **INDEX**
+		普通索引
+* **UNIQUE**
+		唯一性索引
+* **FULLTEXT**
+		全文索引：用于搜索很长一篇文章的时候，效果最好。用在比较短的文本，如果就一两行字的，普通的 INDEX 也可以
+
+### 3. 聚集索引 VS 非聚集索引
+
+#### 3.1 区别
+	* 聚集索引：主键索引，索引中键值的逻辑顺序决定了表中相应行的物理顺序
+	* 非聚集索引(非主键索引，也称二级索引)：除主键索引（普通索引、唯一索引、全文索引），索引的逻辑顺序与磁盘上行的物理存储顺序不同
+
+  查询过程：
+  * 查询聚集索引能直接得到所有数据，
+  * 查非聚集索引需要先得到聚集索引地址，**回表** 再得到数据。
+
+#### 3.1 聚集索引规则
+  1. 如果一个主键被定义了，那么这个主键就是作为聚集索引
+  2. 如果没有主键被定义，那么该表的第一个唯一非空索引被作为聚集索引
+  3. 如果没有主键也没有合适的唯一索引，那么innodb内部会生成一个隐藏的主键作为聚集索引，这个隐藏的主键是一个6个字节的列，改列的值会随着数据的插入自增。
+
+### 4 索引结构
+  默认 ```B+Tree```, ```Hash```(key-value的插入以及查询，哈希表的时间复杂度都是O(1)，如果不需要有序的遍历数据，哈希表性能最好。)
+
+  B+树 由二叉树演变的m阶树
+
+  为什么是B+树（配合磁盘的读写特性，减少单次查询的磁盘访问次数。）
+
+#### 4.1 B+树特点
+  ———— [极客时间 数据结构与算法之美](https://time.geekbang.org/column/article/77830)
+  * 每个节点中子节点的个数不能超过 m，也不能小于 m/2；
+  * 根节点的子节点个数可以不超过 m/2，这是一个例外；
+  * m 叉树只存储索引，并不真正存储数据，这个有点儿类似跳表；
+  * 通过链表将叶子节点串联在一起，这样可以方便按区间查找；
+  * 一般情况，根节点会被存储在内存中，其他节点存储在磁盘中。
+
+  **复杂度**
+  * 所有操作（查、插、删） 时间复杂度 O(logm(N))，
+  * 空间复杂度 最差 O(n)
+
+#### 4.2 **m阶怎么计算来？**
+
+  操作系统按页读取（默认是4k或者8k），为了提高I/O效率，所以一个索引页和操作系统读取空间保持一致。
+
+  ```
+  m = 数据页大小/索引项大小
+  ```
+  所以索引项字段占空空间越小（int 4byte，比bigint 8byte少一半），一页存的索引数据越多，在优化的时候也要考虑索引字段的长度。
+
+  子节点是 **双向链表** 结构，方便范围查询及排序。
+
+  考虑:
+    1000万数据,树有多高？
+
+### 5. 覆盖索引
+  ```sql
+  select 主键 from table where 普通索引字段 = ** ;
+  ```
+  覆盖索引```概念```：通过索引直接插到结果，不需要回表操作。
+
+  例子：身份证号 和 姓名
+
+  如果要根据身份证号查询信息，只要在身份证上建立索引，需要建[身份证、姓名] 组合索引吗？
+
+  如果有身份证号查询姓名的高频查询，则建立上边的组合索引，则可达到覆盖索引，不需要回表查到整行数据，减少执行时间。
+
+
+### 6. 最左前缀原则
+  两个概念：
+  * 这个最左前缀可以是 **组合索引的最左N个字段**
+  * 也可以是 **字符串索引的最左M个字符**。
+
+  建立组合索引（a,b,c）相当于建立了 (a,b,c) (a,b) (a,c) (a) 四个索引
+
+  只要能匹配到最左N个字段，则能使用索引。  如 [a,b,c] [a,c] [a,b] [a] 都能触发索引，内部顺序可变，mysql自动调整。
+
+  字符串索引
+  最左M个字符：如like x% ok, %x，%x% 不行。
+
+### 7. 索引下推
+  MySQL 5.6 引入的索引下推优化（index condition pushdown)
+
+  可以在索引遍历过程中，对索引中包含的字段先做判断，直接过滤掉不满足条件的记录，减少回表次数。
+
+### 8. 索引是否生效，优化
+  可以使用 EXPLAIN 来分析索引是否起效，慢sql做一些索引优化 [Explain优化查询检测](https://www.runoob.com/w3cnote/mysql-index.html)
+
+
+  * 索引字段为int类型时，条件可用' '包起来 也可以直接是数值比较
+  * 索引字段为varchar类型时，条件要使用' '包起来
+
+  * 能触发range范围索引  >,<, not in , in , != ,BETWEEN AND （5.5后版本 ）
+
+### 9. 常用索引命名规范
+  ```
+  唯一 uk_[字段名]_[字段名]...
+  普通 idx_[字段名]_[字段名]...
+  ```
+
+  [github]([https://github.com/loveincode](https://github.com/loveincode/notes))
+  [blog](https://loveincode.cnblogs.com/)
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\344\275\277\347\224\250\345\216\237\345\210\231.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\344\275\277\347\224\250\345\216\237\345\210\231.txt"
similarity index 100%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\344\275\277\347\224\250\345\216\237\345\210\231.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\344\275\277\347\224\250\345\216\237\345\210\231.txt"
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225.md"
similarity index 100%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225.md"
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225.txt"
similarity index 100%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225.txt"
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\245\275\345\244\204\344\270\216\345\274\212\347\253\257.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\245\275\345\244\204\344\270\216\345\274\212\347\253\257.md"
similarity index 99%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\245\275\345\244\204\344\270\216\345\274\212\347\253\257.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\245\275\345\244\204\344\270\216\345\274\212\347\253\257.md"
index 1daa2f2f..95c38787 100644
--- "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\245\275\345\244\204\344\270\216\345\274\212\347\253\257.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\245\275\345\244\204\344\270\216\345\274\212\347\253\257.md"	
@@ -1,47 +1,47 @@
-### 索引的优点：
-
-1、索引能够提高数据检索的效率，降低数据库的IO成本。
-
-2、索引还有一个非常重要的用途，就是降低数据的排序成本。
-
-  每个索引中的索引数据都是按照索引键值进行排序后存放的，所以，当我们的query语句中包含排序分组操作的时候，如果我们的排序字段和索引字段刚好一致，MySQL Query Optimizer就会告诉mysqld在取得数据后不用排序了。
-
-  分组操作没办法直接利用索引完成，但是分组操作是需要先进行排序后才分组的，所以如果Query包含这些操作，那么分组操作就省去了排序的过程。
-
-排序分组操作主要消耗的是我们的内存和 CPU 资源,如果我们能够在进行排序分组操作中利用好索引,将会极大的降低 CPU 资源的消耗。
-
-### 索引的弊端：
-
-1、需要增加IO和调整索引所计算的量。索引占用存储空间，随着table数据里增长，索引数据量也会增长，带来存储空间的消耗。
-
-
-### 一、为什么要创建索引呢（优点）？
-这是因为，创建索引可以大大提高系统的性能。
-第一，   通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
-第二，   可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
-第三，   可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
-第四，   在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
-第五，   通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
-
-### 二、建立方向索引的不利因素（缺点）
-也许会有人要问：增加索引有如此多的优点，为什么不对表中的每一个列创建一个索引呢？这种想法固然有其合理性，然而也有其片面性。虽然，索引有许多优点，但是，为表中的每一个列都增加索引，是非常不明智的。这是因为，增加索引也有许多不利的一个方面。
-
-第一，   创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
-第二，   索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
-第三，   当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
-
-### 三、创建方向索引的准则
-索引是建立在数据库表中的某些列的上面。因此，在创建索引的时候，应该仔细考虑在哪些列上可以创建索引，在哪些列上不能创建索引。
-一般来说，应该在这些列上创建索引。
-第一，   在经常需要搜索的列上，可以加快搜索的速度；
-第二，   在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构；
-第三，   在经常用在连接的列上，这些列主要是一些外键，可以加快连接的速度；
-第四，   在经常需要根据范围进行搜索的列上创建索引，因为索引已经排序，其指定的范围是连续的；
-第五，   在经常需要排序的列上创建索引，因为索引已经排序，这样查询可以利用索引的排序，加快排序查询时间；
-第六，   在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。
-
-同样，对于有些列不应该创建索引。一般来说，不应该创建索引的的这些列具有下列特点：
-第一，             对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为，既然这些列很少使用到，因此有索引或者无索引，并不能提高查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。
-第二，             对于那些只有很少数据值的列也不应该增加索引。这是因为，由于这些列的取值很少，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即需要在表中搜索的数据行的比例很大。增加索引，并不能明显加快检索速度。
-第三，             对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少。
-第四，             当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改性能远远大于检索性能时，不应该创建索引。
+### 索引的优点：
+
+1、索引能够提高数据检索的效率，降低数据库的IO成本。
+
+2、索引还有一个非常重要的用途，就是降低数据的排序成本。
+
+  每个索引中的索引数据都是按照索引键值进行排序后存放的，所以，当我们的query语句中包含排序分组操作的时候，如果我们的排序字段和索引字段刚好一致，MySQL Query Optimizer就会告诉mysqld在取得数据后不用排序了。
+
+  分组操作没办法直接利用索引完成，但是分组操作是需要先进行排序后才分组的，所以如果Query包含这些操作，那么分组操作就省去了排序的过程。
+
+排序分组操作主要消耗的是我们的内存和 CPU 资源,如果我们能够在进行排序分组操作中利用好索引,将会极大的降低 CPU 资源的消耗。
+
+### 索引的弊端：
+
+1、需要增加IO和调整索引所计算的量。索引占用存储空间，随着table数据里增长，索引数据量也会增长，带来存储空间的消耗。
+
+
+### 一、为什么要创建索引呢（优点）？
+这是因为，创建索引可以大大提高系统的性能。
+第一，   通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
+第二，   可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
+第三，   可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
+第四，   在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
+第五，   通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
+
+### 二、建立方向索引的不利因素（缺点）
+也许会有人要问：增加索引有如此多的优点，为什么不对表中的每一个列创建一个索引呢？这种想法固然有其合理性，然而也有其片面性。虽然，索引有许多优点，但是，为表中的每一个列都增加索引，是非常不明智的。这是因为，增加索引也有许多不利的一个方面。
+
+第一，   创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
+第二，   索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
+第三，   当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
+
+### 三、创建方向索引的准则
+索引是建立在数据库表中的某些列的上面。因此，在创建索引的时候，应该仔细考虑在哪些列上可以创建索引，在哪些列上不能创建索引。
+一般来说，应该在这些列上创建索引。
+第一，   在经常需要搜索的列上，可以加快搜索的速度；
+第二，   在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构；
+第三，   在经常用在连接的列上，这些列主要是一些外键，可以加快连接的速度；
+第四，   在经常需要根据范围进行搜索的列上创建索引，因为索引已经排序，其指定的范围是连续的；
+第五，   在经常需要排序的列上创建索引，因为索引已经排序，这样查询可以利用索引的排序，加快排序查询时间；
+第六，   在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。
+
+同样，对于有些列不应该创建索引。一般来说，不应该创建索引的的这些列具有下列特点：
+第一，             对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为，既然这些列很少使用到，因此有索引或者无索引，并不能提高查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。
+第二，             对于那些只有很少数据值的列也不应该增加索引。这是因为，由于这些列的取值很少，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即需要在表中搜索的数据行的比例很大。增加索引，并不能明显加快检索速度。
+第三，             对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少。
+第四，             当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改性能远远大于检索性能时，不应该创建索引。
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\344\273\245\345\217\212\345\246\202\344\275\225\344\275\277\347\224\250.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\344\273\245\345\217\212\345\246\202\344\275\225\344\275\277\347\224\250.md"
similarity index 97%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\344\273\245\345\217\212\345\246\202\344\275\225\344\275\277\347\224\250.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\344\273\245\345\217\212\345\246\202\344\275\225\344\275\277\347\224\250.md"
index 737a7e74..cc08a6c2 100644
--- "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\344\273\245\345\217\212\345\246\202\344\275\225\344\275\277\347\224\250.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\347\264\242\345\274\225\347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\344\273\245\345\217\212\345\246\202\344\275\225\344\275\277\347\224\250.md"	
@@ -1,131 +1,131 @@
-https://blog.csdn.net/u013400939/article/details/72869319
-
-唯一的是什么？
-
-  1. 索引列（字段）的所有值都只能出现一次，即必须唯一
-
---------------------------------------------------------------------------------
-
-主键索引与唯一索引的区别
-
-  1. 主键是一种约束，唯一索引是一种索引，两者在本质上是不同的。
-
-  2. 主键创建后一定包含一个唯一性索引，唯一性索引并不一定就是主键。
-
-  3. 唯一性索引列允许空值，而主键列不允许为空值。
-
-  4. 主键列在创建时，已经默认为空值 ++    唯一索引了。
-
-  5. 一个表最多只能创建一个主键，但可以创建多个唯一索引。
-
-  6. 主键更适合那些不容易更改的唯一标识，如自动递增列、身份证号等。
-
-  7. 主键可以被其他表引用为外键，而唯一索引不能。   ？
-
---------------------------------------------------------------------------------
-
-复合索引
-
-  1. 用户可以在多个列上建立索引，这种索引叫做复合索引(组合索引)。
-
-  2. 就是几个字段联合在一起组成一个索引.复合索引的创建方法与创建单一索引的方法完全一样。
-
-  3. 但复合索引在数据库操作期间所需的开销更小，可以代替多个单一索引。
-
-  4. 当表的行数远远大于索引键的数目时，使用这种方式可以明显加快表的查询速度。
-
---------------------------------------------------------------------------------
-
-（abc） （ab） （ac）（bc）（a） （b） （c）
-
-  1. 复合索引又叫联合索引。
-
-  2. abc    ab    a     ac  可以
-
-  3. 对于复合索引:Mysql从左到右的使用索引中的字段，一个查询可以只使用索引中的一部份，但只能是最左侧部分。
-
-  4. 例如索引是key index (a,b,c). 可以支持a | a,b| a,b,c 3种组合进行查找，但不支持 b,c进行查找 ,当最左侧字段是常量引用时，索引就十分有效。
-
---------------------------------------------------------------------------------
-
-除复合索引外，什么情况下索引被使用，什么情况下不会被使用
-
-  1. 建立索引的目的就是帮助查询,如果查寻用不到则索引就没有必要建立。
-
-  2. 如果表是经常需要更新的也不适合做索引 。频繁更新会导致索引也会频繁更新，降低写的效率。
-
-  3. 唯一性差的字段不适合创建索引。
-
-  4. 当给一个字段创建了索引的话，而这个字段要进行like模糊查询的话，那么这个值左边不可以有%，因为索引查询是要从左到右的，你如果给它加上%后，左边的值不是确定的话，它会找不到这个索引。所以在使用like模糊查询的时候，值得左边不可以有%。
-
-  5. order by  不会使用索引
-
-  6. or 当前后2个字段都有索引时才可以索引出来 否则不可以。
-
-  7. 如果数据表过大(5w以上)则有些字段(字符型长度超过(40))不适合作为索引。查询大量数据时,索引有效,但是慢
-
-  8. 不使用索引的原因：因为索引时会先过一遍索引在过一遍数据
-
---------------------------------------------------------------------------------
-
-全文检索：
-
-  1. 全文检索就是FULLTEXT，用于 MyISAM 表，在列类型为 CHAR、VARCHAR 或 TEXT 列上创建。
-
-  2. 将数据装载到一个没有 FULLTEXT 索引的表中，然后再使用 ALTER TABLE (或 CREATE INDEX) 创建索引，这将是非常快的。
-
-  3. 将数据装载到一个已经有 FULLTEXT 索引的表中，将是非常慢的。
-
-  4. MySQL自带的全文索引只能对英文进行全文检索。要检索中文用sphinx。
-
-  5. 创建全文检索：alter table 表名 add fulltext index 索引名(列名,[列名]，[列名]..（可以有多个，可以有一个）
-
-  6. 在创建表的时候建全文检索：CREATE TABLE article (
-
-  7.      id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
-
-  8.      FULLTEXT (title, content) --在title和content列上创建全文索引
-
-);
-
---------------------------------------------------------------------------------
-
-场景
-
-  1. 当数据多且字段值有相同的值得时候用普通索引。
-
-  2. 当字段多且字段值没有重复的时候用唯一索引。
-
-  3. 当有多个字段名都经常被查询的话用复合索引。
-
-  4. 普通索引不支持空值，唯一索引支持空值。
-
-  5. 但是，若是这张表增删改多而查询较少的话，就不要创建索引了，因为如果你给一列创建了索引，那么对该列进行增删改的时候，都会先访问这一列的索引，
-
-  6. 若是增，则在这一列的索引内以新填入的这个字段名的值为名创建索引的子集，
-
-  7. 若是改，则会把原来的删掉，再添入一个以这个字段名的新值为名创建索引的子集，
-
-  8. 若是删，则会把索引中以这个字段为名的索引的子集删掉。
-
-  9. 所以，会对增删改的执行减缓速度，
-
-  10. 所以，若是这张表增删改多而查询较少的话，就不要创建索引了。
-
-  11. 更新太频繁地字段不适合创建索引。
-
-  12. 不会出现在where条件中的字段不该建立索引。
-
---------------------------------------------------------------------------------
-
-索引创建
-
-CREATE [UNIQUE|CLUSTERED] INDEX INDEX_NAME ON TABLE_NAME(PROPERTY_NAME)；
-
-其中UNIQUE和CLUSTERED为可选项，分别是建立唯一索引和聚簇索引，具体解释为：
-
-UNIQUE:表示此索引的每一个索引值只对应唯一的数据。
-
-CLUSTERED:表示要建立的索引时聚簇索引，即索引项的顺序与表中记录的物理顺序一致的索引组织
-
-ALTER TABLE table_name ADD INDEX index_name (column_list)
+https://blog.csdn.net/u013400939/article/details/72869319
+
+唯一的是什么？
+
+  1. 索引列（字段）的所有值都只能出现一次，即必须唯一
+
+--------------------------------------------------------------------------------
+
+主键索引与唯一索引的区别
+
+  1. 主键是一种约束，唯一索引是一种索引，两者在本质上是不同的。
+
+  2. 主键创建后一定包含一个唯一性索引，唯一性索引并不一定就是主键。
+
+  3. 唯一性索引列允许空值，而主键列不允许为空值。
+
+  4. 主键列在创建时，已经默认为空值 ++    唯一索引了。
+
+  5. 一个表最多只能创建一个主键，但可以创建多个唯一索引。
+
+  6. 主键更适合那些不容易更改的唯一标识，如自动递增列、身份证号等。
+
+  7. 主键可以被其他表引用为外键，而唯一索引不能。   ？
+
+--------------------------------------------------------------------------------
+
+复合索引
+
+  1. 用户可以在多个列上建立索引，这种索引叫做复合索引(组合索引)。
+
+  2. 就是几个字段联合在一起组成一个索引.复合索引的创建方法与创建单一索引的方法完全一样。
+
+  3. 但复合索引在数据库操作期间所需的开销更小，可以代替多个单一索引。
+
+  4. 当表的行数远远大于索引键的数目时，使用这种方式可以明显加快表的查询速度。
+
+--------------------------------------------------------------------------------
+
+（abc） （ab） （ac）（bc）（a） （b） （c）
+
+  1. 复合索引又叫联合索引。
+
+  2. abc    ab    a     ac  可以
+
+  3. 对于复合索引:Mysql从左到右的使用索引中的字段，一个查询可以只使用索引中的一部份，但只能是最左侧部分。
+
+  4. 例如索引是key index (a,b,c). 可以支持a | a,b| a,b,c 3种组合进行查找，但不支持 b,c进行查找 ,当最左侧字段是常量引用时，索引就十分有效。
+
+--------------------------------------------------------------------------------
+
+除复合索引外，什么情况下索引被使用，什么情况下不会被使用
+
+  1. 建立索引的目的就是帮助查询,如果查寻用不到则索引就没有必要建立。
+
+  2. 如果表是经常需要更新的也不适合做索引 。频繁更新会导致索引也会频繁更新，降低写的效率。
+
+  3. 唯一性差的字段不适合创建索引。
+
+  4. 当给一个字段创建了索引的话，而这个字段要进行like模糊查询的话，那么这个值左边不可以有%，因为索引查询是要从左到右的，你如果给它加上%后，左边的值不是确定的话，它会找不到这个索引。所以在使用like模糊查询的时候，值得左边不可以有%。
+
+  5. order by  不会使用索引
+
+  6. or 当前后2个字段都有索引时才可以索引出来 否则不可以。
+
+  7. 如果数据表过大(5w以上)则有些字段(字符型长度超过(40))不适合作为索引。查询大量数据时,索引有效,但是慢
+
+  8. 不使用索引的原因：因为索引时会先过一遍索引在过一遍数据
+
+--------------------------------------------------------------------------------
+
+全文检索：
+
+  1. 全文检索就是FULLTEXT，用于 MyISAM 表，在列类型为 CHAR、VARCHAR 或 TEXT 列上创建。
+
+  2. 将数据装载到一个没有 FULLTEXT 索引的表中，然后再使用 ALTER TABLE (或 CREATE INDEX) 创建索引，这将是非常快的。
+
+  3. 将数据装载到一个已经有 FULLTEXT 索引的表中，将是非常慢的。
+
+  4. MySQL自带的全文索引只能对英文进行全文检索。要检索中文用sphinx。
+
+  5. 创建全文检索：alter table 表名 add fulltext index 索引名(列名,[列名]，[列名]..（可以有多个，可以有一个）
+
+  6. 在创建表的时候建全文检索：CREATE TABLE article (
+
+  7.      id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
+
+  8.      FULLTEXT (title, content) --在title和content列上创建全文索引
+
+);
+
+--------------------------------------------------------------------------------
+
+场景
+
+  1. 当数据多且字段值有相同的值得时候用普通索引。
+
+  2. 当字段多且字段值没有重复的时候用唯一索引。
+
+  3. 当有多个字段名都经常被查询的话用复合索引。
+
+  4. 普通索引不支持空值，唯一索引支持空值。
+
+  5. 但是，若是这张表增删改多而查询较少的话，就不要创建索引了，因为如果你给一列创建了索引，那么对该列进行增删改的时候，都会先访问这一列的索引，
+
+  6. 若是增，则在这一列的索引内以新填入的这个字段名的值为名创建索引的子集，
+
+  7. 若是改，则会把原来的删掉，再添入一个以这个字段名的新值为名创建索引的子集，
+
+  8. 若是删，则会把索引中以这个字段为名的索引的子集删掉。
+
+  9. 所以，会对增删改的执行减缓速度，
+
+  10. 所以，若是这张表增删改多而查询较少的话，就不要创建索引了。
+
+  11. 更新太频繁地字段不适合创建索引。
+
+  12. 不会出现在where条件中的字段不该建立索引。
+
+--------------------------------------------------------------------------------
+
+索引创建
+
+CREATE [UNIQUE|CLUSTERED] INDEX INDEX_NAME ON TABLE_NAME(PROPERTY_NAME)；
+
+其中UNIQUE和CLUSTERED为可选项，分别是建立唯一索引和聚簇索引，具体解释为：
+
+UNIQUE:表示此索引的每一个索引值只对应唯一的数据。
+
+CLUSTERED:表示要建立的索引时聚簇索引，即索引项的顺序与表中记录的物理顺序一致的索引组织
+
+ALTER TABLE table_name ADD INDEX index_name (column_list)
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\350\257\255\346\263\225 EXPLAIN.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\350\257\255\346\263\225 EXPLAIN.txt"
similarity index 100%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\350\257\255\346\263\225 EXPLAIN.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\350\257\255\346\263\225 EXPLAIN.txt"
diff --git "a/06 - DB (mysql)/\347\264\242\345\274\225Index/\350\257\255\346\263\225 SHOW INDEX FROM.txt" "b/06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\350\257\255\346\263\225 SHOW INDEX FROM.txt"
similarity index 100%
rename from "06 - DB (mysql)/\347\264\242\345\274\225Index/\350\257\255\346\263\225 SHOW INDEX FROM.txt"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\347\264\242\345\274\225Index/\350\257\255\346\263\225 SHOW INDEX FROM.txt"
diff --git "a/06 - DB (mysql)/\350\241\250\350\277\236\346\216\245.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\350\241\250\350\277\236\346\216\245.md"
similarity index 100%
rename from "06 - DB (mysql)/\350\241\250\350\277\236\346\216\245.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\350\241\250\350\277\236\346\216\245.md"
diff --git "a/06 - DB (mysql)/\350\257\273\345\206\231\345\210\206\347\246\273.md" "b/06 - DB \346\225\260\346\215\256\345\272\223/\350\257\273\345\206\231\345\210\206\347\246\273.md"
similarity index 98%
rename from "06 - DB (mysql)/\350\257\273\345\206\231\345\210\206\347\246\273.md"
rename to "06 - DB \346\225\260\346\215\256\345\272\223/\350\257\273\345\206\231\345\210\206\347\246\273.md"
index af5e2f0f..3710d6a6 100644
--- "a/06 - DB (mysql)/\350\257\273\345\206\231\345\210\206\347\246\273.md"	
+++ "b/06 - DB \346\225\260\346\215\256\345\272\223/\350\257\273\345\206\231\345\210\206\347\246\273.md"	
@@ -1,64 +1,64 @@
-https://blog.csdn.net/itomge/article/details/6909240
-
-随着一个网站的业务不断扩展，数据不断增加，数据库的压力也会越来越大，对数据库或者SQL的基本优化可能达不到最终的效果，我们可以采用读写分离的策略来改变现状。
-
-读写分离简单的说是把对`数据库读和写的操作分开对应不同的数据库服务器`，这样能有效地减轻数据库压力，也能减轻io压力。
-
-主数据库提供写操作，从数据库提供读操作，其实在很多系统中，主要是读的操作。当主数据库进行写操作时，数据要同步到从的数据库，这样才能有效保证数据库完整性。
-
-Quest SharePlex就是比较牛的同步数据工具，听说比oracle本身的流复制还好，mysql也有自己的同步数据技术。mysql只要是通过二进制日志来复制数据。通过日志在从数据库重复主数据库的操作达到复制数据目的。这个复制比较好的就是通过异步方法，把数据同步到从数据库。
-
-采用读写分离有如下工具：
-  1. oracle的logical standby
-  2. Quest公司的SharePlex
-  3. DSG公司的RealSync
-
-主数据库同步到从数据库后，从数据库一般由多台数据库组成这样才能达到减轻压力的目的。
-
-读的操作怎么样分配到从数据库上？应该根据服务器的压力把读的操作分配到服务器，而不是简单的随机分配。mysql提供了MySQL-Proxy实现读写分离操作。不过MySQL-Proxy好像很久不更新了。oracle可以通过F5有效分配读从数据库的压力。
-
-<div align="center"> <img src="img/dxfl1.jpg" > </div>
-
-ebay的读写分离
-<div align="center"> <img src="img/dxfl2.png" > </div>
-
-
-`MySQL Replication`可以将master的数据复制分布到多个slave上，然后可以利用slave来分担master的读压力。
-
-那么对于前台应用来说，就要考虑如何将读的压力分布到多个slave上。如果每个应用都需要来实现读写分离的算法，一则成本太高，二来如果slave增加更多的机器，应用就要随之修改。明显的，如果在应用和数据库间加一个专门用于实现读写分离的中间层，则整个系统的架构拥有更好的扩展性。
-
-`MySQL Proxy`就是这么一个中间层代理，基本的原理是让主数据库处理事务性查询，而从数据库处理SELECT查询。数据库复制被用来把事务性查询导致的变更同步到集群中的从数据库。
-简单的说，MySQL Proxy就是一个连接池，负责将前台应用的连接请求转发给后台的数据库，并且通过使用lua脚本，可以实现复杂的连接控制和过滤，从而实现读写分离和负载平衡。对于应用来说，MySQL Proxy是完全透明的，应用则只需要连接到MySQL Proxy的监听端口即可。当然，这样proxy机器很可能造成单点失效，可以使用多个proxy机器做为冗余来解决这个问题，在应用服务器的连接池配置中配置到多个proxy的连接参数即可。
-
-MySQL Proxy的安装地址：http://blog.51yip.com/mysql/399.html
-
-实现读写分离的LUA脚本：
-```
-　　--
-　　-- 发送所有的非事务性Select到一个从数据库
-　　if is_in_transaction == 0 and
-　　packet:byte() == proxy.COM_QUERY and
-　　packet:sub(2, 7) == "SELECT" then
-　　local max_conns = -1
-　　local max_conns_ndx = 0
-　　for i = 1, #proxy.servers do
-　　local s = proxy.servers[i]
-　　-- 需要选择一个拥有空闲连接的从数据库
-　　if s.type == proxy.BACKEND_TYPE_RO and
-　　s.idling_connections > 0 then
-　　if max_conns == -1 or
-　　s.connected_clients < max_conns then
-　　max_conns = s.connected_clients
-　　max_conns_ndx = i
-　　end
-　　end
-　　end
-　　-- 至此，我们找到了一个拥有空闲连接的从数据库
-　　if max_conns_ndx > 0 then
-　　proxy.connection.backend_ndx = max_conns_ndx
-　　end
-　　else
-　　-- 发送到主数据库
-　　end
-　　return proxy.PROXY_SEND_QUERY
-```
+https://blog.csdn.net/itomge/article/details/6909240
+
+随着一个网站的业务不断扩展，数据不断增加，数据库的压力也会越来越大，对数据库或者SQL的基本优化可能达不到最终的效果，我们可以采用读写分离的策略来改变现状。
+
+读写分离简单的说是把对`数据库读和写的操作分开对应不同的数据库服务器`，这样能有效地减轻数据库压力，也能减轻io压力。
+
+主数据库提供写操作，从数据库提供读操作，其实在很多系统中，主要是读的操作。当主数据库进行写操作时，数据要同步到从的数据库，这样才能有效保证数据库完整性。
+
+Quest SharePlex就是比较牛的同步数据工具，听说比oracle本身的流复制还好，mysql也有自己的同步数据技术。mysql只要是通过二进制日志来复制数据。通过日志在从数据库重复主数据库的操作达到复制数据目的。这个复制比较好的就是通过异步方法，把数据同步到从数据库。
+
+采用读写分离有如下工具：
+  1. oracle的logical standby
+  2. Quest公司的SharePlex
+  3. DSG公司的RealSync
+
+主数据库同步到从数据库后，从数据库一般由多台数据库组成这样才能达到减轻压力的目的。
+
+读的操作怎么样分配到从数据库上？应该根据服务器的压力把读的操作分配到服务器，而不是简单的随机分配。mysql提供了MySQL-Proxy实现读写分离操作。不过MySQL-Proxy好像很久不更新了。oracle可以通过F5有效分配读从数据库的压力。
+
+<div align="center"> <img src="img/dxfl1.jpg" > </div>
+
+ebay的读写分离
+<div align="center"> <img src="img/dxfl2.png" > </div>
+
+
+`MySQL Replication`可以将master的数据复制分布到多个slave上，然后可以利用slave来分担master的读压力。
+
+那么对于前台应用来说，就要考虑如何将读的压力分布到多个slave上。如果每个应用都需要来实现读写分离的算法，一则成本太高，二来如果slave增加更多的机器，应用就要随之修改。明显的，如果在应用和数据库间加一个专门用于实现读写分离的中间层，则整个系统的架构拥有更好的扩展性。
+
+`MySQL Proxy`就是这么一个中间层代理，基本的原理是让主数据库处理事务性查询，而从数据库处理SELECT查询。数据库复制被用来把事务性查询导致的变更同步到集群中的从数据库。
+简单的说，MySQL Proxy就是一个连接池，负责将前台应用的连接请求转发给后台的数据库，并且通过使用lua脚本，可以实现复杂的连接控制和过滤，从而实现读写分离和负载平衡。对于应用来说，MySQL Proxy是完全透明的，应用则只需要连接到MySQL Proxy的监听端口即可。当然，这样proxy机器很可能造成单点失效，可以使用多个proxy机器做为冗余来解决这个问题，在应用服务器的连接池配置中配置到多个proxy的连接参数即可。
+
+MySQL Proxy的安装地址：http://blog.51yip.com/mysql/399.html
+
+实现读写分离的LUA脚本：
+```
+　　--
+　　-- 发送所有的非事务性Select到一个从数据库
+　　if is_in_transaction == 0 and
+　　packet:byte() == proxy.COM_QUERY and
+　　packet:sub(2, 7) == "SELECT" then
+　　local max_conns = -1
+　　local max_conns_ndx = 0
+　　for i = 1, #proxy.servers do
+　　local s = proxy.servers[i]
+　　-- 需要选择一个拥有空闲连接的从数据库
+　　if s.type == proxy.BACKEND_TYPE_RO and
+　　s.idling_connections > 0 then
+　　if max_conns == -1 or
+　　s.connected_clients < max_conns then
+　　max_conns = s.connected_clients
+　　max_conns_ndx = i
+　　end
+　　end
+　　end
+　　-- 至此，我们找到了一个拥有空闲连接的从数据库
+　　if max_conns_ndx > 0 then
+　　proxy.connection.backend_ndx = max_conns_ndx
+　　end
+　　else
+　　-- 发送到主数据库
+　　end
+　　return proxy.PROXY_SEND_QUERY
+```
diff --git a/08 - Utils/Alfred.md "b/08 - Utils \345\267\245\345\205\267/Alfred.md"
similarity index 100%
rename from 08 - Utils/Alfred.md
rename to "08 - Utils \345\267\245\345\205\267/Alfred.md"
diff --git a/08 - Utils/Guava.md "b/08 - Utils \345\267\245\345\205\267/Guava.md"
similarity index 97%
rename from 08 - Utils/Guava.md
rename to "08 - Utils \345\267\245\345\205\267/Guava.md"
index 8d8d999b..521b8fc7 100644
--- a/08 - Utils/Guava.md	
+++ "b/08 - Utils \345\267\245\345\205\267/Guava.md"	
@@ -1,159 +1,159 @@
-# Guava快速入门
-
-Java诞生于1995年，在这20年的时间里Java已经成为世界上最流行的编程语言之一。虽然Java语言时常经历各种各样的吐槽，但它仍然是一门在不断发展、变化的语言——除了语言本身与JDK在不断的进化，第三方库、框架也同样是日新月异。Guava正是这样一个现代的库，它简单易用，对Java语言是一个非常好的补充，可以说只要你在使用Java语言开发任何项目都应该使用Guava。
-
-## 1. Guava简介
-
-Java类库中有不少难用的典型，Collection一定是其中之一。Google最早提出Guava库，是对Java Collection进行扩展以提高开发效率。随着时间推移，它已经覆盖到了Java开发的方方面面，在Java 8中，已经可以看到不少API就是从Guava中原封不动的借鉴而来。接下来的几个例子比较了使用Guava和原生JDK的开发：
-
-## 2. 初始化集合
-
-```java
-//JDK
-List<String> list = new ArrayList<String>(); 
-list.add("a");
-list.add("b");
-list.add("c");
-list.add("d");
-
-//Guava
-List<String> list = Lists.newArrayList("a", "b", "c", "d");
-```
-
-## 3. 读取文件内容
-
-```java
-//JDK写法冗长，可以自行搜索
-
-//Guava
-List<String> lines = Files.readLines(file, Charsets.UTF_8);
-```
-
-## 4. 集合新类型
-
-Guava针对开发中的常见场景，提供了一些新的集合类型简化代码。
-
-### 4.1 Multiset
-
-我们经常碰到一类统计需求——统计某个对象（常见的如字符串）在一个集合中的出现次数，那么会有如下代码：
-
-```java
-Map<String, Integer> counts = new HashMap<String, Integer>();
-for (String word : words) {
-Integer count = counts.get(word);
-if (count == null) {
-counts.put(word, 1);
-} else {
-counts.put(word, count + 1);
-}
-}
-```
-这段代码看起来有一点丑陋，并且容易出错。Guava提供了一种新的集合类型——Multiset。顾名思义，也就是Set中能够同时存在相同的元素:
-
-```java
-Multiset<String> multiset = HashMultiset.create();
-
-multiset.add("a");
-multiset.add("a");
-multiset.add("b", 5);//add "b" 5 times
-
-System.out.println(multiset.elementSet());//[a, b]
-System.out.println(multiset.count("a"));//2
-System.out.println(multiset.count("b"));//5
-System.out.println(multiset.count("c"));//0
-```
-Multiset很像一个ArrayList，因为它允许重复元素，只不过它的元素之间没有顺序；同时它又具备Map<String, Integer>的某一些特性。但本质上它还是一个真正的集合类型——用来表达数学上“多重集合”的概念，这个例子只是恰好和Map对应上罢了。
-
-### 4.2 MultiMap
-
-想必在开发的过程中你一定遇到过实现一个这样的集合：Map<K, List<V>> Map<K, Set<V>>用来表达某一个Key对应的元素是一个集合，可以用两种视角来看待这类集合：
-
-```
-a -> 1 a -> 2 a -> 4 b -> 3 c -> 5
-```
-另一种是：
-```
-a -> [1, 2, 4] b -> 3 c -> 5
-```
-
-如果使用JDK提供的Collection来实现类似功能，那么一定会有类似上一节中统计数量的代码：添加一个元素时，先在Map中查找该元素对应的List，如果不存在则新建一个List对象。
-```java
-Multimap<String, Integer> multimap = ArrayListMultimap.create();
-multimap.put("a", 1);
-multimap.put("a", 2);
-multimap.put("a", 4);
-multimap.put("b", 3);
-multimap.put("c", 5);
-
-System.out.println(multimap.keys());//[a x 3, b, c]
-System.out.println(multimap.get("a"));//[1 ,2, 4]
-System.out.println(multimap.get("b"));//[3]
-System.out.println(multimap.get("c"));//[5]
-System.out.println(multimap.get("d"));//[]
-
-System.out.println(multimap.asMap());//{a=[1, 2, 4], b=[3], c=[5]}
-```
-## 5. 集合工具类
-
-静态创建方法
-
-JDK 7以前，创建泛型集合会比较啰嗦：
-```java
-List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<TypeThatsTooLongForItsOwnGood>();
-```
-Guava提供了静态方法来推断泛型的类型：
-```java
-List<TypeThatsTooLongForItsOwnGood> list = Lists.newArrayList();
-Map<KeyType, LongishValueType> map = Maps.newLinkedHashMap();
-```
-当然在JDK 7里泛型的类型推断已经支持：
-```java
-List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<>();
-```
-Guava除了提供静态构造方法，还提供了一系列工厂类方法来支持集合的创建：
-```java
-Set<Type> copySet = Sets.newHashSet(elements);
-List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");
-```
-### 5.1 Sets
-我们经常需要操作集合（Set），并对集合进行交并补差等运算，Sets类提供了这些方法：
-```java
-union(Set, Set)
-intersection(Set, Set)
-difference(Set, Set)
-symmetricDifference(Set, Set)
-Set<String> wordsWithPrimeLength = ImmutableSet.of("one", "two", "three", "six", "seven", "eight");
-Set<String> primes = ImmutableSet.of("two", "three", "five", "seven");
-
-SetView<String> intersection = Sets.intersection(primes, wordsWithPrimeLength); // contains "two", "three", "seven"
-// I can use intersection as a Set directly, but copying it can be more efficient if I use it a lot.
-return intersection.immutableCopy();
-```
-### 5.2 Primitives
-
-Java中的基本类型(Primitive)包括：byte, short, int, long, float, double, char, boolean。
-
-在Guava中与之对应的一些工具类包括Bytes, Shorts, Ints, Longs, Floats, Doubles, Chars, Booleans。现在以Ints为例示范一些常用方法：
-```java
-System.out.println(Ints.asList(1,2,3,4));
-System.out.println(Ints.compare(1, 2));
-System.out.println(Ints.join(" ", 1, 2, 3, 4));
-System.out.println(Ints.max(1, 3, 5 ,4, 6));
-System.out.println(Ints.tryParse("1234"));
-```
-### 5.3Hashing
-
-编写一个Hash散列算法在Java中比较繁复，但是在Guava里却非常简单：
-```java
-public static String md5(String str) {
-return Hashing.md5().newHasher()
-.putString(str, Charsets.UTF_8)
-.hash()
-.toString();
-}
-```
-更多Hash算法以及其中的一些概念对象请参考HashingExplained
-
-## 6. 总结
-
+# Guava快速入门
+
+Java诞生于1995年，在这20年的时间里Java已经成为世界上最流行的编程语言之一。虽然Java语言时常经历各种各样的吐槽，但它仍然是一门在不断发展、变化的语言——除了语言本身与JDK在不断的进化，第三方库、框架也同样是日新月异。Guava正是这样一个现代的库，它简单易用，对Java语言是一个非常好的补充，可以说只要你在使用Java语言开发任何项目都应该使用Guava。
+
+## 1. Guava简介
+
+Java类库中有不少难用的典型，Collection一定是其中之一。Google最早提出Guava库，是对Java Collection进行扩展以提高开发效率。随着时间推移，它已经覆盖到了Java开发的方方面面，在Java 8中，已经可以看到不少API就是从Guava中原封不动的借鉴而来。接下来的几个例子比较了使用Guava和原生JDK的开发：
+
+## 2. 初始化集合
+
+```java
+//JDK
+List<String> list = new ArrayList<String>(); 
+list.add("a");
+list.add("b");
+list.add("c");
+list.add("d");
+
+//Guava
+List<String> list = Lists.newArrayList("a", "b", "c", "d");
+```
+
+## 3. 读取文件内容
+
+```java
+//JDK写法冗长，可以自行搜索
+
+//Guava
+List<String> lines = Files.readLines(file, Charsets.UTF_8);
+```
+
+## 4. 集合新类型
+
+Guava针对开发中的常见场景，提供了一些新的集合类型简化代码。
+
+### 4.1 Multiset
+
+我们经常碰到一类统计需求——统计某个对象（常见的如字符串）在一个集合中的出现次数，那么会有如下代码：
+
+```java
+Map<String, Integer> counts = new HashMap<String, Integer>();
+for (String word : words) {
+Integer count = counts.get(word);
+if (count == null) {
+counts.put(word, 1);
+} else {
+counts.put(word, count + 1);
+}
+}
+```
+这段代码看起来有一点丑陋，并且容易出错。Guava提供了一种新的集合类型——Multiset。顾名思义，也就是Set中能够同时存在相同的元素:
+
+```java
+Multiset<String> multiset = HashMultiset.create();
+
+multiset.add("a");
+multiset.add("a");
+multiset.add("b", 5);//add "b" 5 times
+
+System.out.println(multiset.elementSet());//[a, b]
+System.out.println(multiset.count("a"));//2
+System.out.println(multiset.count("b"));//5
+System.out.println(multiset.count("c"));//0
+```
+Multiset很像一个ArrayList，因为它允许重复元素，只不过它的元素之间没有顺序；同时它又具备Map<String, Integer>的某一些特性。但本质上它还是一个真正的集合类型——用来表达数学上“多重集合”的概念，这个例子只是恰好和Map对应上罢了。
+
+### 4.2 MultiMap
+
+想必在开发的过程中你一定遇到过实现一个这样的集合：Map<K, List<V>> Map<K, Set<V>>用来表达某一个Key对应的元素是一个集合，可以用两种视角来看待这类集合：
+
+```
+a -> 1 a -> 2 a -> 4 b -> 3 c -> 5
+```
+另一种是：
+```
+a -> [1, 2, 4] b -> 3 c -> 5
+```
+
+如果使用JDK提供的Collection来实现类似功能，那么一定会有类似上一节中统计数量的代码：添加一个元素时，先在Map中查找该元素对应的List，如果不存在则新建一个List对象。
+```java
+Multimap<String, Integer> multimap = ArrayListMultimap.create();
+multimap.put("a", 1);
+multimap.put("a", 2);
+multimap.put("a", 4);
+multimap.put("b", 3);
+multimap.put("c", 5);
+
+System.out.println(multimap.keys());//[a x 3, b, c]
+System.out.println(multimap.get("a"));//[1 ,2, 4]
+System.out.println(multimap.get("b"));//[3]
+System.out.println(multimap.get("c"));//[5]
+System.out.println(multimap.get("d"));//[]
+
+System.out.println(multimap.asMap());//{a=[1, 2, 4], b=[3], c=[5]}
+```
+## 5. 集合工具类
+
+静态创建方法
+
+JDK 7以前，创建泛型集合会比较啰嗦：
+```java
+List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<TypeThatsTooLongForItsOwnGood>();
+```
+Guava提供了静态方法来推断泛型的类型：
+```java
+List<TypeThatsTooLongForItsOwnGood> list = Lists.newArrayList();
+Map<KeyType, LongishValueType> map = Maps.newLinkedHashMap();
+```
+当然在JDK 7里泛型的类型推断已经支持：
+```java
+List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<>();
+```
+Guava除了提供静态构造方法，还提供了一系列工厂类方法来支持集合的创建：
+```java
+Set<Type> copySet = Sets.newHashSet(elements);
+List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");
+```
+### 5.1 Sets
+我们经常需要操作集合（Set），并对集合进行交并补差等运算，Sets类提供了这些方法：
+```java
+union(Set, Set)
+intersection(Set, Set)
+difference(Set, Set)
+symmetricDifference(Set, Set)
+Set<String> wordsWithPrimeLength = ImmutableSet.of("one", "two", "three", "six", "seven", "eight");
+Set<String> primes = ImmutableSet.of("two", "three", "five", "seven");
+
+SetView<String> intersection = Sets.intersection(primes, wordsWithPrimeLength); // contains "two", "three", "seven"
+// I can use intersection as a Set directly, but copying it can be more efficient if I use it a lot.
+return intersection.immutableCopy();
+```
+### 5.2 Primitives
+
+Java中的基本类型(Primitive)包括：byte, short, int, long, float, double, char, boolean。
+
+在Guava中与之对应的一些工具类包括Bytes, Shorts, Ints, Longs, Floats, Doubles, Chars, Booleans。现在以Ints为例示范一些常用方法：
+```java
+System.out.println(Ints.asList(1,2,3,4));
+System.out.println(Ints.compare(1, 2));
+System.out.println(Ints.join(" ", 1, 2, 3, 4));
+System.out.println(Ints.max(1, 3, 5 ,4, 6));
+System.out.println(Ints.tryParse("1234"));
+```
+### 5.3Hashing
+
+编写一个Hash散列算法在Java中比较繁复，但是在Guava里却非常简单：
+```java
+public static String md5(String str) {
+return Hashing.md5().newHasher()
+.putString(str, Charsets.UTF_8)
+.hash()
+.toString();
+}
+```
+更多Hash算法以及其中的一些概念对象请参考HashingExplained
+
+## 6. 总结
+
 Guava是一个非常有用的现代程序库，在Java项目中强烈推荐使用它来取代Apache Commons的一些子项目（例如Lang, Collection, IO等等），除了这里介绍的一些最常用的特性，它还包括缓存、网络、IO、函数式编程等等内容（其中函数式编程在Java 8中可以使用Stream和Lambda表达式等特性来实现）。它的参考文档应该是Java程序员手头必备之物。
\ No newline at end of file
diff --git "a/08 - Utils/Xshell \345\267\245\345\205\267.txt" "b/08 - Utils \345\267\245\345\205\267/Xshell \345\267\245\345\205\267.txt"
similarity index 97%
rename from "08 - Utils/Xshell \345\267\245\345\205\267.txt"
rename to "08 - Utils \345\267\245\345\205\267/Xshell \345\267\245\345\205\267.txt"
index a3c0d66a..aacde8c4 100644
--- "a/08 - Utils/Xshell \345\267\245\345\205\267.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/Xshell \345\267\245\345\205\267.txt"	
@@ -1,14 +1,14 @@
-Xshell 终端工具
-背景色 右键配色方案修改
-sz 下载
-rz 上传
-
-notepad++ 的插件 NppFTP
-32的notepad可以直接在编辑器里 安装插件
-插件 → Plugin Manager → Show Plugin Manager
-可查看 Available Update Installed 找到NppFTP即可安装
-
-64的notepad没有插件管理功能，可以导入插件。
-插件下载地址：http://sourceforge.net/projects/npp-plugins/files/
-
-安装NppFtp 需要重启 即可配置服务器信息 直接读取服务器文件 并编辑文件上传
+Xshell 终端工具
+背景色 右键配色方案修改
+sz 下载
+rz 上传
+
+notepad++ 的插件 NppFTP
+32的notepad可以直接在编辑器里 安装插件
+插件 → Plugin Manager → Show Plugin Manager
+可查看 Available Update Installed 找到NppFTP即可安装
+
+64的notepad没有插件管理功能，可以导入插件。
+插件下载地址：http://sourceforge.net/projects/npp-plugins/files/
+
+安装NppFtp 需要重启 即可配置服务器信息 直接读取服务器文件 并编辑文件上传
diff --git a/08 - Utils/eclipse.md "b/08 - Utils \345\267\245\345\205\267/eclipse.md"
similarity index 92%
rename from 08 - Utils/eclipse.md
rename to "08 - Utils \345\267\245\345\205\267/eclipse.md"
index 1013f04b..2a844ffa 100644
--- a/08 - Utils/eclipse.md	
+++ "b/08 - Utils \345\267\245\345\205\267/eclipse.md"	
@@ -1,7 +1,7 @@
-eclipse color Theme 1.0.0
-
-wakatime
-
-buildship gradle
-
-Eclipse Code Recommenders
+eclipse color Theme 1.0.0
+
+wakatime
+
+buildship gradle
+
+Eclipse Code Recommenders
diff --git a/08 - Utils/git svn/git.txt "b/08 - Utils \345\267\245\345\205\267/git svn/git.txt"
similarity index 94%
rename from 08 - Utils/git svn/git.txt
rename to "08 - Utils \345\267\245\345\205\267/git svn/git.txt"
index 66583859..9f96b86a 100644
--- a/08 - Utils/git svn/git.txt	
+++ "b/08 - Utils \345\267\245\345\205\267/git svn/git.txt"	
@@ -1,3 +1,3 @@
-很方便的工具 
-SourceTree 注册时需要翻墙
-
+很方便的工具 
+SourceTree 注册时需要翻墙
+
diff --git a/08 - Utils/git svn/github helloworld.md "b/08 - Utils \345\267\245\345\205\267/git svn/github helloworld.md"
similarity index 55%
rename from 08 - Utils/git svn/github helloworld.md
rename to "08 - Utils \345\267\245\345\205\267/git svn/github helloworld.md"
index 3f96768f..57f95f22 100644
--- a/08 - Utils/git svn/github helloworld.md	
+++ "b/08 - Utils \345\267\245\345\205\267/git svn/github helloworld.md"	
@@ -29,3 +29,25 @@
 然后你在这个A2下工作，Commit，push等。然后你希望原始仓库Repo A合并你的工作，你可以在Github上发起一个Pull Request，意思是请求Repo A的所有者从你的A2合并分支。如果被审核通过并正式合并，这样你就为项目A做贡献了
 
 ##  Merge Pull Request
+
+
+<p align='center'>
+<a href="https://github.com/loveincode/notes"><img src="https://img.shields.io/github/stars/loveincode/notes.svg?style=social&label=Stars"></a>
+<a href="https://github.com/loveincode/notes"><img src="https://img.shields.io/github/forks/loveincode/notes.svg?style=social&label=Forks"></a>
+<a href="https://github.com/loveincode/notes"><img src="https://img.shields.io/github/issues/loveincode/notes.svg?style=social&label=Issues"></a>
+<br/>
+<img src="https://img.shields.io/badge/platform-Java-ff69b4.svg">
+<img src="https://img.shields.io/badge/language-Python-orange.svg">
+<a href="https://loveincode.cnblogs.com/"><img src="https://img.shields.io/badge/Blog-loveincode-80d4f9.svg?style=flat"></a>
+</p>
+
+[![stars](https://img.shields.io/github/stars/loveincode/notes.svg?style=social&label=Stars)](https://github.com/loveincode/notes/stargazers)
+[![forks](https://img.shields.io/github/forks/loveincode/notes.svg?style=social&label=Forks)](https://github.com/loveincode/notes/network/members)
+[![issues](https://img.shields.io/github/issues/loveincode/notes.svg?style=social&label=Issues)](https://github.com/loveincode/notes/issues)
+![PLARFORM](https://img.shields.io/badge/platform-Java-ff69b4.svg)
+![language](https://img.shields.io/badge/language-Python-orange.svg)
+[![BLOG](https://img.shields.io/badge/Blog-loveincode-80d4f9.svg?style=flat)](https://loveincode.cnblogs.com/)
+[![LICENSE](https://img.shields.io/badge/license-Anti%20996-blue.svg)](https://github.com/996icu/996.ICU/blob/master/LICENSE)
+[![Badge](https://img.shields.io/badge/link-996.icu-red.svg)](https://996.icu/#/zh_CN)
+[![](https://img.shields.io/badge/build-passing-brightgreen.svg)]()
+[![PRs Welcome](https://badgen.net/badge/PRs/welcome/green)](http://makeapullrequest.com)
diff --git a/08 - Utils/git svn/github language show.md "b/08 - Utils \345\267\245\345\205\267/git svn/github language show.md"
similarity index 97%
rename from 08 - Utils/git svn/github language show.md
rename to "08 - Utils \345\267\245\345\205\267/git svn/github language show.md"
index c8c35edb..480db5e9 100644
--- a/08 - Utils/git svn/github language show.md	
+++ "b/08 - Utils \345\267\245\345\205\267/git svn/github language show.md"	
@@ -1,36 +1,36 @@
-### 修改Github上项目语言显示问题
-
-#### 问题
-最近将自己写的博客放到github上了。由于使用了富文本编辑器、jQuery、Bootstrap等第三方插件，导致js、css等代码远远超过你自己写的代码
-
-这样的情况很不能忍，尤其对于强迫症来说。而且github也没有bitbucket项目语言的设置
-
-搜索了一下发现github是使用 Linguist 来detect所使用的语言。 Linguist 是什么鬼我也不了解，大致就是通过统计哪种语言代码数量最多的作为当前项目主语言。这样很不公平有木有，
-像Scala这种支持函数式编程而且语法简洁的语言，代码量完全拼不过其他语言
-
-#### 解决
-
-解决起来也简单，有2种方法
-
-#### 1、使用外链接
-
-将项目中的静态文件如jQuery、Bootstrap等放到别处用连接导入即可
-
-#### 2、使用 .gitattributes 配置文件
-
-具体就是在项目根目录添加文件名为.gitattributes的文本文件，写入
-
-	*.js linguist-language=Scala
-	*.css linguist-language=Scala
-	*.html linguist-language=Scala
-
-意思就是将.js、css、html当作Scala语言来统计
-
-另外，说一下，在windows系统中并不好直接创建名为 .gitattributes 的文件
-
-那么只需要用命令行创建就行了,或者使用VI也是可以的：
-
-touch .gitattributes
-
-cmd
+### 修改Github上项目语言显示问题
+
+#### 问题
+最近将自己写的博客放到github上了。由于使用了富文本编辑器、jQuery、Bootstrap等第三方插件，导致js、css等代码远远超过你自己写的代码
+
+这样的情况很不能忍，尤其对于强迫症来说。而且github也没有bitbucket项目语言的设置
+
+搜索了一下发现github是使用 Linguist 来detect所使用的语言。 Linguist 是什么鬼我也不了解，大致就是通过统计哪种语言代码数量最多的作为当前项目主语言。这样很不公平有木有，
+像Scala这种支持函数式编程而且语法简洁的语言，代码量完全拼不过其他语言
+
+#### 解决
+
+解决起来也简单，有2种方法
+
+#### 1、使用外链接
+
+将项目中的静态文件如jQuery、Bootstrap等放到别处用连接导入即可
+
+#### 2、使用 .gitattributes 配置文件
+
+具体就是在项目根目录添加文件名为.gitattributes的文本文件，写入
+
+	*.js linguist-language=Scala
+	*.css linguist-language=Scala
+	*.html linguist-language=Scala
+
+意思就是将.js、css、html当作Scala语言来统计
+
+另外，说一下，在windows系统中并不好直接创建名为 .gitattributes 的文件
+
+那么只需要用命令行创建就行了,或者使用VI也是可以的：
+
+touch .gitattributes
+
+cmd
 type NUL > .gitattributes
\ No newline at end of file
diff --git a/08 - Utils/git svn/svn.txt "b/08 - Utils \345\267\245\345\205\267/git svn/svn.txt"
similarity index 97%
rename from 08 - Utils/git svn/svn.txt
rename to "08 - Utils \345\267\245\345\205\267/git svn/svn.txt"
index afd0a283..2219b1df 100644
--- a/08 - Utils/git svn/svn.txt	
+++ "b/08 - Utils \345\267\245\345\205\267/git svn/svn.txt"	
@@ -1,19 +1,19 @@
-
-感叹号表示文件被修改过
-
-加号表示有新增文件
-
-叉号表示有删除文件
-
-如果加号、叉号同时出现，有可能是某个文件改名字了 
-
-1红色感叹号表示这个文件从服务器上下载下来以后，
-外地被修改过。这时执行提交操作就可以了
-
-2黄色感叹号表示这个文件在提交的时候发现存在抵触，
-也就是说有别人在提交之前对这个文件的同一个版本进行了修改。
-这时你需要检查这个文件的历史日志，和修改了这个文件的人进行沟通，
-将两个人的修改内容合并，合并完成后标注为解决冲突，然后提交。
-
-3蓝色加号表示这个文件刚被执行了增加”add操作，
+
+感叹号表示文件被修改过
+
+加号表示有新增文件
+
+叉号表示有删除文件
+
+如果加号、叉号同时出现，有可能是某个文件改名字了 
+
+1红色感叹号表示这个文件从服务器上下载下来以后，
+外地被修改过。这时执行提交操作就可以了
+
+2黄色感叹号表示这个文件在提交的时候发现存在抵触，
+也就是说有别人在提交之前对这个文件的同一个版本进行了修改。
+这时你需要检查这个文件的历史日志，和修改了这个文件的人进行沟通，
+将两个人的修改内容合并，合并完成后标注为解决冲突，然后提交。
+
+3蓝色加号表示这个文件刚被执行了增加”add操作，
 但还没有执行提交操作。这时执行提交操作就可以了
\ No newline at end of file
diff --git "a/08 - Utils \345\267\245\345\205\267/idea.md" "b/08 - Utils \345\267\245\345\205\267/idea.md"
new file mode 100644
index 00000000..c2b02453
--- /dev/null
+++ "b/08 - Utils \345\267\245\345\205\267/idea.md"	
@@ -0,0 +1,2 @@
+高亮显示与选中字符串相同的内容
+【Editor】→【Color Scheme】→【General】菜单下的【Code】→ 【Identifier under caret】 【Identifier under caret(write)】的Backgroud色值 C94969
diff --git "a/08 - Utils/iterm2\345\277\253\346\215\267\351\224\256.md" "b/08 - Utils \345\267\245\345\205\267/iterm2\345\277\253\346\215\267\351\224\256.md"
similarity index 96%
rename from "08 - Utils/iterm2\345\277\253\346\215\267\351\224\256.md"
rename to "08 - Utils \345\267\245\345\205\267/iterm2\345\277\253\346\215\267\351\224\256.md"
index c7c21ef7..e4e1a354 100644
--- "a/08 - Utils/iterm2\345\277\253\346\215\267\351\224\256.md"	
+++ "b/08 - Utils \345\267\245\345\205\267/iterm2\345\277\253\346\215\267\351\224\256.md"	
@@ -1,100 +1,100 @@
-标签
-
-新建标签：command + t
-
-关闭标签：command + w
-
-切换标签：command + 数字 command + 左右方向键
-
-切换全屏：`command + enter`
-
-查找：command + f
-
-分屏
-
-垂直分屏：command + d
-
-水平分屏：command + shift + d
-
-切换屏幕：command + option + 方向键 command + [ 或 command + ]
-
-查看历史命令：command + ;
-
-查看剪贴板历史：command + shift + h
-
-其他
-
-清除当前行：ctrl + u
-
-到行首：ctrl + a
-
-到行尾：ctrl + e
-
-前进后退：ctrl + f/b (相当于左右方向键)
-
-上一条命令：ctrl + p
-
-搜索命令历史：ctrl + r
-
-删除当前光标的字符：ctrl + d
-
-删除光标之前的字符：ctrl + h
-
-删除光标之前的单词：ctrl + w
-
-删除到文本末尾：ctrl + k
-
-交换光标处文本：ctrl + t
-
-清屏1：command + r
-
-清屏2：ctrl + l
-
-自带有哪些很实用的功能/快捷键
-
-`⌘ + 数字` 在各 tab 标签直接来回切换
-
-选择即复制 + 鼠标中键粘贴，这个很实用
-
-`⌘ + f` 所查找的内容会被自动复制
-
-`⌘ + d` 横着分屏 / `⌘ + shift + d` 竖着分屏
-
-`⌘ + r` = clear，而且只是换到新一屏，不会想 clear 一样创建一个空屏
-
-`ctrl + u` 清空当前行，无论光标在什么位置
-
-输入开头命令后 按 `⌘ + ;` 会自动列出输入过的命令
-
-`⌘ + shift + h` 会列出剪切板历史
-
-可以在 Preferences > keys 设置全局快捷键调出 iterm，这个也可以用过 Alfred 实现
-
-我常用的一些快捷键
-
-`⌘ +  1 / 2` 左右 tab 之间来回切换，这个在 前面 已经介绍过了
-`⌘ ←` / `⌘ →` 到一行命令最左边/最右边 ，这个功能同 C+a / C+e
-
-`⌥alt ←` / `⌥alt → `按单词前移/后移，相当与 C+f / C+b，其实这个功能在Iterm中已经预定义好了，`⌥alt f` / `⌥alt b`，看个人习惯了
-
-设置方法如下
-
-当然除了这些可以自定义的也不能忘了 linux 下那些好用的组合
-
-`C+a` / `C+e` 这个几乎在哪都可以使用
-
-`C+p` / `!!` 上一条命令
-
-`C+k` 从光标处删至命令行尾 (本来 C+u 是删至命令行首，但iterm中是删掉整行)
-
-`C+w A+d`从光标处删至字首/尾
-
-`C+h C+d` 删掉光标前后的自负
-
-`C+y` 粘贴至光标后
-
-`C+r` 搜索命令历史，这个较常用
-
-选择喜欢的配色方案。
-
-在Preferences->Profiles->Colors的load presets可以选择某个配色方案。也可以自己下载。在网站http://iterm2colorschemes.com/，几乎可以找到所有可用的配色方案。大家自己选择吧
+标签
+
+新建标签：command + t
+
+关闭标签：command + w
+
+切换标签：command + 数字 command + 左右方向键
+
+切换全屏：`command + enter`
+
+查找：command + f
+
+分屏
+
+垂直分屏：command + d
+
+水平分屏：command + shift + d
+
+切换屏幕：command + option + 方向键 command + [ 或 command + ]
+
+查看历史命令：command + ;
+
+查看剪贴板历史：command + shift + h
+
+其他
+
+清除当前行：ctrl + u
+
+到行首：ctrl + a
+
+到行尾：ctrl + e
+
+前进后退：ctrl + f/b (相当于左右方向键)
+
+上一条命令：ctrl + p
+
+搜索命令历史：ctrl + r
+
+删除当前光标的字符：ctrl + d
+
+删除光标之前的字符：ctrl + h
+
+删除光标之前的单词：ctrl + w
+
+删除到文本末尾：ctrl + k
+
+交换光标处文本：ctrl + t
+
+清屏1：command + r
+
+清屏2：ctrl + l
+
+自带有哪些很实用的功能/快捷键
+
+`⌘ + 数字` 在各 tab 标签直接来回切换
+
+选择即复制 + 鼠标中键粘贴，这个很实用
+
+`⌘ + f` 所查找的内容会被自动复制
+
+`⌘ + d` 横着分屏 / `⌘ + shift + d` 竖着分屏
+
+`⌘ + r` = clear，而且只是换到新一屏，不会想 clear 一样创建一个空屏
+
+`ctrl + u` 清空当前行，无论光标在什么位置
+
+输入开头命令后 按 `⌘ + ;` 会自动列出输入过的命令
+
+`⌘ + shift + h` 会列出剪切板历史
+
+可以在 Preferences > keys 设置全局快捷键调出 iterm，这个也可以用过 Alfred 实现
+
+我常用的一些快捷键
+
+`⌘ +  1 / 2` 左右 tab 之间来回切换，这个在 前面 已经介绍过了
+`⌘ ←` / `⌘ →` 到一行命令最左边/最右边 ，这个功能同 C+a / C+e
+
+`⌥alt ←` / `⌥alt → `按单词前移/后移，相当与 C+f / C+b，其实这个功能在Iterm中已经预定义好了，`⌥alt f` / `⌥alt b`，看个人习惯了
+
+设置方法如下
+
+当然除了这些可以自定义的也不能忘了 linux 下那些好用的组合
+
+`C+a` / `C+e` 这个几乎在哪都可以使用
+
+`C+p` / `!!` 上一条命令
+
+`C+k` 从光标处删至命令行尾 (本来 C+u 是删至命令行首，但iterm中是删掉整行)
+
+`C+w A+d`从光标处删至字首/尾
+
+`C+h C+d` 删掉光标前后的自负
+
+`C+y` 粘贴至光标后
+
+`C+r` 搜索命令历史，这个较常用
+
+选择喜欢的配色方案。
+
+在Preferences->Profiles->Colors的load presets可以选择某个配色方案。也可以自己下载。在网站http://iterm2colorschemes.com/，几乎可以找到所有可用的配色方案。大家自己选择吧
diff --git "a/08 - Utils/mac\347\273\210\347\253\257.md" "b/08 - Utils \345\267\245\345\205\267/mac\347\273\210\347\253\257.md"
similarity index 100%
rename from "08 - Utils/mac\347\273\210\347\253\257.md"
rename to "08 - Utils \345\267\245\345\205\267/mac\347\273\210\347\253\257.md"
diff --git a/08 - Utils/markdown.md "b/08 - Utils \345\267\245\345\205\267/markdown.md"
similarity index 94%
rename from 08 - Utils/markdown.md
rename to "08 - Utils \345\267\245\345\205\267/markdown.md"
index 2c1bc046..07f0a5f4 100644
--- a/08 - Utils/markdown.md	
+++ "b/08 - Utils \345\267\245\345\205\267/markdown.md"	
@@ -1,65 +1,65 @@
-markdown
-
-windows: [下载地址](https://markdownpad.com/download.html)
-
- 【进阶版】有道云笔记Markdown指南 http://note.youdao.com/iyoudao/?p=2445
- 【简明版】有道云笔记Markdown指南 http://note.youdao.com/iyoudao/?p=2411
-
-
- Markdown Guide
-
- Emphasis
- 	**bold**
- 	*italics*
- 	~~strikethrough~~
-
- Headers
- 	# Big header
- 	## Medium header
- 	### Small header
- 	#### Tiny header
-
- Lists
- 	* Generic list item
- 	* Generic list item
- 	* Generic list item
-
- 	1. Numbered list item
- 	2. Numbered list item
- 	3. Numbered list item
- Links
-
- 	[Text to display](http://www.example.com)
-
- Quotes
- 	> This is a quote.
- 	> It can span multiple lines!
-
- Images   Need to upload an image? Imgur has a great interface.
-
- 	![](http://www.example.com/image.jpg)
-
- Tables
-
- 	| Column 1 | Column 2 | Column 3 |
- 	| -------- | -------- | -------- |
- 	| John     | Doe      | Male     |
- 	| Mary     | Smith    | Female   |
-
- 	Or without aligning the columns...
-
- 	| Column 1 | Column 2 | Column 3 |
- 	| -------- | -------- | -------- |
- 	| John | Doe | Male |
- 	| Mary | Smith | Female |
-
- Displaying code
-
- 	`var example = "hello!";`
-
- 	Or spanning multiple lines...
-
- 	```
- 		var example = "hello!";
- 		alert(example);
- 	```
+markdown
+
+windows: [下载地址](https://markdownpad.com/download.html)
+
+ 【进阶版】有道云笔记Markdown指南 http://note.youdao.com/iyoudao/?p=2445
+ 【简明版】有道云笔记Markdown指南 http://note.youdao.com/iyoudao/?p=2411
+
+
+ Markdown Guide
+
+ Emphasis
+ 	**bold**
+ 	*italics*
+ 	~~strikethrough~~
+
+ Headers
+ 	# Big header
+ 	## Medium header
+ 	### Small header
+ 	#### Tiny header
+
+ Lists
+ 	* Generic list item
+ 	* Generic list item
+ 	* Generic list item
+
+ 	1. Numbered list item
+ 	2. Numbered list item
+ 	3. Numbered list item
+ Links
+
+ 	[Text to display](http://www.example.com)
+
+ Quotes
+ 	> This is a quote.
+ 	> It can span multiple lines!
+
+ Images   Need to upload an image? Imgur has a great interface.
+
+ 	![](http://www.example.com/image.jpg)
+
+ Tables
+
+ 	| Column 1 | Column 2 | Column 3 |
+ 	| -------- | -------- | -------- |
+ 	| John     | Doe      | Male     |
+ 	| Mary     | Smith    | Female   |
+
+ 	Or without aligning the columns...
+
+ 	| Column 1 | Column 2 | Column 3 |
+ 	| -------- | -------- | -------- |
+ 	| John | Doe | Male |
+ 	| Mary | Smith | Female |
+
+ Displaying code
+
+ 	`var example = "hello!";`
+
+ 	Or spanning multiple lines...
+
+ 	```
+ 		var example = "hello!";
+ 		alert(example);
+ 	```
diff --git "a/08 - Utils/maven/Scope\345\261\236\346\200\247\350\256\276\347\275\256\345\220\253\344\271\211.md" "b/08 - Utils \345\267\245\345\205\267/maven/Scope\345\261\236\346\200\247\350\256\276\347\275\256\345\220\253\344\271\211.md"
similarity index 98%
rename from "08 - Utils/maven/Scope\345\261\236\346\200\247\350\256\276\347\275\256\345\220\253\344\271\211.md"
rename to "08 - Utils \345\267\245\345\205\267/maven/Scope\345\261\236\346\200\247\350\256\276\347\275\256\345\220\253\344\271\211.md"
index 02a44d26..857edb3c 100644
--- "a/08 - Utils/maven/Scope\345\261\236\346\200\247\350\256\276\347\275\256\345\220\253\344\271\211.md"	
+++ "b/08 - Utils \345\267\245\345\205\267/maven/Scope\345\261\236\346\200\247\350\256\276\347\275\256\345\220\253\344\271\211.md"	
@@ -1,10 +1,10 @@
-Scope属性设置含义
-每个依赖项的Scope选项进行该jar包的相关操作设置，默认为compile，根据需要调整设置：
-
-1、compile设置编译范围内有效，在`编译`和`打包`时都会将依赖项加载进去。
-
-2、test设置测试范围内有效，只在`测试`时使用，编译和打包时都不会加载该项。
-
-3、provided设置 `编译`和`测试`的范围内有效，打包时不会加载该项。
-
-4、runtime设置在`运行时`加载该依赖项，但是编译时不依赖。
+Scope属性设置含义
+每个依赖项的Scope选项进行该jar包的相关操作设置，默认为compile，根据需要调整设置：
+
+1、compile设置编译范围内有效，在`编译`和`打包`时都会将依赖项加载进去。
+
+2、test设置测试范围内有效，只在`测试`时使用，编译和打包时都不会加载该项。
+
+3、provided设置 `编译`和`测试`的范围内有效，打包时不会加载该项。
+
+4、runtime设置在`运行时`加载该依赖项，但是编译时不依赖。
diff --git "a/08 - Utils/maven/maven\344\273\223\345\272\223.txt" "b/08 - Utils \345\267\245\345\205\267/maven/maven\344\273\223\345\272\223.txt"
similarity index 97%
rename from "08 - Utils/maven/maven\344\273\223\345\272\223.txt"
rename to "08 - Utils \345\267\245\345\205\267/maven/maven\344\273\223\345\272\223.txt"
index bcc89c3e..5005e528 100644
--- "a/08 - Utils/maven/maven\344\273\223\345\272\223.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/maven/maven\344\273\223\345\272\223.txt"	
@@ -1,15 +1,15 @@
-#收集的比较快的maven仓库
-http://maven.wso2.org/nexus/content/groups/public/
-http://jcenter.bintray.com/
-http://maven.antelink.com/content/repositories/central/
-http://nexus.openkoala.org/nexus/content/groups/Koala-release/
-http://maven.tmatesoft.com/content/groups/public/
-http://mavensync.zkoss.org/maven2/
-http://maven.springframework.org/release/
-
-
-阿里云 
-http://maven.aliyun.com/nexus/content/groups/public/
-
-
+#收集的比较快的maven仓库
+http://maven.wso2.org/nexus/content/groups/public/
+http://jcenter.bintray.com/
+http://maven.antelink.com/content/repositories/central/
+http://nexus.openkoala.org/nexus/content/groups/Koala-release/
+http://maven.tmatesoft.com/content/groups/public/
+http://mavensync.zkoss.org/maven2/
+http://maven.springframework.org/release/
+
+
+阿里云 
+http://maven.aliyun.com/nexus/content/groups/public/
+
+
 http://www.mvnrepository.com/
\ No newline at end of file
diff --git a/08 - Utils/maven/pom-exclusion.md "b/08 - Utils \345\267\245\345\205\267/maven/pom-exclusion.md"
similarity index 100%
rename from 08 - Utils/maven/pom-exclusion.md
rename to "08 - Utils \345\267\245\345\205\267/maven/pom-exclusion.md"
diff --git "a/08 - Utils \345\267\245\345\205\267/maven/\345\221\275\344\273\244.md" "b/08 - Utils \345\267\245\345\205\267/maven/\345\221\275\344\273\244.md"
new file mode 100644
index 00000000..3888c3d2
--- /dev/null
+++ "b/08 - Utils \345\267\245\345\205\267/maven/\345\221\275\344\273\244.md"	
@@ -0,0 +1,50 @@
+# Maven命令列表
+
+mvn –version            显示版本信息
+mvn clean               清理项目生产的临时文件,一般是模块下的target目录
+mvn compile             编译源代码，一般编译模块下的src/main/java目录
+mvn package             项目打包工具,会在模块下的target目录生成jar或war等文件
+mvn test                测试命令,或执行src/test/java/下junit的测试用例.
+mvn install             将打包的jar/war文件复制到你的本地仓库中,供其他模块使用
+mvn deploy              将打包的文件发布到远程参考,提供其他人员进行下载依赖
+mvn site                生成项目相关信息的网站
+mvn eclipse:eclipse     将项目转化为Eclipse项目
+mvn dependency:tree     打印出项目的整个依赖树  
+mvn archetype:generate  创建Maven的普通java项目
+mvn tomcat:run          在tomcat容器中运行web应用
+mvn jetty:run           调用 Jetty 插件的 Run 目标在 Jetty Servlet 容器中启动 web 应用
+
+# mvn compile与mvn install、mvn deploy的区别
+mvn compile，编译类文件
+mvn install，包含mvn compile，mvn package，然后上传到本地仓库
+mvn deploy,包含mvn install,然后，上传到私服
+
+mvn clean package依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)等７个阶段。
+mvn clean install依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)、install等8个阶段。
+mvn clean deploy依次执行了clean、resources、compile、testResources、testCompile、test、jar(打包)、install、deploy等９个阶段。
+由上面的分析可知主要区别如下，
+package命令完成了项目编译、单元测试、打包功能，但没有把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库
+install命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库，但没有布署到远程maven私服仓库
+deploy命令完成了项目编译、单元测试、打包功能，同时把打好的可执行jar包（war包或其它形式的包）布署到本地maven仓库和远程maven私服仓库　　
+
+命令参数
+上面列举的只是比较通用的命令，其实很多命令都可以携带参数以执行更精准的任务。
+1.   -D 传入属性参数 mvn -Dxxx=yyy指定java全局属性
+比如命令：
+mvn package -Dmaven.test.skip=true
+以“-D”开头，将“maven.test.skip”的值设为“true”,就是告诉maven打包的时候跳过单元测试。同理，“mvn deploy-Dmaven.test.skip=true”代表部署项目并跳过单元测试。
+2.  -P 使用指定的Profile配置 mvn -Pxxx引用profile xxx
+比如项目开发需要有多个环境，一般为开发，测试，预发，正式4个环境，在pom.xml中的配置如下：
+3.  -e 显示maven运行出错的信息(显示详细错误)
+4.  -o 离线执行命令,即不去远程仓库更新包
+5.  -X 显示maven允许的debug信息
+6.  -U 强制去远程更新snapshot的插件或依赖，默认每天只更新一次
+7.  -N 仅在当前项目模块执行命令，关闭reactor 表示不递归子模块
+8.  -pl module_name在指定模块上执行命令
+9.  -ff 在递归执行命令过程中，一旦发生错误就直接退出
+
+mvn -h 可以看到很多命令及其用途；
+-am --also-make 同时构建所列模块的依赖模块；
+-amd -also-make-dependents 同时构建依赖于所列模块的模块；
+-pl --projects <arg> 构建制定的模块，模块间用逗号分隔；
+-rf -resume-from <arg> 从指定的模块恢复反应堆。
diff --git a/08 - Utils/sublime text/x.txt "b/08 - Utils \345\267\245\345\205\267/sublime text/x.txt"
similarity index 95%
rename from 08 - Utils/sublime text/x.txt
rename to "08 - Utils \345\267\245\345\205\267/sublime text/x.txt"
index 1744e40d..e1174233 100644
--- a/08 - Utils/sublime text/x.txt	
+++ "b/08 - Utils \345\267\245\345\205\267/sublime text/x.txt"	
@@ -1,10 +1,10 @@
-下载 http://www.sublimetextcn.com/3/
-
-markdown 插件 http://blog.csdn.net/github_32886825/article/details/52930195
-
-
-#sublime
-50.116.34.243       sublime.wbond.net
-
-
+下载 http://www.sublimetextcn.com/3/
+
+markdown 插件 http://blog.csdn.net/github_32886825/article/details/52930195
+
+
+#sublime
+50.116.34.243       sublime.wbond.net
+
+
 http://www.cnblogs.com/ae6623/p/5338049.html
\ No newline at end of file
diff --git "a/08 - Utils/tcpdump/\346\212\223\345\214\205\344\277\235\345\255\230\346\226\207\344\273\266 wireshark\345\210\206\346\236\220.txt" "b/08 - Utils \345\267\245\345\205\267/tcpdump/\346\212\223\345\214\205\344\277\235\345\255\230\346\226\207\344\273\266 wireshark\345\210\206\346\236\220.txt"
similarity index 96%
rename from "08 - Utils/tcpdump/\346\212\223\345\214\205\344\277\235\345\255\230\346\226\207\344\273\266 wireshark\345\210\206\346\236\220.txt"
rename to "08 - Utils \345\267\245\345\205\267/tcpdump/\346\212\223\345\214\205\344\277\235\345\255\230\346\226\207\344\273\266 wireshark\345\210\206\346\236\220.txt"
index 675fdfe2..66515b02 100644
--- "a/08 - Utils/tcpdump/\346\212\223\345\214\205\344\277\235\345\255\230\346\226\207\344\273\266 wireshark\345\210\206\346\236\220.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/tcpdump/\346\212\223\345\214\205\344\277\235\345\255\230\346\226\207\344\273\266 wireshark\345\210\206\346\236\220.txt"	
@@ -1,3 +1,3 @@
-tcpdump -i eth0 -w dump.pcap
-
+tcpdump -i eth0 -w dump.pcap
+
 使用wireshark打开 分析
\ No newline at end of file
diff --git "a/08 - Utils/\344\270\203\347\211\233\344\272\221/\345\257\271\350\261\241\345\255\230\345\202\250.txt" "b/08 - Utils \345\267\245\345\205\267/\344\270\203\347\211\233\344\272\221/\345\257\271\350\261\241\345\255\230\345\202\250.txt"
similarity index 93%
rename from "08 - Utils/\344\270\203\347\211\233\344\272\221/\345\257\271\350\261\241\345\255\230\345\202\250.txt"
rename to "08 - Utils \345\267\245\345\205\267/\344\270\203\347\211\233\344\272\221/\345\257\271\350\261\241\345\255\230\345\202\250.txt"
index 1f0ff0c7..de530c1c 100644
--- "a/08 - Utils/\344\270\203\347\211\233\344\272\221/\345\257\271\350\261\241\345\255\230\345\202\250.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/\344\270\203\347\211\233\344\272\221/\345\257\271\350\261\241\345\255\230\345\202\250.txt"	
@@ -1,8 +1,8 @@
-
-提供
-
-存储  10 G  下载流量 20G API请求 PUT/DELETE请求 10万次 GET请求 100万次
-
-
- 
+
+提供
+
+存储  10 G  下载流量 20G API请求 PUT/DELETE请求 10万次 GET请求 100万次
+
+
+ 
 	
\ No newline at end of file
diff --git "a/08 - Utils/\346\220\234\347\264\242\346\212\200\345\267\247.txt" "b/08 - Utils \345\267\245\345\205\267/\346\220\234\347\264\242\346\212\200\345\267\247.txt"
similarity index 100%
rename from "08 - Utils/\346\220\234\347\264\242\346\212\200\345\267\247.txt"
rename to "08 - Utils \345\267\245\345\205\267/\346\220\234\347\264\242\346\212\200\345\267\247.txt"
diff --git "a/08 - Utils/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\255\246\344\271\240.txt" "b/08 - Utils \345\267\245\345\205\267/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\255\246\344\271\240.txt"
similarity index 98%
rename from "08 - Utils/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\255\246\344\271\240.txt"
rename to "08 - Utils \345\267\245\345\205\267/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\255\246\344\271\240.txt"
index 72a977ba..c455bc4e 100644
--- "a/08 - Utils/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\255\246\344\271\240.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\255\246\344\271\240.txt"	
@@ -1,6 +1,6 @@
-正则表达式 Regular Expression http://www.runoob.com/regexp/regexp-tutorial.html
-java正则表达式 https://www.runoob.com/java/java-regular-expressions.html
-
-JavaScript RegExp 对象 http://www.runoob.com/js/js-obj-regexp.html
-
+正则表达式 Regular Expression http://www.runoob.com/regexp/regexp-tutorial.html
+java正则表达式 https://www.runoob.com/java/java-regular-expressions.html
+
+JavaScript RegExp 对象 http://www.runoob.com/js/js-obj-regexp.html
+
 python正则表达式 http://www.runoob.com/python/python-reg-expressions.html
\ No newline at end of file
diff --git "a/08 - Utils/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\270\270\347\224\250.txt" "b/08 - Utils \345\267\245\345\205\267/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\270\270\347\224\250.txt"
similarity index 97%
rename from "08 - Utils/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\270\270\347\224\250.txt"
rename to "08 - Utils \345\267\245\345\205\267/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\270\270\347\224\250.txt"
index f1176930..feb78019 100644
--- "a/08 - Utils/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\270\270\347\224\250.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217/\345\270\270\347\224\250.txt"	
@@ -1,61 +1,61 @@
-//正整数
-/^[0-9]*[1-9][0-9]*$/;
-//负整数
-/^-[0-9]*[1-9][0-9]*$/;
-//正浮点数
-/^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$/;   
-//负浮点数
-/^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;  
-//浮点数
-/^(-?\d+)(\.\d+)?$/;
-//email地址
-/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/;
-//url地址
-/^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$/;
-或：^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$ 
-//年/月/日（年-月-日、年.月.日）
-/^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$/;
-//匹配中文字符
-/[\u4e00-\u9fa5]/;
-//匹配帐号是否合法(字母开头，允许5-10字节，允许字母数字下划线)
-/^[a-zA-Z][a-zA-Z0-9_]{4,9}$/;
-//匹配空白行的正则表达式
-/\n\s*\r/;
-//匹配中国邮政编码
-/[1-9]\d{5}(?!\d)/;
-//匹配身份证
-/\d{15}|\d{18}/;
-//匹配国内电话号码
-/(\d{3}-|\d{4}-)?(\d{8}|\d{7})?/;
-//匹配IP地址
-/((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/;
-//匹配首尾空白字符的正则表达式
-/^\s*|\s*$/;
-//匹配HTML标记的正则表达式
-< (\S*?)[^>]*>.*?|< .*? />;
-//sql 语句
-^(select|drop|delete|create|update|insert).*$
-//提取信息中的网络链接
-(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)? 
-//提取信息中的邮件地址
-\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* 
-//提取信息中的图片链接
-(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)? 
-//提取信息中的 IP 地址
-(\d+)\.(\d+)\.(\d+)\.(\d+)
-//取信息中的中国手机号码
-(86)*0*13\d{9} 
-//提取信息中的中国邮政编码
-[1-9]{1}(\d+){5} 
-//提取信息中的浮点数（即小数）
-(-?\d*)\.?\d+ 
-//提取信息中的任何数字
-(-?\d*)(\.\d+)?
-//电话区号
-^0\d{2,3}$
-//腾讯 QQ 号
-^[1-9]*[1-9][0-9]*$ 
-//帐号（字母开头，允许 5-16 字节，允许字母数字下划线）
-^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
-//中文、英文、数字及下划线
+//正整数
+/^[0-9]*[1-9][0-9]*$/;
+//负整数
+/^-[0-9]*[1-9][0-9]*$/;
+//正浮点数
+/^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$/;   
+//负浮点数
+/^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;  
+//浮点数
+/^(-?\d+)(\.\d+)?$/;
+//email地址
+/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/;
+//url地址
+/^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$/;
+或：^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$ 
+//年/月/日（年-月-日、年.月.日）
+/^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$/;
+//匹配中文字符
+/[\u4e00-\u9fa5]/;
+//匹配帐号是否合法(字母开头，允许5-10字节，允许字母数字下划线)
+/^[a-zA-Z][a-zA-Z0-9_]{4,9}$/;
+//匹配空白行的正则表达式
+/\n\s*\r/;
+//匹配中国邮政编码
+/[1-9]\d{5}(?!\d)/;
+//匹配身份证
+/\d{15}|\d{18}/;
+//匹配国内电话号码
+/(\d{3}-|\d{4}-)?(\d{8}|\d{7})?/;
+//匹配IP地址
+/((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/;
+//匹配首尾空白字符的正则表达式
+/^\s*|\s*$/;
+//匹配HTML标记的正则表达式
+< (\S*?)[^>]*>.*?|< .*? />;
+//sql 语句
+^(select|drop|delete|create|update|insert).*$
+//提取信息中的网络链接
+(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)? 
+//提取信息中的邮件地址
+\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* 
+//提取信息中的图片链接
+(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)? 
+//提取信息中的 IP 地址
+(\d+)\.(\d+)\.(\d+)\.(\d+)
+//取信息中的中国手机号码
+(86)*0*13\d{9} 
+//提取信息中的中国邮政编码
+[1-9]{1}(\d+){5} 
+//提取信息中的浮点数（即小数）
+(-?\d*)\.?\d+ 
+//提取信息中的任何数字
+(-?\d*)(\.\d+)?
+//电话区号
+^0\d{2,3}$
+//腾讯 QQ 号
+^[1-9]*[1-9][0-9]*$ 
+//帐号（字母开头，允许 5-16 字节，允许字母数字下划线）
+^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
+//中文、英文、数字及下划线
 ^[\u4e00-\u9fa5_a-zA-Z0-9]+$
\ No newline at end of file
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2546\347\253\240 \345\215\225\344\276\213\346\250\241\345\274\217\344\270\216\345\244\232\347\272\277\347\250\213.md" "b/08 - Utils \345\267\245\345\205\267/\347\210\254\350\231\253/java.txt"
similarity index 100%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2546\347\253\240 \345\215\225\344\276\213\346\250\241\345\274\217\344\270\216\345\244\232\347\272\277\347\250\213.md"
rename to "08 - Utils \345\267\245\345\205\267/\347\210\254\350\231\253/java.txt"
diff --git "a/08 - Utils/\347\210\254\350\231\253/python.txt" "b/08 - Utils \345\267\245\345\205\267/\347\210\254\350\231\253/python.txt"
similarity index 92%
rename from "08 - Utils/\347\210\254\350\231\253/python.txt"
rename to "08 - Utils \345\267\245\345\205\267/\347\210\254\350\231\253/python.txt"
index 6bf19860..bebb81e2 100644
--- "a/08 - Utils/\347\210\254\350\231\253/python.txt"	
+++ "b/08 - Utils \345\267\245\345\205\267/\347\210\254\350\231\253/python.txt"	
@@ -1,20 +1,20 @@
-requests
-获取内容
-
-
-BeautifulSoup
-
-取元素
-3.1. 选择元素
-3.2. 获取名称
-3.3. 获取属性
-3.4. 获取内容
-3.5. 嵌套选择
-3.6. 子节点和子孙节点
-3.7. 父节点和祖先节点
-3.8. 兄弟节点
-
-PyQuery
- 
-取元素
-dom操作
+requests
+获取内容
+
+
+BeautifulSoup
+
+取元素
+3.1. 选择元素
+3.2. 获取名称
+3.3. 获取属性
+3.4. 获取内容
+3.5. 嵌套选择
+3.6. 子节点和子孙节点
+3.7. 父节点和祖先节点
+3.8. 兄弟节点
+
+PyQuery
+ 
+取元素
+dom操作
diff --git "a/08 - Utils/\350\260\267\346\255\214Chrome/crx/Isometric Contributions\347\233\264\350\247\202\350\241\241\351\207\217\344\275\240\347\232\204\345\267\245\344\275\234\351\207\217.crx" "b/08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/crx/Isometric Contributions\347\233\264\350\247\202\350\241\241\351\207\217\344\275\240\347\232\204\345\267\245\344\275\234\351\207\217.crx"
similarity index 100%
rename from "08 - Utils/\350\260\267\346\255\214Chrome/crx/Isometric Contributions\347\233\264\350\247\202\350\241\241\351\207\217\344\275\240\347\232\204\345\267\245\344\275\234\351\207\217.crx"
rename to "08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/crx/Isometric Contributions\347\233\264\350\247\202\350\241\241\351\207\217\344\275\240\347\232\204\345\267\245\344\275\234\351\207\217.crx"
diff --git "a/08 - Utils/\350\260\267\346\255\214Chrome/\345\274\200\345\217\221\350\200\205\345\267\245\345\205\267\351\252\232\346\223\215\344\275\234.md" "b/08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/\345\274\200\345\217\221\350\200\205\345\267\245\345\205\267\351\252\232\346\223\215\344\275\234.md"
similarity index 100%
rename from "08 - Utils/\350\260\267\346\255\214Chrome/\345\274\200\345\217\221\350\200\205\345\267\245\345\205\267\351\252\232\346\223\215\344\275\234.md"
rename to "08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/\345\274\200\345\217\221\350\200\205\345\267\245\345\205\267\351\252\232\346\223\215\344\275\234.md"
diff --git "a/08 - Utils/\350\260\267\346\255\214Chrome/\350\260\267\346\255\214\346\265\217\350\247\210\345\231\250\346\217\222\344\273\266.md" "b/08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/\350\260\267\346\255\214\346\265\217\350\247\210\345\231\250\346\217\222\344\273\266.md"
similarity index 97%
rename from "08 - Utils/\350\260\267\346\255\214Chrome/\350\260\267\346\255\214\346\265\217\350\247\210\345\231\250\346\217\222\344\273\266.md"
rename to "08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/\350\260\267\346\255\214\346\265\217\350\247\210\345\231\250\346\217\222\344\273\266.md"
index ab3d8b72..791f1251 100644
--- "a/08 - Utils/\350\260\267\346\255\214Chrome/\350\260\267\346\255\214\346\265\217\350\247\210\345\231\250\346\217\222\344\273\266.md"	
+++ "b/08 - Utils \345\267\245\345\205\267/\350\260\267\346\255\214Chrome/\350\260\267\346\255\214\346\265\217\350\247\210\345\231\250\346\217\222\344\273\266.md"	
@@ -1,121 +1,121 @@
-http://www.cnplugins.com/ 插件网
-
-convertio 转换工具 很无敌
-
-Clear Cache
-ColorPick Eyedropper
-Json-handle
-Advanced REST client
-EditThisCookie
-1、JSONview插件，将json数据美化；
-2、Wappalyzer插件，查看网站用了那些技术；
-3、Vue Devtools插件，可以查看vue整体的结构；
-
-
-Insight.io Octotree 升级版 可进行搜索 查找引用 类似于IDE
-
-clear Cache 清除浏览器缓存
-
-PostMan 接口请求模拟
-
-vimium  使用vim的方式操作浏览器，减少键盘与鼠标的切换使用
-
-https://www.jianshu.com/p/80a8f0bdd511
-
-### github 相关
-`Isometric Contributions` 3D 像素立体展示 GitHub 上的仓库提交记录。
-`octotree` 快捷导航，方便浏览。
-`GitHub Plus` 能够显示代码仓库的大小，以及其中每个文件的大小和下载链接。
-`GitHub Hovercard` Hovercard 插件支持的悬停位置更多，包括用户头像，仓库地址，Issue 链接，个人主页等。咱们还是用图说话比较直接：
-`Sourcegraph for GitHub` 代码搜索，查看引用，自动跳转，项目目录导航，这些 IDE 上常用的功能操作，借助 Sourcegraph 插件，都能帮你直接在线使用。如图：
-`Awesome Autocomplete for GitHub` GitHub 智能搜索插件。
-`Octo Mate` 展示项目大小，任意文件点击下载等
-
-`Stylish` +  `GitHub Dark` 夜间主题
-
-1. Surfingkeys
-在Chrome上，可以摆脱掉烦人的鼠标了。Vimium 升级版，我的最爱。
-
-
-2. Tampermonkey
-一千个司机眼中有一千个油猴。
-强大的脚本让你可以做很多很爽的事情。比如开车、百度网盘破解直接下载、VIP视频在线解析破解去广告等。
-
-
-3. 沙拉查词-网页划词翻译
-全能网页划词翻译，开放源码、功能丰富、超多词典、清爽快速、支持个性化设置
-详细信息删除。
-找了很久才找到的划词翻译软件，而且双击Ctrl还可以弹出查询翻译页面。用起来很爽。
-
-4. 掘金
-
-新标签页托管给掘金，快速获得专业内容。掘金已成为一种习惯。
-
-5. Imagus
-鼠标悬浮停留在图片上，自动弹出放大图片，不用再在新链接中打开看大图了。
-
-
-6. oneTab
-标签页打开太多的时候，占用内存而且怕关掉后回头找不到？oneTab完美解决这个问题。
-主要是用来缩减窗口，保存浏览记录。
-为了省内存？Chrome越来越吃内存？加内存条才是根本的解决办法。
-
-
-7. AutoPagerize
-专门需要Google、百度，点击下一页很烦。AutoPagerize让我不再需要点下一页。
-
-
-8. 谷歌访问助手
-如果你只要访问个谷歌或者上谷歌商店的话，不需要突破围墙的话，装这个插件可以满足基本使用了。免费而且速度还行。
-在我的酸酸乳被严打封锁期间，我是靠着这个插件熬下来的，且行且珍惜。良民万岁。
-
-
-9. Proxy SwitchyOmega
-HTTP、SOCKS5代理插件，轻松快捷地管理和切换多个代理设置。用过段时间，挺好用的。
-
-
-10. LastPass
-省掉很多记密码的烦恼。
-
-
-11. Insight.io for Github
-IDE like code intelligence and code search for GitHub by Insight.io.
-Github内看代码更方便，带高亮、跳转。
-
-
-12. GitZip for github
-It can make the sub-directories and files of github repository as zip and download it.
-不想Clone整个项目，只想下载单个文件或者单个文件夹时，用这个。
-
-
-13. Clear Cache
-一键清除缓存，可以少点很多步。
-
-
-14. User-Agent Switcher for Chrome
-Chrome可以转换为别的浏览器进行访问，如IE、Safari、360甚至iOS、 Android等移动浏览器，方便用户进行测试。
-
-
-15. Adblock Plus
-网页去广告，不用uBlock Origin 的原因是它太强力，有时候把我博客的评论部分都杀掉了。
-
-
-16. 微博图床
-一键将页面中的图片上传到微博，微博是个好图床。我一般用微博图床来拿HTTPS图片。
-
-
-17. 扩展管理器（Extension Manager）
-一键管理所有扩展，快速开启/禁用、批量闪电管理，智能排序，右键卸载、锁定、选项配置，角标提醒，大小布局随心配。快捷、简单、安全。
-当插件越来越多的时候，就需要个插件管理器了。这个管理器很方便，颜值不错。
-
-
-18. IDM Integration Module
-接管Chrome下载，使用IDM下载。一般在安装IDM的时候会自动安装Chrome的扩展。
-
-
-19. 惠惠购物助手
-每逢剁手节的时候，都要打开这个看看历史价。
-
-
-20. 有道云网页剪报
-一键保存网页内容，保存到有道云笔记里，我有时候将这个作为类似书签使用。
+http://www.cnplugins.com/ 插件网
+
+convertio 转换工具 很无敌
+
+Clear Cache
+ColorPick Eyedropper
+Json-handle
+Advanced REST client
+EditThisCookie
+1、JSONview插件，将json数据美化；
+2、Wappalyzer插件，查看网站用了那些技术；
+3、Vue Devtools插件，可以查看vue整体的结构；
+
+
+Insight.io Octotree 升级版 可进行搜索 查找引用 类似于IDE
+
+clear Cache 清除浏览器缓存
+
+PostMan 接口请求模拟
+
+vimium  使用vim的方式操作浏览器，减少键盘与鼠标的切换使用
+
+https://www.jianshu.com/p/80a8f0bdd511
+
+### github 相关
+`Isometric Contributions` 3D 像素立体展示 GitHub 上的仓库提交记录。
+`octotree` 快捷导航，方便浏览。
+`GitHub Plus` 能够显示代码仓库的大小，以及其中每个文件的大小和下载链接。
+`GitHub Hovercard` Hovercard 插件支持的悬停位置更多，包括用户头像，仓库地址，Issue 链接，个人主页等。咱们还是用图说话比较直接：
+`Sourcegraph for GitHub` 代码搜索，查看引用，自动跳转，项目目录导航，这些 IDE 上常用的功能操作，借助 Sourcegraph 插件，都能帮你直接在线使用。如图：
+`Awesome Autocomplete for GitHub` GitHub 智能搜索插件。
+`Octo Mate` 展示项目大小，任意文件点击下载等
+
+`Stylish` +  `GitHub Dark` 夜间主题
+
+1. Surfingkeys
+在Chrome上，可以摆脱掉烦人的鼠标了。Vimium 升级版，我的最爱。
+
+
+2. Tampermonkey
+一千个司机眼中有一千个油猴。
+强大的脚本让你可以做很多很爽的事情。比如开车、百度网盘破解直接下载、VIP视频在线解析破解去广告等。
+
+
+3. 沙拉查词-网页划词翻译
+全能网页划词翻译，开放源码、功能丰富、超多词典、清爽快速、支持个性化设置
+详细信息删除。
+找了很久才找到的划词翻译软件，而且双击Ctrl还可以弹出查询翻译页面。用起来很爽。
+
+4. 掘金
+
+新标签页托管给掘金，快速获得专业内容。掘金已成为一种习惯。
+
+5. Imagus
+鼠标悬浮停留在图片上，自动弹出放大图片，不用再在新链接中打开看大图了。
+
+
+6. oneTab
+标签页打开太多的时候，占用内存而且怕关掉后回头找不到？oneTab完美解决这个问题。
+主要是用来缩减窗口，保存浏览记录。
+为了省内存？Chrome越来越吃内存？加内存条才是根本的解决办法。
+
+
+7. AutoPagerize
+专门需要Google、百度，点击下一页很烦。AutoPagerize让我不再需要点下一页。
+
+
+8. 谷歌访问助手
+如果你只要访问个谷歌或者上谷歌商店的话，不需要突破围墙的话，装这个插件可以满足基本使用了。免费而且速度还行。
+在我的酸酸乳被严打封锁期间，我是靠着这个插件熬下来的，且行且珍惜。良民万岁。
+
+
+9. Proxy SwitchyOmega
+HTTP、SOCKS5代理插件，轻松快捷地管理和切换多个代理设置。用过段时间，挺好用的。
+
+
+10. LastPass
+省掉很多记密码的烦恼。
+
+
+11. Insight.io for Github
+IDE like code intelligence and code search for GitHub by Insight.io.
+Github内看代码更方便，带高亮、跳转。
+
+
+12. GitZip for github
+It can make the sub-directories and files of github repository as zip and download it.
+不想Clone整个项目，只想下载单个文件或者单个文件夹时，用这个。
+
+
+13. Clear Cache
+一键清除缓存，可以少点很多步。
+
+
+14. User-Agent Switcher for Chrome
+Chrome可以转换为别的浏览器进行访问，如IE、Safari、360甚至iOS、 Android等移动浏览器，方便用户进行测试。
+
+
+15. Adblock Plus
+网页去广告，不用uBlock Origin 的原因是它太强力，有时候把我博客的评论部分都杀掉了。
+
+
+16. 微博图床
+一键将页面中的图片上传到微博，微博是个好图床。我一般用微博图床来拿HTTPS图片。
+
+
+17. 扩展管理器（Extension Manager）
+一键管理所有扩展，快速开启/禁用、批量闪电管理，智能排序，右键卸载、锁定、选项配置，角标提醒，大小布局随心配。快捷、简单、安全。
+当插件越来越多的时候，就需要个插件管理器了。这个管理器很方便，颜值不错。
+
+
+18. IDM Integration Module
+接管Chrome下载，使用IDM下载。一般在安装IDM的时候会自动安装Chrome的扩展。
+
+
+19. 惠惠购物助手
+每逢剁手节的时候，都要打开这个看看历史价。
+
+
+20. 有道云网页剪报
+一键保存网页内容，保存到有道云笔记里，我有时候将这个作为类似书签使用。
diff --git "a/08 - Utils/\350\273\237\344\273\266.md" "b/08 - Utils \345\267\245\345\205\267/\350\273\237\344\273\266.md"
similarity index 96%
rename from "08 - Utils/\350\273\237\344\273\266.md"
rename to "08 - Utils \345\267\245\345\205\267/\350\273\237\344\273\266.md"
index d7b0bfd1..ad9bbd86 100644
--- "a/08 - Utils/\350\273\237\344\273\266.md"	
+++ "b/08 - Utils \345\267\245\345\205\267/\350\273\237\344\273\266.md"	
@@ -1,94 +1,94 @@
-https://juejin.im/post/5af0021e518825671547926e
-
-快速启动：WOX
-快速启动应用+文件搜索+各种实用插件（计算器、翻译、网页快速访问等）
-下载地址 https://github.com/Wox-launcher/Wox/releases
-文档位置 http://www.wox.one/]
-
-护眼宝 windows-Mac 
-
-adobe Flash Player
-
-WinRAR
-
-Google Chrome
-
-WampServer
-
-Xmind
-
-Wireshark
-
-baacloud
-
-winTop
-
-Clibor
-
-navicat
-
-Git
-
-IDE
-github 出的 https://atom.io/  插件 simplified-chinese-menu 汉化包 markdown-preview-enhanced md插件
-https://shd101wyy.github.io/markdown-preview-enhanced/#/zh-cn/installation
-
-Microsoft 的 vscode  https://code.visualstudio.com/ markdown-preview-enhanced md插件
-
-https://www.princexml.com/
-
-搜索工具：everything
-秒找电脑里的各种文件。与WOX完美集成。
-
-下载：IDM
-多线程下载HTTP类文件下载利器，杠杠的。Chrome 内的下载都托管给了IDM，可下载百度云离线文件，突破下载速度限制。
-
-截图：snipaste
-开源、免费的国产截图神器。给我最大的感受是截图更方便，且比QQ截图工具清晰很多。
-
-预览工具：QuickLook
-按下空格即可快速预览文件，微软商店内的免费应用。
-
-剪切板工具： Clibor > Ditto
-再也不用担心刚才复制的内容找不到了。
-
-结构化笔记：workflowy
-
-Markdown写作工具：Typora
-最好用的Markdown写作工具，所见即所得。
-
-贴图工具：PicGo
-支持多种图床，功能强大。
-
-看图工具：2345看图王
-
-压缩软件：BandZIP
-播放器：Splash
-录屏工具：LICEcap screentogif http://www.screentogif.com/?l=zh_cn 录制屏幕GIf
-比GifCam更好用
-
-文本编辑器：Sublime Atom
-对比Atom，Sublime主要是打开速度更快，感觉更清爽。
-
-数据库客户端：`DataGrip`
-一个客户端全搞定主流数据库。不用再装Navicat、plsql了。
-ps:DataGrip其实只是IDEA里一个集成功能，被单独抽离出来成了一个独立产品。
-
-
-SSH客户端：MobaXterm `Xshell5`
-集成SSH、SFTP、FTP等，一个全搞定。还可分屏等功能，好用。
-
-终端工具：Cmder
-丢弃掉Windows自带cmd窗口吧。
-
-API工具：Postman
-强大的API调试、Http请求的工具 。可自动同步个人请求记录。
-
-API管理平台
-Hitchhiker
-
-eoLinker
-
-apidocjs
-
-mac磁盘空间计算 www.omnigroup.com/omnidisksweeper
+https://juejin.im/post/5af0021e518825671547926e
+
+快速启动：WOX
+快速启动应用+文件搜索+各种实用插件（计算器、翻译、网页快速访问等）
+下载地址 https://github.com/Wox-launcher/Wox/releases
+文档位置 http://www.wox.one/]
+
+护眼宝 windows-Mac 
+
+adobe Flash Player
+
+WinRAR
+
+Google Chrome
+
+WampServer
+
+Xmind
+
+Wireshark
+
+baacloud
+
+winTop
+
+Clibor
+
+navicat
+
+Git
+
+IDE
+github 出的 https://atom.io/  插件 simplified-chinese-menu 汉化包 markdown-preview-enhanced md插件
+https://shd101wyy.github.io/markdown-preview-enhanced/#/zh-cn/installation
+
+Microsoft 的 vscode  https://code.visualstudio.com/ markdown-preview-enhanced md插件
+
+https://www.princexml.com/
+
+搜索工具：everything
+秒找电脑里的各种文件。与WOX完美集成。
+
+下载：IDM
+多线程下载HTTP类文件下载利器，杠杠的。Chrome 内的下载都托管给了IDM，可下载百度云离线文件，突破下载速度限制。
+
+截图：snipaste
+开源、免费的国产截图神器。给我最大的感受是截图更方便，且比QQ截图工具清晰很多。
+
+预览工具：QuickLook
+按下空格即可快速预览文件，微软商店内的免费应用。
+
+剪切板工具： Clibor > Ditto
+再也不用担心刚才复制的内容找不到了。
+
+结构化笔记：workflowy
+
+Markdown写作工具：Typora
+最好用的Markdown写作工具，所见即所得。
+
+贴图工具：PicGo
+支持多种图床，功能强大。
+
+看图工具：2345看图王
+
+压缩软件：BandZIP
+播放器：Splash
+录屏工具：LICEcap screentogif http://www.screentogif.com/?l=zh_cn 录制屏幕GIf
+比GifCam更好用
+
+文本编辑器：Sublime Atom
+对比Atom，Sublime主要是打开速度更快，感觉更清爽。
+
+数据库客户端：`DataGrip`
+一个客户端全搞定主流数据库。不用再装Navicat、plsql了。
+ps:DataGrip其实只是IDEA里一个集成功能，被单独抽离出来成了一个独立产品。
+
+
+SSH客户端：MobaXterm `Xshell5`
+集成SSH、SFTP、FTP等，一个全搞定。还可分屏等功能，好用。
+
+终端工具：Cmder
+丢弃掉Windows自带cmd窗口吧。
+
+API工具：Postman
+强大的API调试、Http请求的工具 。可自动同步个人请求记录。
+
+API管理平台
+Hitchhiker
+
+eoLinker
+
+apidocjs
+
+mac磁盘空间计算 www.omnigroup.com/omnidisksweeper
diff --git "a/08 - Utils/\351\230\277\351\207\214\344\272\221.md" "b/08 - Utils \345\267\245\345\205\267/\351\230\277\351\207\214\344\272\221.md"
similarity index 100%
rename from "08 - Utils/\351\230\277\351\207\214\344\272\221.md"
rename to "08 - Utils \345\267\245\345\205\267/\351\230\277\351\207\214\344\272\221.md"
diff --git "a/09 - J/01 - \350\246\201\347\202\271\346\261\207\346\200\273\351\233\206.md" "b/09 - J \351\235\242\347\273\217/01 - \350\246\201\347\202\271\346\261\207\346\200\273\351\233\206.md"
similarity index 100%
rename from "09 - J/01 - \350\246\201\347\202\271\346\261\207\346\200\273\351\233\206.md"
rename to "09 - J \351\235\242\347\273\217/01 - \350\246\201\347\202\271\346\261\207\346\200\273\351\233\206.md"
diff --git "a/09 - J/02 - \347\273\217\351\252\214.md" "b/09 - J \351\235\242\347\273\217/02 - \347\273\217\351\252\214.md"
similarity index 100%
rename from "09 - J/02 - \347\273\217\351\252\214.md"
rename to "09 - J \351\235\242\347\273\217/02 - \347\273\217\351\252\214.md"
diff --git "a/09 - J/03 - \344\270\200\344\270\252\344\270\244\345\271\264Java\347\232\204\351\235\242\350\257\225\346\200\273\347\273\223.md" "b/09 - J \351\235\242\347\273\217/03 - \344\270\200\344\270\252\344\270\244\345\271\264Java\347\232\204\351\235\242\350\257\225\346\200\273\347\273\223.md"
similarity index 100%
rename from "09 - J/03 - \344\270\200\344\270\252\344\270\244\345\271\264Java\347\232\204\351\235\242\350\257\225\346\200\273\347\273\223.md"
rename to "09 - J \351\235\242\347\273\217/03 - \344\270\200\344\270\252\344\270\244\345\271\264Java\347\232\204\351\235\242\350\257\225\346\200\273\347\273\223.md"
diff --git "a/09 - J/04 - \347\237\245\345\220\215\344\272\222\350\201\224\347\275\221\345\205\254\345\217\270\346\240\241\346\213\233 Java \345\274\200\345\217\221\345\262\227\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\350\247\243\346\236\220.md" "b/09 - J \351\235\242\347\273\217/04 - \347\237\245\345\220\215\344\272\222\350\201\224\347\275\221\345\205\254\345\217\270\346\240\241\346\213\233 Java \345\274\200\345\217\221\345\262\227\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\350\247\243\346\236\220.md"
similarity index 100%
rename from "09 - J/04 - \347\237\245\345\220\215\344\272\222\350\201\224\347\275\221\345\205\254\345\217\270\346\240\241\346\213\233 Java \345\274\200\345\217\221\345\262\227\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\350\247\243\346\236\220.md"
rename to "09 - J \351\235\242\347\273\217/04 - \347\237\245\345\220\215\344\272\222\350\201\224\347\275\221\345\205\254\345\217\270\346\240\241\346\213\233 Java \345\274\200\345\217\221\345\262\227\351\235\242\350\257\225\347\237\245\350\257\206\347\202\271\350\247\243\346\236\220.md"
diff --git a/09 - J/Java-base.pdf "b/09 - J \351\235\242\347\273\217/Java-base.pdf"
similarity index 100%
rename from 09 - J/Java-base.pdf
rename to "09 - J \351\235\242\347\273\217/Java-base.pdf"
diff --git a/09 - J/Occupation/40w.jpg "b/09 - J \351\235\242\347\273\217/Occupation/40w.jpg"
similarity index 100%
rename from 09 - J/Occupation/40w.jpg
rename to "09 - J \351\235\242\347\273\217/Occupation/40w.jpg"
diff --git a/09 - J/Occupation/m.md "b/09 - J \351\235\242\347\273\217/Occupation/m.md"
similarity index 94%
rename from 09 - J/Occupation/m.md
rename to "09 - J \351\235\242\347\273\217/Occupation/m.md"
index 4cd553f6..90e59ad7 100644
--- a/09 - J/Occupation/m.md	
+++ "b/09 - J \351\235\242\347\273\217/Occupation/m.md"	
@@ -1,11 +1,11 @@
-## 计划
-项目进度安排 甘特图
-完成任务后自由时间
-
-## 沟通
-需求 和 开发之前协调
-团队之间的协作
-
-## 氛围
-氛围，技术分享
-活动，团建
+## 计划
+项目进度安排 甘特图
+完成任务后自由时间
+
+## 沟通
+需求 和 开发之前协调
+团队之间的协作
+
+## 氛围
+氛围，技术分享
+活动，团建
diff --git a/09 - J/Occupation/suzhi.txt "b/09 - J \351\235\242\347\273\217/Occupation/suzhi.txt"
similarity index 100%
rename from 09 - J/Occupation/suzhi.txt
rename to "09 - J \351\235\242\347\273\217/Occupation/suzhi.txt"
diff --git "a/09 - J/Occupation/\344\270\215\350\246\201\345\216\273\350\277\231\346\240\267\347\232\204\345\205\254\345\217\270.md" "b/09 - J \351\235\242\347\273\217/Occupation/\344\270\215\350\246\201\345\216\273\350\277\231\346\240\267\347\232\204\345\205\254\345\217\270.md"
similarity index 100%
rename from "09 - J/Occupation/\344\270\215\350\246\201\345\216\273\350\277\231\346\240\267\347\232\204\345\205\254\345\217\270.md"
rename to "09 - J \351\235\242\347\273\217/Occupation/\344\270\215\350\246\201\345\216\273\350\277\231\346\240\267\347\232\204\345\205\254\345\217\270.md"
diff --git "a/09 - J/Occupation/\344\274\230\347\247\200\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\2047\345\244\247\347\211\271\346\200\247.md" "b/09 - J \351\235\242\347\273\217/Occupation/\344\274\230\347\247\200\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\2047\345\244\247\347\211\271\346\200\247.md"
similarity index 99%
rename from "09 - J/Occupation/\344\274\230\347\247\200\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\2047\345\244\247\347\211\271\346\200\247.md"
rename to "09 - J \351\235\242\347\273\217/Occupation/\344\274\230\347\247\200\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\2047\345\244\247\347\211\271\346\200\247.md"
index fe274454..ad7085ad 100644
--- "a/09 - J/Occupation/\344\274\230\347\247\200\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\2047\345\244\247\347\211\271\346\200\247.md"	
+++ "b/09 - J \351\235\242\347\273\217/Occupation/\344\274\230\347\247\200\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\2047\345\244\247\347\211\271\346\200\247.md"	
@@ -1,51 +1,51 @@
-http://www.codeceo.com/7-feature-programmer-need.html
-
-不是每一个程序员都能成为优秀的软件工程师。在过去的6年时间里，我在Ooyala、Quora和now Quip这3个创业公司面试过许许多多挺有发展潜力的“**种子选手**”，他们都有着5年以上的工作经验，并且曾为类似于谷歌这样的顶级技术公司服务过，但是就是搞砸了面试。毫无疑问，这些应聘人员都是不错的软件工程师，并且，他们甚至可能很擅长他们目前的工作。我之所以否决他们，只是因为我不认为他们能成为一名 **优秀** 的软件工程师。
-
-
-
-我多年的面试、培训和指导经验告诉我，具备一些特殊的品质能让软件工程师更容易在创业环境中取得成功。并且，这些品质在初创企业比在一个更成熟的公司更为关键。因为在一家初创企业：
-
-  1. 对产品、软件系统、团队及其文化有一个 **更为深刻** 的认识。
-  2. 成功更依赖于团队的表现，而非你自己。当然，如果在一家更大更成熟的公司，你的出色表现可能会成为你向上爬的踏脚石，但是在一家又小又新的公司，这根本无足挂齿。
-  3. 时间是关键因素，一方面是因为初创企业大多没有盈利，另一方面则是相较于那些盘根错节根深蒂固的老牌子公司，敏捷是他们最大的优势。时间有限就意味着你必须马不停蹄、加班加点，不能拖拖拉拉磨磨蹭蹭，也没有太多的时间供你挥霍在需要解决的问题上。
-我曾经有幸合作过的最有效率的软件工程师，有着熟练的技术和卓越的决策能力。他们大多内涵以下7种特质：
-
-### 1.系统调试技巧
-编程很大一部分时间其实是花在调试上的。有用户报告紧急问题，尽快将其修复；服务器的CPU出现负载高峰，尽快找出原因；数据莫名遭到破坏，尽快找出罪魁祸首，等等，都是你的工作。而良好的调试技巧则能让我们干净利落地解决这些问题。
-
-在调试时，我们应该用一种科学严谨的思维看待问题：先假设出错的地方，然后用最有效的方法或者最小可重现的情况去验证。此外调试过程还需要涉及各种的工具：发现瓶颈的分析器、单步执行代码的调试器、缩小回归原因范围的git bisect、交叉分析现状的UNIX命令行等等。
-
-不过，调试的应用范围不仅仅局限于技术领域。如果产品的增长率和使用率趋于平稳，我们该怎么假设和测试用户的行为以调试未来目标的重心？如果一个团队完不成他们的项目目标，我们该怎么调试才能知道导致项目流产的根本原因是技能不足，团队沟通不畅还是别的其他原因？招聘有的时候并不能尽如人意——你也知道，大家对于你是如何调试的过程并不能一目了然，不是吗？（关键：先从数据入手）
-
-### 2.勇于面对未知
-作为一名软件工程师，你需要经常专研那些又大又不熟悉的代码库：可能你需要好好研究你正在使用的那个开源工具的代码，才能随心所欲地挥洒自如；又或者你需要搞清楚其他团队成员写的代码，因为他没有修改时间等等。所以，快速驾驭大型代码库和精通相关区域的能力显得至关重要。而这种能力大部分来自于经验，通过阅读过大量代码积累的经验。还有一小部分则需要靠我们熟悉能搜索代码库、跳转到相关部分的工具了，以及会查找有关提交历史中的版本控制——这些捷径都能减少我们去了解新代码所需的时间。如果是在更为成熟的公司，这种勇于面对未知的精神也能让我们受益匪浅，不过不同的是，我们往往只需要专注并精通一部分代码库就能成果斐然了。
-
-当然，其他非代码领域有时候也需要你去探索。软件工程师常常需要接待客户、与销售人员讨论客户要求的可行性、给新的工程师培训，以及其他领域的很多你甚至完全没有接触过的事宜。在这些经历中成长，会让你受益无穷。
-
-### 3.对决策的务实态度
-可能在一家大规模公司，在代码审查和单元测试坚持己见有助于改善组织平衡。但是在一家初创公司，务实更重要，因为这能让团队快速完成任务。在这里我所说的务实指的是，知道什么时候应该积极辩论，而一旦有了决策，即便你再不同意，也能一丝不苟地作为团队的一份子认真执行。我曾经看到过因为编码风格而相互争执的现象，一个说在源代码起码得有80，100，或120个字符和大括号，而另一个觉得应该另起一行。呵呵。我深深地觉得，我们还不如把这些宝贵的时间和精力用到更重要的决策上。
-
-对决策的指导启发式评估应该侧重于“是否最终能增加团队成功的概率？”。很多因素都会对这个问题产生影响：产品的选择、架构的侧重点、团队的文化、人才结构，等等。我们在决策前最好限定讨论的时间，然后坚决执行，各抒己见。
-
-### 4.善于运用工具
-工欲善其事，必先利其器。工具的合理运用能让我们节约大量的时间，而时间则是我们最重要的资源。高效的工程师常常是那些善于利用工具的人，而这一点在创业公司尤为重要，因为这里的时间更紧迫。一些大型的组织可能会有专门的工具团队。而在初创公司，你善用工具的能力越强，完成的任务数量就越多。如果这些工具也为其他团队成员所接受，那么团队生产力将会发生乘数效应。
-
-### 5.牛逼的多面手
-初创企业早期出现的很多问题其实并不需要很专业的知识。具备的技能越多，在解决问题时遇到的瓶颈就越少，哪怕我们只是对这些技能有一个最基本的了解，还在摸索熟悉技能的过程中。如果前端Web工程师也装备了基本的服务器技术（server skill），那下次再遇到与此相关的问题就不必去请服务器工程师在百忙之中拨冗相见了。而后端工程师，假如会一些基本的HTML、CSS和JavaScript技能，就能将他所制作的工具设计成一个Web界面，以方便其他团队成员使用，从而不必因为缺乏Web设计师而裹足不前。一个成长中的工程师，应该是那种能顺利使用基本的数据分析工具分析实验数据，而不必受制于数据分析员的多面手。
-
-不过，有一种更欢迎“专家”的例外是，如果是在利基、重技术的环境里，例如启动数据库，那么拥有精深的专业知识工作效率会更高。而且，随着创业公司的发展，对于博而不精的多面手，越到后期，能取代你的人就越多。
-
-### 6.保持玩家心态，而非受害者心态
-在Fred Kofman的《Conscious Business》一书中，他描述了人们对待问题采取的两种不同态度。可以是受害者心态，怨天尤人，责怪他人的不是（项目时间太少、产品推出不当、以及和队友发生争执等等），通通归咎于外部原因。另一种就是玩家心态，审视自己的能力，一旦确定能做补救，毫不犹豫地贡献自己的能量。虽然短时间内，受害者心态能抚慰我们受伤的心情，但是从长远角度看，拥有玩家心态的人才能不断进步与发展。
-
-在创业公司工作压力是很大的，并且随着压力程度的增加，人们往往不但不能勇于承担个人责任，反而很容易陷入互相推诿以逃避责任的怪圈。而这样做，我不得不遗憾的说，最后终将导致失望和解聘。
-
-### 7.不断学习与回顾，持之以恒
-研究发现，只要我们有足够的激情和动力，上述种种品质通过学习和培养都是可以后天养成的。而学习这些技巧的所有能量来源于一种叫做“坚忍不拔”的品质。Angela Lee曾在她的TED演讲《The key to success? Grit》（《成功的关键：坚持》）中，提及这个概念：
-
-坚忍不拔是一种专注于长远目标的激情和毅力。坚持梦想，坚持未来，不是一天两天，也不是一周两周，更不是一个月两个月，而是持续多年，不畏艰辛、勇往直前，为了目标而奋斗。
-
-如果我们也能拥有这种坚忍不拔的品质，愿意投入时间回顾自己的所作所为，那么就能发现自己的薄弱之处和需要改进的地方。然后随着时间的推移，不断进步的你必将会成为一个更为优秀的软件工程师。在早期如果能得到大咖的指点迷津，尽早行进在正确的方向，也能让我们走的更远。
-
-上述这些技能即便是在更为成熟的公司也是能助你一臂之力的，不过在初创公司发挥的作用更大，原因么，上面也有提到，因为初创公司的时间更紧凑。当然，并不是说不具备这些技能就不是一个好的工程师了，这只能说明，可能你不大适合这种创业环境。但是，如果你立志要成为一个优秀的软件工程师，不要让上面这7点品质限制你的发展。那么，从现在开始，写个计划学习和提高这些技能吧！
+http://www.codeceo.com/7-feature-programmer-need.html
+
+不是每一个程序员都能成为优秀的软件工程师。在过去的6年时间里，我在Ooyala、Quora和now Quip这3个创业公司面试过许许多多挺有发展潜力的“**种子选手**”，他们都有着5年以上的工作经验，并且曾为类似于谷歌这样的顶级技术公司服务过，但是就是搞砸了面试。毫无疑问，这些应聘人员都是不错的软件工程师，并且，他们甚至可能很擅长他们目前的工作。我之所以否决他们，只是因为我不认为他们能成为一名 **优秀** 的软件工程师。
+
+
+
+我多年的面试、培训和指导经验告诉我，具备一些特殊的品质能让软件工程师更容易在创业环境中取得成功。并且，这些品质在初创企业比在一个更成熟的公司更为关键。因为在一家初创企业：
+
+  1. 对产品、软件系统、团队及其文化有一个 **更为深刻** 的认识。
+  2. 成功更依赖于团队的表现，而非你自己。当然，如果在一家更大更成熟的公司，你的出色表现可能会成为你向上爬的踏脚石，但是在一家又小又新的公司，这根本无足挂齿。
+  3. 时间是关键因素，一方面是因为初创企业大多没有盈利，另一方面则是相较于那些盘根错节根深蒂固的老牌子公司，敏捷是他们最大的优势。时间有限就意味着你必须马不停蹄、加班加点，不能拖拖拉拉磨磨蹭蹭，也没有太多的时间供你挥霍在需要解决的问题上。
+我曾经有幸合作过的最有效率的软件工程师，有着熟练的技术和卓越的决策能力。他们大多内涵以下7种特质：
+
+### 1.系统调试技巧
+编程很大一部分时间其实是花在调试上的。有用户报告紧急问题，尽快将其修复；服务器的CPU出现负载高峰，尽快找出原因；数据莫名遭到破坏，尽快找出罪魁祸首，等等，都是你的工作。而良好的调试技巧则能让我们干净利落地解决这些问题。
+
+在调试时，我们应该用一种科学严谨的思维看待问题：先假设出错的地方，然后用最有效的方法或者最小可重现的情况去验证。此外调试过程还需要涉及各种的工具：发现瓶颈的分析器、单步执行代码的调试器、缩小回归原因范围的git bisect、交叉分析现状的UNIX命令行等等。
+
+不过，调试的应用范围不仅仅局限于技术领域。如果产品的增长率和使用率趋于平稳，我们该怎么假设和测试用户的行为以调试未来目标的重心？如果一个团队完不成他们的项目目标，我们该怎么调试才能知道导致项目流产的根本原因是技能不足，团队沟通不畅还是别的其他原因？招聘有的时候并不能尽如人意——你也知道，大家对于你是如何调试的过程并不能一目了然，不是吗？（关键：先从数据入手）
+
+### 2.勇于面对未知
+作为一名软件工程师，你需要经常专研那些又大又不熟悉的代码库：可能你需要好好研究你正在使用的那个开源工具的代码，才能随心所欲地挥洒自如；又或者你需要搞清楚其他团队成员写的代码，因为他没有修改时间等等。所以，快速驾驭大型代码库和精通相关区域的能力显得至关重要。而这种能力大部分来自于经验，通过阅读过大量代码积累的经验。还有一小部分则需要靠我们熟悉能搜索代码库、跳转到相关部分的工具了，以及会查找有关提交历史中的版本控制——这些捷径都能减少我们去了解新代码所需的时间。如果是在更为成熟的公司，这种勇于面对未知的精神也能让我们受益匪浅，不过不同的是，我们往往只需要专注并精通一部分代码库就能成果斐然了。
+
+当然，其他非代码领域有时候也需要你去探索。软件工程师常常需要接待客户、与销售人员讨论客户要求的可行性、给新的工程师培训，以及其他领域的很多你甚至完全没有接触过的事宜。在这些经历中成长，会让你受益无穷。
+
+### 3.对决策的务实态度
+可能在一家大规模公司，在代码审查和单元测试坚持己见有助于改善组织平衡。但是在一家初创公司，务实更重要，因为这能让团队快速完成任务。在这里我所说的务实指的是，知道什么时候应该积极辩论，而一旦有了决策，即便你再不同意，也能一丝不苟地作为团队的一份子认真执行。我曾经看到过因为编码风格而相互争执的现象，一个说在源代码起码得有80，100，或120个字符和大括号，而另一个觉得应该另起一行。呵呵。我深深地觉得，我们还不如把这些宝贵的时间和精力用到更重要的决策上。
+
+对决策的指导启发式评估应该侧重于“是否最终能增加团队成功的概率？”。很多因素都会对这个问题产生影响：产品的选择、架构的侧重点、团队的文化、人才结构，等等。我们在决策前最好限定讨论的时间，然后坚决执行，各抒己见。
+
+### 4.善于运用工具
+工欲善其事，必先利其器。工具的合理运用能让我们节约大量的时间，而时间则是我们最重要的资源。高效的工程师常常是那些善于利用工具的人，而这一点在创业公司尤为重要，因为这里的时间更紧迫。一些大型的组织可能会有专门的工具团队。而在初创公司，你善用工具的能力越强，完成的任务数量就越多。如果这些工具也为其他团队成员所接受，那么团队生产力将会发生乘数效应。
+
+### 5.牛逼的多面手
+初创企业早期出现的很多问题其实并不需要很专业的知识。具备的技能越多，在解决问题时遇到的瓶颈就越少，哪怕我们只是对这些技能有一个最基本的了解，还在摸索熟悉技能的过程中。如果前端Web工程师也装备了基本的服务器技术（server skill），那下次再遇到与此相关的问题就不必去请服务器工程师在百忙之中拨冗相见了。而后端工程师，假如会一些基本的HTML、CSS和JavaScript技能，就能将他所制作的工具设计成一个Web界面，以方便其他团队成员使用，从而不必因为缺乏Web设计师而裹足不前。一个成长中的工程师，应该是那种能顺利使用基本的数据分析工具分析实验数据，而不必受制于数据分析员的多面手。
+
+不过，有一种更欢迎“专家”的例外是，如果是在利基、重技术的环境里，例如启动数据库，那么拥有精深的专业知识工作效率会更高。而且，随着创业公司的发展，对于博而不精的多面手，越到后期，能取代你的人就越多。
+
+### 6.保持玩家心态，而非受害者心态
+在Fred Kofman的《Conscious Business》一书中，他描述了人们对待问题采取的两种不同态度。可以是受害者心态，怨天尤人，责怪他人的不是（项目时间太少、产品推出不当、以及和队友发生争执等等），通通归咎于外部原因。另一种就是玩家心态，审视自己的能力，一旦确定能做补救，毫不犹豫地贡献自己的能量。虽然短时间内，受害者心态能抚慰我们受伤的心情，但是从长远角度看，拥有玩家心态的人才能不断进步与发展。
+
+在创业公司工作压力是很大的，并且随着压力程度的增加，人们往往不但不能勇于承担个人责任，反而很容易陷入互相推诿以逃避责任的怪圈。而这样做，我不得不遗憾的说，最后终将导致失望和解聘。
+
+### 7.不断学习与回顾，持之以恒
+研究发现，只要我们有足够的激情和动力，上述种种品质通过学习和培养都是可以后天养成的。而学习这些技巧的所有能量来源于一种叫做“坚忍不拔”的品质。Angela Lee曾在她的TED演讲《The key to success? Grit》（《成功的关键：坚持》）中，提及这个概念：
+
+坚忍不拔是一种专注于长远目标的激情和毅力。坚持梦想，坚持未来，不是一天两天，也不是一周两周，更不是一个月两个月，而是持续多年，不畏艰辛、勇往直前，为了目标而奋斗。
+
+如果我们也能拥有这种坚忍不拔的品质，愿意投入时间回顾自己的所作所为，那么就能发现自己的薄弱之处和需要改进的地方。然后随着时间的推移，不断进步的你必将会成为一个更为优秀的软件工程师。在早期如果能得到大咖的指点迷津，尽早行进在正确的方向，也能让我们走的更远。
+
+上述这些技能即便是在更为成熟的公司也是能助你一臂之力的，不过在初创公司发挥的作用更大，原因么，上面也有提到，因为初创公司的时间更紧凑。当然，并不是说不具备这些技能就不是一个好的工程师了，这只能说明，可能你不大适合这种创业环境。但是，如果你立志要成为一个优秀的软件工程师，不要让上面这7点品质限制你的发展。那么，从现在开始，写个计划学习和提高这些技能吧！
diff --git "a/09 - J/Occupation/\347\250\213\345\272\217\345\221\230\347\264\240\350\264\250.jpg" "b/09 - J \351\235\242\347\273\217/Occupation/\347\250\213\345\272\217\345\221\230\347\264\240\350\264\250.jpg"
similarity index 100%
rename from "09 - J/Occupation/\347\250\213\345\272\217\345\221\230\347\264\240\350\264\250.jpg"
rename to "09 - J \351\235\242\347\273\217/Occupation/\347\250\213\345\272\217\345\221\230\347\264\240\350\264\250.jpg"
diff --git "a/09 - J/Occupation/\347\264\240\350\264\250\350\246\201\346\261\202.jpg" "b/09 - J \351\235\242\347\273\217/Occupation/\347\264\240\350\264\250\350\246\201\346\261\202.jpg"
similarity index 100%
rename from "09 - J/Occupation/\347\264\240\350\264\250\350\246\201\346\261\202.jpg"
rename to "09 - J \351\235\242\347\273\217/Occupation/\347\264\240\350\264\250\350\246\201\346\261\202.jpg"
diff --git "a/09 - J/Occupation/\350\201\214\344\270\232\350\247\204\345\210\222.jpg" "b/09 - J \351\235\242\347\273\217/Occupation/\350\201\214\344\270\232\350\247\204\345\210\222.jpg"
similarity index 100%
rename from "09 - J/Occupation/\350\201\214\344\270\232\350\247\204\345\210\222.jpg"
rename to "09 - J \351\235\242\347\273\217/Occupation/\350\201\214\344\270\232\350\247\204\345\210\222.jpg"
diff --git "a/09 - J/Occupation/\350\226\252\350\265\204\344\275\223\347\263\273.md" "b/09 - J \351\235\242\347\273\217/Occupation/\350\226\252\350\265\204\344\275\223\347\263\273.md"
similarity index 98%
rename from "09 - J/Occupation/\350\226\252\350\265\204\344\275\223\347\263\273.md"
rename to "09 - J \351\235\242\347\273\217/Occupation/\350\226\252\350\265\204\344\275\223\347\263\273.md"
index 7e088e82..a1a236d0 100644
--- "a/09 - J/Occupation/\350\226\252\350\265\204\344\275\223\347\263\273.md"	
+++ "b/09 - J \351\235\242\347\273\217/Occupation/\350\226\252\350\265\204\344\275\223\347\263\273.md"	
@@ -1,29 +1,29 @@
-**携程** 20-35W T4 研究生或一年以上工作经验
-**薪资结构**
-12薪+2-4个月年终奖，普遍每半年发1.5个月。年终奖分两次发放，年中、年末各一次。
-**晋升流程**
-携程的绩效考核采取5分制，划分为A、B、C、D四个等级，对应的分数分别是4.2+、3.2+、2.8+、2.8-。
-其中5%的人能拿到A，60%的人拿B，30%的人拿C，5%的人拿D。
-对应的年终奖分别为2个月、1.5个月、1个月和0个月。晋升方式上则比较传统，一般都是由直线经理提名，评审委员会进行评估。
-
-**新美大** 20-25W 1-3年 毕业生或工作至少一年
-**薪资结构**
-12薪+每个季度发四分之一左右绩效+1-3个月年终奖，通常拿14、15薪的人比较多。
-**晋升流程**
-新美大的绩效考核也和腾讯一样，划分S、A、B、C四个等级，
-不同的是内部大部分员工会被安排在B级，S、A一般作为激励方式存在。
-四个等级对应的人数比例分别为5%，25%，65%，5%。对应的绩效分数分别是：1.2、1.1、1、0.8。
-晋升和调薪都是一年两次，年初会做一次普调，薪资涨幅8%左右，年中会给年初没有涨薪成功的人再做一些调整，特别优秀的人也可能有2次调薪的机会。
-晋升的基本标准是上一次的晋升时间大于等于1年（对应级别不同时间不同），绩效高于平均数，一年以内不能有C（连续两个Q绩效C就要末位淘汰）。
-晋升途径一般有两种，比较常见的是自助申报，比较特殊的是由直属经理特别申报，需要通过部门总监的审批。申报通过后，2-3以上要参加答辩。为了保证公平公正，上海的员工答辩时一定要有一个北京的评审官，反之亦然。
-
-**阿里** P5-P6 优秀应届毕业生或至少2年工作经验
-**薪酬结构**
-阿里的薪资一般按13薪+0-6个月奖金+合理有效的行权方案进行发放，
-年终奖金采取1、3、6原则，即60%的人能拿到3.5，30% 的人拿3.75，10% 的人拿3.25，绩效好的团队整个都拿3.75的情况也有。
-（注：3.75代表"部分超出期望"，3.5代表"符合期望"，3.25代表"需要提高"。）
-所以，在BAT这种类型的公司里，找好团队找好坑很重要，短期内这决定了你和同职级员工之间的薪资差异，长远看也将决定你在这家公司能走多远、爬多高。
-**晋升流程**
-和腾讯一样，阿里也是一年有两次晋升机会，其中7、8月是比较核心层级的晋升，如P7、P8、P9，年底则是较低级别的。
-考核因素是上一年的绩效分数+直属领导的打分+晋升委员会打分，这里的委员会一般由直属领导+合作方的高管+懂业务的HRG组成。（HRG：HR多面手，base在业务下面）
-晋升标准：绩效满足3.75、主管提名、技术答辩通过。
+**携程** 20-35W T4 研究生或一年以上工作经验
+**薪资结构**
+12薪+2-4个月年终奖，普遍每半年发1.5个月。年终奖分两次发放，年中、年末各一次。
+**晋升流程**
+携程的绩效考核采取5分制，划分为A、B、C、D四个等级，对应的分数分别是4.2+、3.2+、2.8+、2.8-。
+其中5%的人能拿到A，60%的人拿B，30%的人拿C，5%的人拿D。
+对应的年终奖分别为2个月、1.5个月、1个月和0个月。晋升方式上则比较传统，一般都是由直线经理提名，评审委员会进行评估。
+
+**新美大** 20-25W 1-3年 毕业生或工作至少一年
+**薪资结构**
+12薪+每个季度发四分之一左右绩效+1-3个月年终奖，通常拿14、15薪的人比较多。
+**晋升流程**
+新美大的绩效考核也和腾讯一样，划分S、A、B、C四个等级，
+不同的是内部大部分员工会被安排在B级，S、A一般作为激励方式存在。
+四个等级对应的人数比例分别为5%，25%，65%，5%。对应的绩效分数分别是：1.2、1.1、1、0.8。
+晋升和调薪都是一年两次，年初会做一次普调，薪资涨幅8%左右，年中会给年初没有涨薪成功的人再做一些调整，特别优秀的人也可能有2次调薪的机会。
+晋升的基本标准是上一次的晋升时间大于等于1年（对应级别不同时间不同），绩效高于平均数，一年以内不能有C（连续两个Q绩效C就要末位淘汰）。
+晋升途径一般有两种，比较常见的是自助申报，比较特殊的是由直属经理特别申报，需要通过部门总监的审批。申报通过后，2-3以上要参加答辩。为了保证公平公正，上海的员工答辩时一定要有一个北京的评审官，反之亦然。
+
+**阿里** P5-P6 优秀应届毕业生或至少2年工作经验
+**薪酬结构**
+阿里的薪资一般按13薪+0-6个月奖金+合理有效的行权方案进行发放，
+年终奖金采取1、3、6原则，即60%的人能拿到3.5，30% 的人拿3.75，10% 的人拿3.25，绩效好的团队整个都拿3.75的情况也有。
+（注：3.75代表"部分超出期望"，3.5代表"符合期望"，3.25代表"需要提高"。）
+所以，在BAT这种类型的公司里，找好团队找好坑很重要，短期内这决定了你和同职级员工之间的薪资差异，长远看也将决定你在这家公司能走多远、爬多高。
+**晋升流程**
+和腾讯一样，阿里也是一年有两次晋升机会，其中7、8月是比较核心层级的晋升，如P7、P8、P9，年底则是较低级别的。
+考核因素是上一年的绩效分数+直属领导的打分+晋升委员会打分，这里的委员会一般由直属领导+合作方的高管+懂业务的HRG组成。（HRG：HR多面手，base在业务下面）
+晋升标准：绩效满足3.75、主管提名、技术答辩通过。
diff --git "a/09 - J/Occupation/\351\234\200\350\246\201\347\252\201\347\240\264\347\232\204\346\212\200\346\234\257\350\246\201\347\202\271.md" "b/09 - J \351\235\242\347\273\217/Occupation/\351\234\200\350\246\201\347\252\201\347\240\264\347\232\204\346\212\200\346\234\257\350\246\201\347\202\271.md"
similarity index 97%
rename from "09 - J/Occupation/\351\234\200\350\246\201\347\252\201\347\240\264\347\232\204\346\212\200\346\234\257\350\246\201\347\202\271.md"
rename to "09 - J \351\235\242\347\273\217/Occupation/\351\234\200\350\246\201\347\252\201\347\240\264\347\232\204\346\212\200\346\234\257\350\246\201\347\202\271.md"
index 70bd9597..a97a05a3 100644
--- "a/09 - J/Occupation/\351\234\200\350\246\201\347\252\201\347\240\264\347\232\204\346\212\200\346\234\257\350\246\201\347\202\271.md"	
+++ "b/09 - J \351\235\242\347\273\217/Occupation/\351\234\200\350\246\201\347\252\201\347\240\264\347\232\204\346\212\200\346\234\257\350\246\201\347\202\271.md"	
@@ -1,287 +1,287 @@
-## 一、源码分析
-源码分析是一种临界知识，掌握了这种临界知识，能不变应万变，源码分析对于很多人来说很枯燥，生涩难懂。
-
-源码阅读，我觉得最核心有三点：技术基础+强烈的求知欲+耐心。
-
-我认为是阅读源码的最核心驱动力。我见到绝大多数程序员，对学习的态度，基本上就是这几个层次(很偏激哦)：
-
-1. 只关注项目本身，不懂就baidu一下。
-2. 除了做好项目，还会阅读和项目有关的技术书籍，看wikipedia。
-3. 除了阅读和项目相关的书外，还会阅读IT行业的书，比如学Java时，还会去了解函数语言，如LISP。
-4. 找一些开源项目看看，大量试用第三方框架，还会写写demo。
-5. 阅读基础框架、J2EE规范、Debug服务器内核。
-大多数程序都是第1种，到第5种不光需要浓厚的兴趣，还需要勇气：我能读懂吗？其实，你能够读懂的
-
-耐心，真的很重要。因为你极少看到阅读源码的指导性文章或书籍，也没有人要求或建议你读。你读的过程中经常会卡住，而一卡主可能就陷进了迷宫。这时，你需要做的，可能是暂时中断一下，再从外围看看它：如API结构、框架的设计图。
-
-下图是我总结出目前最应该学习的源码知识点：
-
-源码分析专题
-  常用设计模式
-    01 Proxy代理模式
-    02 Factory工厂模式
-    03 Singleton单例模式
-    04 Delegate委派模式
-    05 Strategy策略模式                 可以在运行时选择算法的行为
-    06 Prototype原型模式                避免客户端应用程序中的对象生成器的子类，
-    07 TemplateMethod模板方法模式       模板方法为算法定义了一个框架。 算法子类为空白部分提供实现。
-  Spring5  
-    01 IOC容器设计原理及高级特性
-    02 AOP设计原理
-    03 FactoryBean 和 BeanFactory
-    04 Spring事务处理机制
-    05 基于SpringJDBC手写ORM框架
-    06 SpringMVC9大组件
-    07 手写实现SpringMVC框架
-    08 SpringMVC与Struts2对比分析
-    09 Spring5新特性
-  MyBatis
-    01 代码自动生成器
-    02 Mybatis关联查询、嵌套查询
-    03 缓存使用场景及选择策略
-    04 Spring集成下的SqlSession与Mapper
-    05 MyBatis的事务
-    06 分析MyBatis的动态代理的真正实现
-    07 手写实现Mini版的MyBatis
-
-## 二、分布式架构
-分布式系统是一个古老而宽泛的话题，而近几年因为 “大数据” 概念的兴起，又焕发出了新的青春与活力。除此之外，分布式系统也是一门理论模型与工程技法并重的学科内容。相比于机器学习这样的研究方向，学习分布式系统的同学往往会感觉：“入门容易，深入难”。的确，学习分布式系统几乎不需要太多数学知识。
-
-分布式系统是一个复杂且宽泛的研究领域，学习一两门在线课程，看一两本书可能都是不能完全覆盖其所有内容的。
-
-总的来说，分布式系统要做的任务就是把多台机器有机的组合、连接起来，让其协同完成一件任务，可以是计算任务，也可以是存储任务。如果一定要给近些年的分布式系统研究做一个分类的话，我个人认为大概可以包括三大部分：
-
-分布式存储系统
-分布式计算系统
-分布式管理系统
-下图是我总结近几年目前分布式最主流的技术：
-
-分布式专题体系：
-  分布式架构原理
-    01 分布式架构演进过程
-    02 如何把应用从单机扩展到分布式 https://blog.csdn.net/yp1125/article/details/79125477
-    03 CDN加速静态文件访问
-    04 系统监控、容灾、储存动态扩容
-    05 架构设计及业务驱动分化
-    06 CAP、Base理论及其应用
-  分布式架构策略
-    01 分布式架构网络通信原理剖析
-    02 通信协议中的序列化和反序列化
-    03 基于框架的RPC技术WebService/RMI/Hession
-    04 深入分析Zookeeper在disconf配置中心的应用
-    05 基于Zookeeper实现分布式服务器动态上下线感知
-    06 深入分析Zookeeper Zab 协议及选举机制源码解读
-    07 Dubbo管理中心及监控平台安装部署
-    08 基于Dubbo的分布式系统架构实战
-    09 Dubbo容错机制及搞扩展性分析
-  分布式架构中间件
-    01 分布式消息通信ActiveMQ/Kafka/RabbitMQ
-    02 Redis主从复制原理及无磁盘复制分析
-    03 图解Redis中AOP和RDB持久化策略的原理
-    04 MongoDB企业级集群解决方案
-    05 MongoDB数据分析，转存及恢复策略
-    06 基于OpenResty部署应用层Nginx以及Nginx+Lua实战
-    07 Nginx反向代理服务器及负载均衡服务配置实战
-    08 基于Netty实现高性能IM聊天
-    09 基于Netty实现Dubbo多协议通信支持
-    10 Netty无锁化串行设计及高并发处理机制
-  分布式架构实践
-    01 分布式全局ID生成方案
-    02 Session跨域共享及企业级单点登录解决方案实战
-    03 分布式事务解决方案实战
-    04 高并发下的服务降级、限流实战
-    05 基于分布式架构下分布式锁的解决方案实战
-    06 分布式架构下实现分布式定时调度
-
-
-## 三、微服务
-当前微服务很热，大家都号称在使用微服务架构，但究竟什么是微服务架构？微服务架构是不是发展趋势？对于这些问题，我们都缺乏清楚的认识。
-
-为解决单体架构下的各种问题，微服务架构应运而生。与其构建一个臃肿庞大、难以驯服的怪兽，还不如及早将服务拆分。微服务的核心思想便是服务拆分与解耦，降低复杂性。微服务强调将功能合理拆解，尽可能保证每个服务的功能单一，按照单一责任原则（Single Responsibility Principle）明确角色。 将各个服务做轻，从而做到灵活、可复用，亦可根据各个服务自身资源需求，单独布署，单独作横向扩展。
-
-下图是我总结出微服务需要学习的知识点：
-
-微服务专题
-  微框架
-    01 与微服务之间的关系
-    02 热部署实现
-    03 核心组件 ：Starter、Actuator、AutoConfiguration、Cli
-    04 继承MyBatis实现多数据源路由实战、继承Dubbo实战、继承Redis缓存实战
-    05 继承Swagger2构建API管理及测试体系
-    06 实现多环境配置动态解析
-  Spring Cloud
-    01 Eureka注册中心
-    02 Ribbon继承REST实现负载均衡
-    03 Fegion声明式服务调用
-    04 Hystrix服务熔断降级方式
-    05 Zuul实现微服务网关
-    06 Config分布式统一配置中心
-    07 Sleuth调用链路跟踪
-    08 EUS消息总线
-    09 基于Hystrix实现接口实现降级
-    10 继承Spring Cloud实现统一整合方案
-  Docker虚拟化
-    01 Docker的镜像、仓库、容器
-    02 Docker File构建的LNMP环境部署个人博客WordPress
-    03 Docker Compose构建的LNMP环境部署个人博客WordPress
-    04 Docker网路组成、路由互联、Openvswitch
-    05 基于Swarm构建Docker集群实战
-    06 KUbernetes简介
-  微服务架构
-    01 SOA架构和微服务架构之间的区别和联系
-    02 如何设计微服务及其设计原理
-    03 解惑Spring Boot流行因素及能够解决什么问题
-    04 什么是Spring Cloud,为何要选择 Spring Cloud
-    05 基于全局分析Spring Cloud各个组件所解决的问题
-
-## 四、性能优化
-不管是应付前端面试还是改进产品体验，性能优化都是躲不开的话题。
-
-优化的目的是让用户有“快”的感受，那如何让用户感受到快呢？
-
-加载速度真的很快，用户打开输入网址按下回车立即看到了页面
-加载速度并没有变快，但用户感觉你的网站很快
-性能优化取决于多个因素，包括垃圾收集、虚拟机和底层操作系统（OS）设置。有多个工具可供开发人员进行分析和优化时使用，你可以通过阅读 Java Tools for Source Code Optimization and Analysis 来学习和使用它们。
-
-必须要明白的是，没有两个应用程序可以使用相同的优化方式，也没有完美的优化 java 应用程序的参考路径。使用最佳实践并且坚持采用适当的方式处理性能优化。想要达到真正最高的性能优化，你作为一个 Java 开发人员，需要对 Java 虚拟机（JVM）和底层操作系统有正确的理解。
-
-以上五大知识体系是我从业多年总结出来的经验，都是当前最主流的技术。想学习这些技术的朋友可以加群：478030634。群里会分享这些技术知识点供大家学习免费下载
-
-下图是我总结性能优化应该学习理解的几大知识体系：
-
-性能优化
-  理解性能优化
-    01 性能基准
-    02 性能优化到底是什么
-    03 衡量维度
-  JVM调优
-    01 知其然，知其所以然
-    02 什么是JVM运行时数据区
-    03 什么是JVM内存模型 JMM
-    04 各垃圾回收器使用场景（Thoughput/CMS）
-    05 理解GC日志，从日志看端倪
-    06 实战MAT分析dump文件
-  Tomcat调优
-    01 How it work？探查Tomcat的运行机制及框架
-    02 分析Tomcat线程模型
-    03 Tomcat系统参数认识及调优
-    04 基准测试
-  Mysql调优
-    01 理解Mysql底层 B+ Tree 机制
-    02 Sql执行计划详解
-    03 索引优化详解
-    04 Sql语句优化
-
-## 五、Java工程化
-工欲善其事，必先利其器，不管是小白，还是资深开发，都需要先选择好的工具。提升开发效率何团队协作效率。让自己有更多时间来思考。
-
-工程化专题
-  Maven
-    01 生成可执行jar、理解Scope生成最精确的jar
-    02 类冲突、包依赖 NoClassDefFoundError问题定位及解决
-    03 全面理解Maven的lifecycle、Phase、Goal
-    04 架构师必备之Maven生成Archetype
-    05 Maven流行插件实战、手写自己的插件
-    06 Nexus使用、上传、配置
-    07 对比Gradle
-  Jenkins
-    01 搭建Jenkins自动部署环境
-    02 Jenkins继承Maven、git实现自动部署
-    03 test\pre\production多环节发布
-    04 Jenkins多环境配置、权限管理及插件使用
-  Sonar
-    01 使用Sonar进行代码质量管理
-    02 关于代码检查工具FindBugs/PMD的运用
-    03 SonarQube代码质量管理平台安装及使用
-    04 使用Jenkins与Sonar集成对代码进行持续检测
-    05 Idea与Sonar集合的使用
-  Git
-    01 什么是Git以及Git的工作原理
-    02 Git常用命令Best practise（避坑教学）
-    03 Git冲突怎么引起的， 如何解决
-    04 架构师职责：Git flow规范团队git使用规程
-    05 团队案例分享（买不到才是最贵的）
-
-### 并发
-  并发基础
-    01 线程的起源、优势、实现
-    02 共享内存、缓存一致性，MESI协议
-    03 自旋锁、重量级锁、偏向锁
-    04 一致性模型
-    05 JMM内存模型
-  线程实现
-    01 synchronized、volatile关键字
-    02 happens-before语义
-    03 线程的实现方式
-    04 wait/notify
-    05 Thread.join
-    06 ThreadLocal
-  并发框架
-    01 核心机制AQS
-    02 重入锁ReentrantLock
-    03 线程锁synchronized及Locks
-    04 并发工具类CountDownLatch
-    05 线程安全集合ConcurrentHashMap
-    06 线程池及原理
-  其他
-    01 Fork/join
-    02 阻塞队列
-    03 原子操作Atomic
-
-### 电商项目实战
-
-  用户认证
-    01 用户注册
-    02 SSO单点登录
-    03 第三方登录
-    04 UI页面拦截
-    05 业务拦截
-  店铺、商品
-    01 ElasticSearch实现大数据聚合检索
-    02 Hadoop环境搭建
-    03 动静分离
-    04 店铺管理
-    05 商品管理
-  订单、支付
-    01 订单号统一生成规则
-    02 下单流程管理
-    03 库存管理
-    04 购物车
-    05 优惠券支付
-    06 积分支付
-    07 第三方支付
-  数据统计分析
-    01 用户行为分析
-    02 行业分析
-    03 区域分析
-  通知推送
-    01 融云推送
-    02 消息中间件
-    03 用户群聊
-    04 点对点聊天
-    05 文件断点续传
-
-next：
-
-  **JMS** JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
-  Web Service WSDL SOAP
-
-  **Weblogic** WebLogic是美国Oracle公司出品的一个application server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
-
-  **SOA** 面向服务的架构（SOA）是一个组件模型，它将应用程序的不同功能单元（称为服务）通过这些服务之间定义良好的接口和契约联系起来。接口是采用中立的方式进行定义的，它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种各样的系统中的服务可以以一种统一和通用的方式进行交互。
-
-  各种数据结构：红黑树，二叉树，平衡树，B-树，B+树，2-3-4树，线性表，hash表，图，堆都了解了吗？各种排序能写吗？
-
-  HashMap的源码都看明白了吗？
-
-  多线程精通了吗？分布式架构，各种数据库，NOSQL都精通了吗？明白底层实现吗？
-
-  各种设计模式，工厂，策略，代理等等能运用到项目中吗？
-
-  能设计一个秒杀系统吗？保证100万在线点抢购网站不挂掉吗？
-
-  能设计一个抢红包系统吗？保证1000万级在线，服务不至于挂掉。
-
-  编译原理都知道吗？
-
-  大数据，云计算，人工智能，各种搜索引擎，爬虫会写吗？
+## 一、源码分析
+源码分析是一种临界知识，掌握了这种临界知识，能不变应万变，源码分析对于很多人来说很枯燥，生涩难懂。
+
+源码阅读，我觉得最核心有三点：技术基础+强烈的求知欲+耐心。
+
+我认为是阅读源码的最核心驱动力。我见到绝大多数程序员，对学习的态度，基本上就是这几个层次(很偏激哦)：
+
+1. 只关注项目本身，不懂就baidu一下。
+2. 除了做好项目，还会阅读和项目有关的技术书籍，看wikipedia。
+3. 除了阅读和项目相关的书外，还会阅读IT行业的书，比如学Java时，还会去了解函数语言，如LISP。
+4. 找一些开源项目看看，大量试用第三方框架，还会写写demo。
+5. 阅读基础框架、J2EE规范、Debug服务器内核。
+大多数程序都是第1种，到第5种不光需要浓厚的兴趣，还需要勇气：我能读懂吗？其实，你能够读懂的
+
+耐心，真的很重要。因为你极少看到阅读源码的指导性文章或书籍，也没有人要求或建议你读。你读的过程中经常会卡住，而一卡主可能就陷进了迷宫。这时，你需要做的，可能是暂时中断一下，再从外围看看它：如API结构、框架的设计图。
+
+下图是我总结出目前最应该学习的源码知识点：
+
+源码分析专题
+  常用设计模式
+    01 Proxy代理模式
+    02 Factory工厂模式
+    03 Singleton单例模式
+    04 Delegate委派模式
+    05 Strategy策略模式                 可以在运行时选择算法的行为
+    06 Prototype原型模式                避免客户端应用程序中的对象生成器的子类，
+    07 TemplateMethod模板方法模式       模板方法为算法定义了一个框架。 算法子类为空白部分提供实现。
+  Spring5  
+    01 IOC容器设计原理及高级特性
+    02 AOP设计原理
+    03 FactoryBean 和 BeanFactory
+    04 Spring事务处理机制
+    05 基于SpringJDBC手写ORM框架
+    06 SpringMVC9大组件
+    07 手写实现SpringMVC框架
+    08 SpringMVC与Struts2对比分析
+    09 Spring5新特性
+  MyBatis
+    01 代码自动生成器
+    02 Mybatis关联查询、嵌套查询
+    03 缓存使用场景及选择策略
+    04 Spring集成下的SqlSession与Mapper
+    05 MyBatis的事务
+    06 分析MyBatis的动态代理的真正实现
+    07 手写实现Mini版的MyBatis
+
+## 二、分布式架构
+分布式系统是一个古老而宽泛的话题，而近几年因为 “大数据” 概念的兴起，又焕发出了新的青春与活力。除此之外，分布式系统也是一门理论模型与工程技法并重的学科内容。相比于机器学习这样的研究方向，学习分布式系统的同学往往会感觉：“入门容易，深入难”。的确，学习分布式系统几乎不需要太多数学知识。
+
+分布式系统是一个复杂且宽泛的研究领域，学习一两门在线课程，看一两本书可能都是不能完全覆盖其所有内容的。
+
+总的来说，分布式系统要做的任务就是把多台机器有机的组合、连接起来，让其协同完成一件任务，可以是计算任务，也可以是存储任务。如果一定要给近些年的分布式系统研究做一个分类的话，我个人认为大概可以包括三大部分：
+
+分布式存储系统
+分布式计算系统
+分布式管理系统
+下图是我总结近几年目前分布式最主流的技术：
+
+分布式专题体系：
+  分布式架构原理
+    01 分布式架构演进过程
+    02 如何把应用从单机扩展到分布式 https://blog.csdn.net/yp1125/article/details/79125477
+    03 CDN加速静态文件访问
+    04 系统监控、容灾、储存动态扩容
+    05 架构设计及业务驱动分化
+    06 CAP、Base理论及其应用
+  分布式架构策略
+    01 分布式架构网络通信原理剖析
+    02 通信协议中的序列化和反序列化
+    03 基于框架的RPC技术WebService/RMI/Hession
+    04 深入分析Zookeeper在disconf配置中心的应用
+    05 基于Zookeeper实现分布式服务器动态上下线感知
+    06 深入分析Zookeeper Zab 协议及选举机制源码解读
+    07 Dubbo管理中心及监控平台安装部署
+    08 基于Dubbo的分布式系统架构实战
+    09 Dubbo容错机制及搞扩展性分析
+  分布式架构中间件
+    01 分布式消息通信ActiveMQ/Kafka/RabbitMQ
+    02 Redis主从复制原理及无磁盘复制分析
+    03 图解Redis中AOP和RDB持久化策略的原理
+    04 MongoDB企业级集群解决方案
+    05 MongoDB数据分析，转存及恢复策略
+    06 基于OpenResty部署应用层Nginx以及Nginx+Lua实战
+    07 Nginx反向代理服务器及负载均衡服务配置实战
+    08 基于Netty实现高性能IM聊天
+    09 基于Netty实现Dubbo多协议通信支持
+    10 Netty无锁化串行设计及高并发处理机制
+  分布式架构实践
+    01 分布式全局ID生成方案
+    02 Session跨域共享及企业级单点登录解决方案实战
+    03 分布式事务解决方案实战
+    04 高并发下的服务降级、限流实战
+    05 基于分布式架构下分布式锁的解决方案实战
+    06 分布式架构下实现分布式定时调度
+
+
+## 三、微服务
+当前微服务很热，大家都号称在使用微服务架构，但究竟什么是微服务架构？微服务架构是不是发展趋势？对于这些问题，我们都缺乏清楚的认识。
+
+为解决单体架构下的各种问题，微服务架构应运而生。与其构建一个臃肿庞大、难以驯服的怪兽，还不如及早将服务拆分。微服务的核心思想便是服务拆分与解耦，降低复杂性。微服务强调将功能合理拆解，尽可能保证每个服务的功能单一，按照单一责任原则（Single Responsibility Principle）明确角色。 将各个服务做轻，从而做到灵活、可复用，亦可根据各个服务自身资源需求，单独布署，单独作横向扩展。
+
+下图是我总结出微服务需要学习的知识点：
+
+微服务专题
+  微框架
+    01 与微服务之间的关系
+    02 热部署实现
+    03 核心组件 ：Starter、Actuator、AutoConfiguration、Cli
+    04 继承MyBatis实现多数据源路由实战、继承Dubbo实战、继承Redis缓存实战
+    05 继承Swagger2构建API管理及测试体系
+    06 实现多环境配置动态解析
+  Spring Cloud
+    01 Eureka注册中心
+    02 Ribbon继承REST实现负载均衡
+    03 Fegion声明式服务调用
+    04 Hystrix服务熔断降级方式
+    05 Zuul实现微服务网关
+    06 Config分布式统一配置中心
+    07 Sleuth调用链路跟踪
+    08 EUS消息总线
+    09 基于Hystrix实现接口实现降级
+    10 继承Spring Cloud实现统一整合方案
+  Docker虚拟化
+    01 Docker的镜像、仓库、容器
+    02 Docker File构建的LNMP环境部署个人博客WordPress
+    03 Docker Compose构建的LNMP环境部署个人博客WordPress
+    04 Docker网路组成、路由互联、Openvswitch
+    05 基于Swarm构建Docker集群实战
+    06 KUbernetes简介
+  微服务架构
+    01 SOA架构和微服务架构之间的区别和联系
+    02 如何设计微服务及其设计原理
+    03 解惑Spring Boot流行因素及能够解决什么问题
+    04 什么是Spring Cloud,为何要选择 Spring Cloud
+    05 基于全局分析Spring Cloud各个组件所解决的问题
+
+## 四、性能优化
+不管是应付前端面试还是改进产品体验，性能优化都是躲不开的话题。
+
+优化的目的是让用户有“快”的感受，那如何让用户感受到快呢？
+
+加载速度真的很快，用户打开输入网址按下回车立即看到了页面
+加载速度并没有变快，但用户感觉你的网站很快
+性能优化取决于多个因素，包括垃圾收集、虚拟机和底层操作系统（OS）设置。有多个工具可供开发人员进行分析和优化时使用，你可以通过阅读 Java Tools for Source Code Optimization and Analysis 来学习和使用它们。
+
+必须要明白的是，没有两个应用程序可以使用相同的优化方式，也没有完美的优化 java 应用程序的参考路径。使用最佳实践并且坚持采用适当的方式处理性能优化。想要达到真正最高的性能优化，你作为一个 Java 开发人员，需要对 Java 虚拟机（JVM）和底层操作系统有正确的理解。
+
+以上五大知识体系是我从业多年总结出来的经验，都是当前最主流的技术。想学习这些技术的朋友可以加群：478030634。群里会分享这些技术知识点供大家学习免费下载
+
+下图是我总结性能优化应该学习理解的几大知识体系：
+
+性能优化
+  理解性能优化
+    01 性能基准
+    02 性能优化到底是什么
+    03 衡量维度
+  JVM调优
+    01 知其然，知其所以然
+    02 什么是JVM运行时数据区
+    03 什么是JVM内存模型 JMM
+    04 各垃圾回收器使用场景（Thoughput/CMS）
+    05 理解GC日志，从日志看端倪
+    06 实战MAT分析dump文件
+  Tomcat调优
+    01 How it work？探查Tomcat的运行机制及框架
+    02 分析Tomcat线程模型
+    03 Tomcat系统参数认识及调优
+    04 基准测试
+  Mysql调优
+    01 理解Mysql底层 B+ Tree 机制
+    02 Sql执行计划详解
+    03 索引优化详解
+    04 Sql语句优化
+
+## 五、Java工程化
+工欲善其事，必先利其器，不管是小白，还是资深开发，都需要先选择好的工具。提升开发效率何团队协作效率。让自己有更多时间来思考。
+
+工程化专题
+  Maven
+    01 生成可执行jar、理解Scope生成最精确的jar
+    02 类冲突、包依赖 NoClassDefFoundError问题定位及解决
+    03 全面理解Maven的lifecycle、Phase、Goal
+    04 架构师必备之Maven生成Archetype
+    05 Maven流行插件实战、手写自己的插件
+    06 Nexus使用、上传、配置
+    07 对比Gradle
+  Jenkins
+    01 搭建Jenkins自动部署环境
+    02 Jenkins继承Maven、git实现自动部署
+    03 test\pre\production多环节发布
+    04 Jenkins多环境配置、权限管理及插件使用
+  Sonar
+    01 使用Sonar进行代码质量管理
+    02 关于代码检查工具FindBugs/PMD的运用
+    03 SonarQube代码质量管理平台安装及使用
+    04 使用Jenkins与Sonar集成对代码进行持续检测
+    05 Idea与Sonar集合的使用
+  Git
+    01 什么是Git以及Git的工作原理
+    02 Git常用命令Best practise（避坑教学）
+    03 Git冲突怎么引起的， 如何解决
+    04 架构师职责：Git flow规范团队git使用规程
+    05 团队案例分享（买不到才是最贵的）
+
+### 并发
+  并发基础
+    01 线程的起源、优势、实现
+    02 共享内存、缓存一致性，MESI协议
+    03 自旋锁、重量级锁、偏向锁
+    04 一致性模型
+    05 JMM内存模型
+  线程实现
+    01 synchronized、volatile关键字
+    02 happens-before语义
+    03 线程的实现方式
+    04 wait/notify
+    05 Thread.join
+    06 ThreadLocal
+  并发框架
+    01 核心机制AQS
+    02 重入锁ReentrantLock
+    03 线程锁synchronized及Locks
+    04 并发工具类CountDownLatch
+    05 线程安全集合ConcurrentHashMap
+    06 线程池及原理
+  其他
+    01 Fork/join
+    02 阻塞队列
+    03 原子操作Atomic
+
+### 电商项目实战
+
+  用户认证
+    01 用户注册
+    02 SSO单点登录
+    03 第三方登录
+    04 UI页面拦截
+    05 业务拦截
+  店铺、商品
+    01 ElasticSearch实现大数据聚合检索
+    02 Hadoop环境搭建
+    03 动静分离
+    04 店铺管理
+    05 商品管理
+  订单、支付
+    01 订单号统一生成规则
+    02 下单流程管理
+    03 库存管理
+    04 购物车
+    05 优惠券支付
+    06 积分支付
+    07 第三方支付
+  数据统计分析
+    01 用户行为分析
+    02 行业分析
+    03 区域分析
+  通知推送
+    01 融云推送
+    02 消息中间件
+    03 用户群聊
+    04 点对点聊天
+    05 文件断点续传
+
+next：
+
+  **JMS** JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
+  Web Service WSDL SOAP
+
+  **Weblogic** WebLogic是美国Oracle公司出品的一个application server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
+
+  **SOA** 面向服务的架构（SOA）是一个组件模型，它将应用程序的不同功能单元（称为服务）通过这些服务之间定义良好的接口和契约联系起来。接口是采用中立的方式进行定义的，它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种各样的系统中的服务可以以一种统一和通用的方式进行交互。
+
+  各种数据结构：红黑树，二叉树，平衡树，B-树，B+树，2-3-4树，线性表，hash表，图，堆都了解了吗？各种排序能写吗？
+
+  HashMap的源码都看明白了吗？
+
+  多线程精通了吗？分布式架构，各种数据库，NOSQL都精通了吗？明白底层实现吗？
+
+  各种设计模式，工厂，策略，代理等等能运用到项目中吗？
+
+  能设计一个秒杀系统吗？保证100万在线点抢购网站不挂掉吗？
+
+  能设计一个抢红包系统吗？保证1000万级在线，服务不至于挂掉。
+
+  编译原理都知道吗？
+
+  大数据，云计算，人工智能，各种搜索引擎，爬虫会写吗？
diff --git a/09 - J/README.md "b/09 - J \351\235\242\347\273\217/README.md"
similarity index 100%
rename from 09 - J/README.md
rename to "09 - J \351\235\242\347\273\217/README.md"
diff --git "a/09 - J/interview/HashMap\350\257\246\350\247\243.md" "b/09 - J \351\235\242\347\273\217/interview/HashMap\350\257\246\350\247\243.md"
similarity index 100%
rename from "09 - J/interview/HashMap\350\257\246\350\247\243.md"
rename to "09 - J \351\235\242\347\273\217/interview/HashMap\350\257\246\350\247\243.md"
diff --git "a/09 - J/interview/List,Set\345\222\214Map\350\257\246\350\247\243\345\217\212\345\205\266\345\214\272\345\210\253\345\222\214\344\273\226\344\273\254\345\210\206\345\210\253\351\200\202\347\224\250\347\232\204\345\234\272\346\231\257.md" "b/09 - J \351\235\242\347\273\217/interview/List,Set\345\222\214Map\350\257\246\350\247\243\345\217\212\345\205\266\345\214\272\345\210\253\345\222\214\344\273\226\344\273\254\345\210\206\345\210\253\351\200\202\347\224\250\347\232\204\345\234\272\346\231\257.md"
similarity index 100%
rename from "09 - J/interview/List,Set\345\222\214Map\350\257\246\350\247\243\345\217\212\345\205\266\345\214\272\345\210\253\345\222\214\344\273\226\344\273\254\345\210\206\345\210\253\351\200\202\347\224\250\347\232\204\345\234\272\346\231\257.md"
rename to "09 - J \351\235\242\347\273\217/interview/List,Set\345\222\214Map\350\257\246\350\247\243\345\217\212\345\205\266\345\214\272\345\210\253\345\222\214\344\273\226\344\273\254\345\210\206\345\210\253\351\200\202\347\224\250\347\232\204\345\234\272\346\231\257.md"
diff --git a/09 - J/interview/README.md "b/09 - J \351\235\242\347\273\217/interview/README.md"
similarity index 100%
rename from 09 - J/interview/README.md
rename to "09 - J \351\235\242\347\273\217/interview/README.md"
diff --git a/09 - J/interview/img/640 (1).webp "b/09 - J \351\235\242\347\273\217/interview/img/640 (1).webp"
similarity index 100%
rename from 09 - J/interview/img/640 (1).webp
rename to "09 - J \351\235\242\347\273\217/interview/img/640 (1).webp"
diff --git a/09 - J/interview/img/640 (2).webp "b/09 - J \351\235\242\347\273\217/interview/img/640 (2).webp"
similarity index 100%
rename from 09 - J/interview/img/640 (2).webp
rename to "09 - J \351\235\242\347\273\217/interview/img/640 (2).webp"
diff --git a/09 - J/interview/img/640.webp "b/09 - J \351\235\242\347\273\217/interview/img/640.webp"
similarity index 100%
rename from 09 - J/interview/img/640.webp
rename to "09 - J \351\235\242\347\273\217/interview/img/640.webp"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/01.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/01.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/01.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/01.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/02.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/02.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/02.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/02.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/03.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/03.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/03.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/03.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/04.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/04.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/04.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/04.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/05.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/05.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/05.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/05.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/06.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/06.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/06.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/06.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/07 - spring\351\235\242\350\257\225\351\242\230\345\217\212\347\255\224\346\241\210\350\247\243\346\236\220.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/07 - spring\351\235\242\350\257\225\351\242\230\345\217\212\347\255\224\346\241\210\350\247\243\346\236\220.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/07 - spring\351\235\242\350\257\225\351\242\230\345\217\212\347\255\224\346\241\210\350\247\243\346\236\220.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/07 - spring\351\235\242\350\257\225\351\242\230\345\217\212\347\255\224\346\241\210\350\247\243\346\236\220.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/08.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/08.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/08.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/08.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/09.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/09.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/09.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/09.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/10.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/10.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/10.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/10.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/11.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/11.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/11.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/11.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/12.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/12.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/12.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/12.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/Java\344\270\255\351\253\230\347\272\247\351\235\242\350\257\225\351\242\230.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/Java\344\270\255\351\253\230\347\272\247\351\235\242\350\257\225\351\242\230.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/Java\344\270\255\351\253\230\347\272\247\351\235\242\350\257\225\351\242\230.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/Java\344\270\255\351\253\230\347\272\247\351\235\242\350\257\225\351\242\230.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/SSH\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\351\233\206\351\224\246.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/SSH\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\351\233\206\351\224\246.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/SSH\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\351\233\206\351\224\246.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/SSH\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\351\233\206\351\224\246.md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/\346\216\242\350\256\250Java\344\270\255\346\234\200\345\270\270\350\247\201\347\232\204\345\215\201\351\201\223\351\235\242\350\257\225\351\242\230(\350\266\205\347\273\217\345\205\270).md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/\346\216\242\350\256\250Java\344\270\255\346\234\200\345\270\270\350\247\201\347\232\204\345\215\201\351\201\223\351\235\242\350\257\225\351\242\230(\350\266\205\347\273\217\345\205\270).md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/\346\216\242\350\256\250Java\344\270\255\346\234\200\345\270\270\350\247\201\347\232\204\345\215\201\351\201\223\351\235\242\350\257\225\351\242\230(\350\266\205\347\273\217\345\205\270).md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/\346\216\242\350\256\250Java\344\270\255\346\234\200\345\270\270\350\247\201\347\232\204\345\215\201\351\201\223\351\235\242\350\257\225\351\242\230(\350\266\205\347\273\217\345\205\270).md"
diff --git "a/09 - J/interview/\344\270\255\347\272\247/\346\225\260\346\215\256\345\272\223\351\235\242\350\257\225\345\270\270\351\227\256\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/\346\225\260\346\215\256\345\272\223\351\235\242\350\257\225\345\270\270\351\227\256\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
similarity index 100%
rename from "09 - J/interview/\344\270\255\347\272\247/\346\225\260\346\215\256\345\272\223\351\235\242\350\257\225\345\270\270\351\227\256\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
rename to "09 - J \351\235\242\347\273\217/interview/\344\270\255\347\272\247/\346\225\260\346\215\256\345\272\223\351\235\242\350\257\225\345\270\270\351\227\256\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/01 - \345\237\272\347\241\200\347\257\207\344\270\200.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/01 - \345\237\272\347\241\200\347\257\207\344\270\200.md"
similarity index 98%
rename from "09 - J/interview/\345\210\235\347\272\247/01 - \345\237\272\347\241\200\347\257\207\344\270\200.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/01 - \345\237\272\347\241\200\347\257\207\344\270\200.md"
index 6ef5d208..d71161f5 100755
--- "a/09 - J/interview/\345\210\235\347\272\247/01 - \345\237\272\347\241\200\347\257\207\344\270\200.md"	
+++ "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/01 - \345\237\272\347\241\200\347\257\207\344\270\200.md"	
@@ -1,110 +1,110 @@
-
-### 1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
-
-  可以有多个类，但 **只能有一个public的类**，并且 **public的类名必须与文件名相一致**。
-
-### 2、Java有没有goto?
-
-  java中的保留字，现在没有在java中使用。
-
-### 3、说说&和&&的区别。
-
-  &和&&都可以用作逻辑与的运算符，表示`逻辑``与`（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
-
-  &&还具有`短路`的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于`if(str!= null && !str.equals(s))`表达式，当str为null时，后面的表达式不会执行，所以不会出现 `NullPointerException`如果将&&改为&，则会抛出NullPointerException异常。`If(x==33 & ++y>0)` y会增长，`If(x==33 && ++y>0)`不会增长
-
-  &还可以用作`位运算符`，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。
-
-### 4、在JAVA中如何跳出当前的多重嵌套循环？
-
-  在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break语句，即可跳出外层循环。
-
-  例如：
-  ``` java
-  for(int i=0;i<10;i++){
-     for(intj=0;j<10;j++){
-         System.out.println(“i=” + i + “,j=” + j);
-         if(j == 5) break ok;
-     }
-  }
-  ```
-
-  另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
-
-  ```java
-  int[][] arr = {1,2,3},{4,5,6,7},{9};
-  boolean found = false;
-  for(int i=0;i<arr.length&&!found;i++){
-      for(intj=0;j<arr[i].length;j++){
-          System.out.println(“i=” + i + “,j=” + j);
-          if(arr[i][j] ==5) {
-              found =true;
-              break;
-          }
-      }
-  }
-  ```
-
-### 5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
-
-  在switch（e）中，e只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。
-
-  switch语句能否作用在String上说错了，Java1.7之后已经支持这种写法了！
-
-### 6、short s1= 1; s1 = （s1+1是int类型，而等号左边的是short类型，所以需要强转）1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?(没有错)
-
-  对于`short s1= 1; s1 = s1 + 1;`由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
-
-  对于`short s1= 1; s1 += 1;`由于 +=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
-
-### 7、char型变量中能不能存贮一个中文汉字?为什么?
-
-  char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
-
-### 8、用最有效率的方法算出2乘以8等於几?
-
-  `2<< 3`，(左移三位)因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2<< 3。
-
-### 9、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
-
-  使用final关键字修饰一个变量时，是指`引用变量不能变`，引用变量所`指向的对象中的内容还是可以改变的`。例如，对于如下语句：
-  ``` java
-  final StringBuffer a = new StringBuffer("immutable");
-  ```
-  执行如下语句将报告编译期`错误`：
-  ``` java
-  a = new StringBuffer("");
-  ```
-  但是，执行如下语句则可以`通过编译`：
-  ``` java
-  a.append(" broken!");
-  ```
-  有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：
-  ``` java
-  public void method(final  StringBuffer param){
-
-  }
-  ```
-  实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
-  ``` java
-  param.append("a");
-  ```
-
-### 10，静态变量和实例变量的区别？
-
-  在`语法定义`上的区别：静态变量前要加`static`关键字，而实例变量前则不加。
-
-  在`程序运行时`的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
-
-  例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个`staticVar`变量，并且每创建一个实例对象，这个`staticVar`就会加1；但是，每创建一个实例对象，就会分配一个`instanceVar`，即可能分配多个`instanceVar`，并且每个`instanceVar`的值都只自加了1次。
-  ``` java
-  public class VariantTest{
-      public static int staticVar = 0;
-      public int instanceVar = 0;
-      public VariantTest(){
-            staticVar++;
-            instanceVar++;
-            System.out.println(staticVar +instanceVar);
-      }
-  }
-  ```
+
+### 1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
+
+  可以有多个类，但 **只能有一个public的类**，并且 **public的类名必须与文件名相一致**。
+
+### 2、Java有没有goto?
+
+  java中的保留字，现在没有在java中使用。
+
+### 3、说说&和&&的区别。
+
+  &和&&都可以用作逻辑与的运算符，表示`逻辑``与`（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
+
+  &&还具有`短路`的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于`if(str!= null && !str.equals(s))`表达式，当str为null时，后面的表达式不会执行，所以不会出现 `NullPointerException`如果将&&改为&，则会抛出NullPointerException异常。`If(x==33 & ++y>0)` y会增长，`If(x==33 && ++y>0)`不会增长
+
+  &还可以用作`位运算符`，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。
+
+### 4、在JAVA中如何跳出当前的多重嵌套循环？
+
+  在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break语句，即可跳出外层循环。
+
+  例如：
+  ``` java
+  for(int i=0;i<10;i++){
+     for(intj=0;j<10;j++){
+         System.out.println(“i=” + i + “,j=” + j);
+         if(j == 5) break ok;
+     }
+  }
+  ```
+
+  另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
+
+  ```java
+  int[][] arr = {1,2,3},{4,5,6,7},{9};
+  boolean found = false;
+  for(int i=0;i<arr.length&&!found;i++){
+      for(intj=0;j<arr[i].length;j++){
+          System.out.println(“i=” + i + “,j=” + j);
+          if(arr[i][j] ==5) {
+              found =true;
+              break;
+          }
+      }
+  }
+  ```
+
+### 5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
+
+  在switch（e）中，e只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。
+
+  switch语句能否作用在String上说错了，Java1.7之后已经支持这种写法了！
+
+### 6、short s1= 1; s1 = （s1+1是int类型，而等号左边的是short类型，所以需要强转）1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?(没有错)
+
+  对于`short s1= 1; s1 = s1 + 1;`由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
+
+  对于`short s1= 1; s1 += 1;`由于 +=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
+
+### 7、char型变量中能不能存贮一个中文汉字?为什么?
+
+  char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
+
+### 8、用最有效率的方法算出2乘以8等於几?
+
+  `2<< 3`，(左移三位)因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2<< 3。
+
+### 9、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
+
+  使用final关键字修饰一个变量时，是指`引用变量不能变`，引用变量所`指向的对象中的内容还是可以改变的`。例如，对于如下语句：
+  ``` java
+  final StringBuffer a = new StringBuffer("immutable");
+  ```
+  执行如下语句将报告编译期`错误`：
+  ``` java
+  a = new StringBuffer("");
+  ```
+  但是，执行如下语句则可以`通过编译`：
+  ``` java
+  a.append(" broken!");
+  ```
+  有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：
+  ``` java
+  public void method(final  StringBuffer param){
+
+  }
+  ```
+  实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
+  ``` java
+  param.append("a");
+  ```
+
+### 10，静态变量和实例变量的区别？
+
+  在`语法定义`上的区别：静态变量前要加`static`关键字，而实例变量前则不加。
+
+  在`程序运行时`的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
+
+  例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个`staticVar`变量，并且每创建一个实例对象，这个`staticVar`就会加1；但是，每创建一个实例对象，就会分配一个`instanceVar`，即可能分配多个`instanceVar`，并且每个`instanceVar`的值都只自加了1次。
+  ``` java
+  public class VariantTest{
+      public static int staticVar = 0;
+      public int instanceVar = 0;
+      public VariantTest(){
+            staticVar++;
+            instanceVar++;
+            System.out.println(staticVar +instanceVar);
+      }
+  }
+  ```
diff --git "a/09 - J/interview/\345\210\235\347\272\247/02 - \345\237\272\347\241\200\347\257\207\344\272\214.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/02 - \345\237\272\347\241\200\347\257\207\344\272\214.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/02 - \345\237\272\347\241\200\347\257\207\344\272\214.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/02 - \345\237\272\347\241\200\347\257\207\344\272\214.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/03 - \351\233\206\345\220\210\346\241\206\346\236\266\347\257\207\344\270\211.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/03 - \351\233\206\345\220\210\346\241\206\346\236\266\347\257\207\344\270\211.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/03 - \351\233\206\345\220\210\346\241\206\346\236\266\347\257\207\344\270\211.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/03 - \351\233\206\345\220\210\346\241\206\346\236\266\347\257\207\344\270\211.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/04 - \345\237\272\347\241\200\347\257\207\345\233\233.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/04 - \345\237\272\347\241\200\347\257\207\345\233\233.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/04 - \345\237\272\347\241\200\347\257\207\345\233\233.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/04 - \345\237\272\347\241\200\347\257\207\345\233\233.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/05 - \345\237\272\347\241\200\347\257\207\344\272\224.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/05 - \345\237\272\347\241\200\347\257\207\344\272\224.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/05 - \345\237\272\347\241\200\347\257\207\344\272\224.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/05 - \345\237\272\347\241\200\347\257\207\344\272\224.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/06 - javaweb\347\257\207\345\205\255.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/06 - javaweb\347\257\207\345\205\255.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/06 - javaweb\347\257\207\345\205\255.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/06 - javaweb\347\257\207\345\205\255.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/07 - javaweb\347\257\207\344\270\203.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/07 - javaweb\347\257\207\344\270\203.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/07 - javaweb\347\257\207\344\270\203.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/07 - javaweb\347\257\207\344\270\203.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/08 - \346\241\206\346\236\266\347\257\207\345\205\253.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/08 - \346\241\206\346\236\266\347\257\207\345\205\253.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/08 - \346\241\206\346\236\266\347\257\207\345\205\253.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/08 - \346\241\206\346\236\266\347\257\207\345\205\253.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/09 - \346\241\206\346\236\266\347\257\207\344\271\235.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/09 - \346\241\206\346\236\266\347\257\207\344\271\235.md"
similarity index 98%
rename from "09 - J/interview/\345\210\235\347\272\247/09 - \346\241\206\346\236\266\347\257\207\344\271\235.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/09 - \346\241\206\346\236\266\347\257\207\344\271\235.md"
index 28af8c05..610f61dc 100755
--- "a/09 - J/interview/\345\210\235\347\272\247/09 - \346\241\206\346\236\266\347\257\207\344\271\235.md"	
+++ "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/09 - \346\241\206\346\236\266\347\257\207\344\271\235.md"	
@@ -1,113 +1,113 @@
-### 81，使用Spring框架的好处是什么？
-
-  `轻量`：Spring 是轻量的，基本的版本大约2MB。
-
-  `控制反转`：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
-
-  `面向切面的编程(AOP)`：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
-
-  `容器`：Spring 包含并管理应用中对象的生命周期和配置。
-
-  `MVC框架`：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
-
-  `事务管理`：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
-
-  `异常处理`：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。
-
-### 82. ApplicationContext通常的实现是什么?
-
-  `FileSystemXmlApplicationContext` ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
-
-  `ClassPathXmlApplicationContext`：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
-
-  `WebXmlApplicationContext`：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。
-
-### 83，什么是Spring的依赖注入？有哪些方法进行依赖注入
-
-  依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IOC容器）负责把他们组装起来。
-
-  **构造器依赖注入**：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
-
-  **Setter方法注入**：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。
-
-### 84，什么是Spring beans?
-
-  Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 **<bean/>** 的形式定义。
-
-  Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，如果它被赋为TRUE，bean 就是单件，否则就是一个 prototype bean。默认是TRUE，所以所有在Spring框架中的beans 缺省都是单件。
-
-### 85，解释Spring支持的几种bean的作用域。
-
-  Spring框架支持以下五种bean的作用域：
-
-  `singleton` : bean在每个Spring ioc 容器中只有一个实例。
-
-  `prototype`：一个bean的定义可以有多个实例。
-
-  `request`：每次http请求都会创建一个bean，该作用域仅在基于web的 Spring ApplicationContext情形下有效。
-
-  `session`：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
-
-  `global-session`：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
-
-  缺省的Spring bean 的作用域是Singleton.
-
-### 86，解释Spring框架中bean的生命周期。
-
-  1. Spring容器 从XML 文件中读取bean的定义，并实例化bean。
-
-  2. Spring根据bean的定义填充所有的属性。
-
-  3. 如果bean 实现了 BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
-
-  4. 如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
-
-  5. 如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
-
-  6. 如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
-
-  7. 如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
-
-  8. 如果bean实现了 DisposableBean，它将调用destroy()方法。
-
-### 87，在 Spring中如何注入一个java集合？
-
-  Spring提供以下几种集合的配置元素：
-
-  `<list>` 类型用于注入一列值，允许有相同的值。
-
-  `<set>` 类型用于注入一组值，不允许有相同的值。
-
-  `<map>` 类型用于注入一组键值对，键和值都可以为任意类型。
-
-  `<props>`类型用于注入一组键值对，键和值都只能为String类型。
-
-### 88，解释不同方式的自动装配 。
-
-  有五种自动装配的方式，用来指导Spring容器用自动装配方式进行依赖注入。
-
-  `no`：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
-
-  `byName`：通过参数名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
-
-  `byType`:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
-
-  `constructor`：这个方式类似于byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
-
-  `autodetect`：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。
-
-### 89，Spring框架的事务管理有哪些优点？
-
-  它为不同的事务API  如 JTA，JDBC，Hibernate，JPA 和JDO，提供一个不变的编程模式。
-
-  它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API如
-
-  它支持声明式事务管理。
-
-  它和Spring各种数据访问抽象层很好得集成。
-
-### 90.什么是基于Java的Spring注解配置? 给一些注解的例子.
-
-  基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。
-
-  以`@Configuration` 注解为例，它用来标记类可以当做一个bean的定义，被Spring IOC容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进`Spring应用上下文`。
+### 81，使用Spring框架的好处是什么？
+
+  `轻量`：Spring 是轻量的，基本的版本大约2MB。
+
+  `控制反转`：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
+
+  `面向切面的编程(AOP)`：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
+
+  `容器`：Spring 包含并管理应用中对象的生命周期和配置。
+
+  `MVC框架`：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
+
+  `事务管理`：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
+
+  `异常处理`：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。
+
+### 82. ApplicationContext通常的实现是什么?
+
+  `FileSystemXmlApplicationContext` ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
+
+  `ClassPathXmlApplicationContext`：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
+
+  `WebXmlApplicationContext`：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。
+
+### 83，什么是Spring的依赖注入？有哪些方法进行依赖注入
+
+  依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IOC容器）负责把他们组装起来。
+
+  **构造器依赖注入**：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
+
+  **Setter方法注入**：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。
+
+### 84，什么是Spring beans?
+
+  Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 **<bean/>** 的形式定义。
+
+  Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，如果它被赋为TRUE，bean 就是单件，否则就是一个 prototype bean。默认是TRUE，所以所有在Spring框架中的beans 缺省都是单件。
+
+### 85，解释Spring支持的几种bean的作用域。
+
+  Spring框架支持以下五种bean的作用域：
+
+  `singleton` : bean在每个Spring ioc 容器中只有一个实例。
+
+  `prototype`：一个bean的定义可以有多个实例。
+
+  `request`：每次http请求都会创建一个bean，该作用域仅在基于web的 Spring ApplicationContext情形下有效。
+
+  `session`：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
+
+  `global-session`：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
+
+  缺省的Spring bean 的作用域是Singleton.
+
+### 86，解释Spring框架中bean的生命周期。
+
+  1. Spring容器 从XML 文件中读取bean的定义，并实例化bean。
+
+  2. Spring根据bean的定义填充所有的属性。
+
+  3. 如果bean 实现了 BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
+
+  4. 如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
+
+  5. 如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
+
+  6. 如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
+
+  7. 如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
+
+  8. 如果bean实现了 DisposableBean，它将调用destroy()方法。
+
+### 87，在 Spring中如何注入一个java集合？
+
+  Spring提供以下几种集合的配置元素：
+
+  `<list>` 类型用于注入一列值，允许有相同的值。
+
+  `<set>` 类型用于注入一组值，不允许有相同的值。
+
+  `<map>` 类型用于注入一组键值对，键和值都可以为任意类型。
+
+  `<props>`类型用于注入一组键值对，键和值都只能为String类型。
+
+### 88，解释不同方式的自动装配 。
+
+  有五种自动装配的方式，用来指导Spring容器用自动装配方式进行依赖注入。
+
+  `no`：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
+
+  `byName`：通过参数名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
+
+  `byType`:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
+
+  `constructor`：这个方式类似于byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
+
+  `autodetect`：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。
+
+### 89，Spring框架的事务管理有哪些优点？
+
+  它为不同的事务API  如 JTA，JDBC，Hibernate，JPA 和JDO，提供一个不变的编程模式。
+
+  它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API如
+
+  它支持声明式事务管理。
+
+  它和Spring各种数据访问抽象层很好得集成。
+
+### 90.什么是基于Java的Spring注解配置? 给一些注解的例子.
+
+  基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。
+
+  以`@Configuration` 注解为例，它用来标记类可以当做一个bean的定义，被Spring IOC容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进`Spring应用上下文`。
diff --git "a/09 - J/interview/\345\210\235\347\272\247/10 - \346\214\201\344\271\205\345\261\202\345\215\201.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/10 - \346\214\201\344\271\205\345\261\202\345\215\201.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/10 - \346\214\201\344\271\205\345\261\202\345\215\201.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/10 - \346\214\201\344\271\205\345\261\202\345\215\201.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/11 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\270\200.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/11 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\270\200.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/11 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\270\200.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/11 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\270\200.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/12 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\272\214.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/12 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\272\214.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/12 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\272\214.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/12 - \346\225\260\346\215\256\345\272\223\347\257\207\345\215\201\344\272\214.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/13 - \345\244\232\347\272\277\347\250\213\347\257\207\345\215\201\344\270\211.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/13 - \345\244\232\347\272\277\347\250\213\347\257\207\345\215\201\344\270\211.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/13 - \345\244\232\347\272\277\347\250\213\347\257\207\345\215\201\344\270\211.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/13 - \345\244\232\347\272\277\347\250\213\347\257\207\345\215\201\344\270\211.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/14 - \346\263\233\345\236\213\347\257\207\345\215\201\345\233\233.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/14 - \346\263\233\345\236\213\347\257\207\345\215\201\345\233\233.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/14 - \346\263\233\345\236\213\347\257\207\345\215\201\345\233\233.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/14 - \346\263\233\345\236\213\347\257\207\345\215\201\345\233\233.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/15 - web\347\257\207\345\215\201\344\272\224.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/15 - web\347\257\207\345\215\201\344\272\224.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/15 - web\347\257\207\345\215\201\344\272\224.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/15 - web\347\257\207\345\215\201\344\272\224.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/16 - \345\271\266\345\217\221\347\257\207\345\215\201\345\205\255.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/16 - \345\271\266\345\217\221\347\257\207\345\215\201\345\205\255.md"
similarity index 100%
rename from "09 - J/interview/\345\210\235\347\272\247/16 - \345\271\266\345\217\221\347\257\207\345\215\201\345\205\255.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/16 - \345\271\266\345\217\221\347\257\207\345\215\201\345\205\255.md"
diff --git "a/09 - J/interview/\345\210\235\347\272\247/17 - \347\256\227\346\263\225\347\257\207\345\215\201\344\270\203.md" "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/17 - \347\256\227\346\263\225\347\257\207\345\215\201\344\270\203.md"
similarity index 97%
rename from "09 - J/interview/\345\210\235\347\272\247/17 - \347\256\227\346\263\225\347\257\207\345\215\201\344\270\203.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/17 - \347\256\227\346\263\225\347\257\207\345\215\201\344\270\203.md"
index 42b1ad73..9ce6b620 100755
--- "a/09 - J/interview/\345\210\235\347\272\247/17 - \347\256\227\346\263\225\347\257\207\345\215\201\344\270\203.md"	
+++ "b/09 - J \351\235\242\347\273\217/interview/\345\210\235\347\272\247/17 - \347\256\227\346\263\225\347\257\207\345\215\201\344\270\203.md"	
@@ -1,237 +1,237 @@
-### 170，堆和栈在内存中的区别是什么？
-
-  **概念**：
-
-  **栈（stack）** 是为执行线程留出的内存空间。当函数被调用的时候，栈顶为局部变量和一些 bookkeeping 数据预留块。当函数执行完毕，块就没有用了，可能在下次的函数调用的时候再被使用。栈通常用后进先出的方式预留空间；因此最近的保留块通常最先被释放。这么做可以使跟踪堆栈变的简单；从栈中释放块只不过是指针的偏移而已。
-
-  **堆（heap）** 是为动态分配预留的内存空间。和栈不一样，从堆上分配和重新分配块没有固定模式；你可以在任何时候分配和释放它。这样使得跟踪哪部分堆已经被分配和被释放变的异常复杂；有许多定制的堆分配策略用来为不同的使用模式下调整堆的性能。
-
-  **区别**：
-
-  `内存分配`：
-
-  栈：由编译器自动分配和释放，存放函数的参数、局部变量、临时变量、函数返回地址等。
-
-  堆：一般人为分配和释放，对Java而言由系统释放回收，但对于C++等，必须手动释放，如果没有手动释放会引起内存泄漏。
-
-  `系统响应`：
-
-  栈：只要栈的剩余空间大于所申请的空间，系统将为程序提供内存，否则将报异常提示栈溢出。
-
-  堆：在记录空闲内存地址的链表中寻找一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。
-
-  `大小限制`：
-
-  栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 windows下，栈的大小是2M，如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
-  堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。
-
-  结论：堆获得的空间比较灵活，也比较大。
-
-  **分配效率**：
-  栈：由系统自动分配，速度较快，无法人为控制。
-
-  堆：由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
-
-  **存储内容**：
-
-  栈：在栈中，第一个进栈的是主函数下一条指令的地址，然后是函数的各个参数，在大多数编译器中，参数是由右往左入栈，然后是函数中的局部变量。注意，静态变量不入栈。出栈则刚好顺序相反。
-
-  堆：一般在堆的头部用一个字节存放堆的大小，具体内容受人为控制。
-
-
-
-### 171，求出1000之内的所有水仙花数
-
-  概念：
-
-  水仙花数指的是一个三位整数，它的各位数字的立方和等于这个数本身.。
-
-  解法：
-  ``` java
-  public class NumberOfDaffodils {    
-      public static void main(String[] args) {  
-          // TODO Auto-generated method stub  
-          int hundred, ten, bits;    
-          System.out.println("水仙花数为：");    
-          for (int i = 100; i <= 999; i++){    
-              hundred = i / 100;    
-              ten = i % 100 / 10;    
-              bits = i % 10;    
-              if (i == hundred * hundred * hundred + ten * ten * ten + bits * bits * bits){    
-                  System.out.print(i + "    ");    
-              }    
-          }      
-      }  
-  }
-  ```
-### 172，比较一下几种常用的排序算法，简单的写一下你知道的几种排序算法？
-
-  比较：
-
-  **1.稳定性比较**
-
-  `插入排序`、`冒泡排序`、`二叉树排序`、`二路归并排序`及`其他线形排序`是`稳定`的
-
-  `选择排序`、`希尔排序`、`快速排序`、`堆排序`是不稳定的
-
-  **2.时间复杂性比较**
-
-  插入排序、冒泡排序、选择排序的时间复杂性为`O(n2)`
-
-  其它非线形排序的时间复杂性为`O(nlog2n)`
-
-  线形排序的时间复杂性为`O(n)`;
-
-  **3.辅助空间的比较**
-
-  线形排序、二路归并排序的辅助空间为O(n)；
-
-  其它排序的辅助空间为O(1);
-
-  **4.其它比较**
-
-  * 插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度，但是在这种情况下，快速排序反而慢了。
-
-  * 当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
-
-  * 若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
-
-  * 当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
-
-  * 当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下宜用归并排序。
-
-  * 当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
-
-  常见的排序算法：
-
-  选择排序
-  ```java
-  public class SelectionSort {
-      public void selectionSort(int[] array) {
-          int temp;
-          for (int i = 0; i < array.length - 1; i++) {
-              for (int j = i + 1; j <= array.length - 1; j++) {
-                  if (array[i] > array[j]) {    
-                      // 注意和冒泡排序的区别，这里是i和j比较。
-                      temp = array[i];
-                      array[i] = array[j];
-                      array[j] = temp;
-                  }
-              }// 打印每趟排序结果
-              for (int m = 0; m <= array.length - 1; m++) {
-                  System.out.print(array[m] + "\t");
-              }
-              System.out.println();
-          }
-      }    
-      public static void main(String[] args) {
-          SelectionSort selectionSort = new SelectionSort();
-          int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
-          selectionSort.selectionSort(array);        
-          for (int m = 0; m <= array.length - 1; m++) {
-              System.out.print(array[m] + "\t");
-          }
-      }
-  }
-  ```
-  插入排序
-  ```java
-  public class InsertSort {
-      public void insertSort(int[] array, int first, int last) {        
-      int temp, i, j;        
-      for (i = first + 1; i <= last - 1; i++) {
-              temp = array[i];
-              j = i - 1;            
-          while (j >= first && array[j] > temp) {
-                  array[j + 1] = array[j];
-                  j--;
-              }
-              array[j + 1] = temp;            // 打印每次排序结果
-              for (int m = 0; m <= array.length - 1; m++) {
-                  System.out.print(array[m] + "\t");
-              }
-              System.out.println();
-          }
-      }    
-       public static void main(String[] args) {
-          InsertSort insertSort = new InsertSort();
-              int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
-          insertSort.insertSort(array, 0, array.length);      
-               for (int i = 0; i <= array.length - 1; i++) {
-              System.out.print(array[i] + "\t");
-          }
-      }
-  }
-  ```
-  快速排序
-  ```java
-  public class QuickSort {    
-      public int partition(int[] sortArray, int low, int height) {        
-      int key = sortArray[low];        
-      while (low < height) {            
-          while (low < height && sortArray[height] >= key)
-              height--;
-              sortArray[low] = sortArray[height];            
-              while (low < height && sortArray[low] <= key)
-                  low++;
-                  sortArray[height] = sortArray[low];
-              }
-              sortArray[low] = key;        // 打印每次排序结果
-          for (int i = 0; i <= sortArray.length - 1; i++) {
-              System.out.print(sortArray[i] + "\t");
-          }
-          System.out.println();        
-          return low;
-      }    
-      public void sort(int[] sortArray, int low, int height) {        
-          if (low < height) {            
-              int result = partition(sortArray, low, height);
-              sort(sortArray, low, result - 1);
-              sort(sortArray, result + 1, height);
-          }
-      }
-      public static void main(String[] args) {
-          QuickSort quickSort = new QuickSort();        
-          int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };        
-          for (int i = 0; i <= array.length - 1; i++) {
-              System.out.print(array[i] + "\t");
-          }
-          System.out.println();
-          quickSort.sort(array, 0, 8);        
-          for (int i = 0; i <= array.length - 1; i++) {
-              System.out.print(array[i] + "\t");
-          }
-      }
-  }
-  ```
-
-  希尔排序
-  ```java
-  public class ShellSort {
-      public void shellSort(int[] array, int n) {
-          int i, j, gap;
-          int temp;
-          for (gap = n / 2; gap > 0; gap /= 2) {
-              for (i = gap; i < n; i++) {       
-                  for (j = i - gap; j >= 0 && array[j] > array[j + gap]; j -= gap) {
-                      temp = array[j];
-                      array[j] = array[j + gap];
-                      array[j + gap] = temp;
-                  }                // 打印每趟排序结果
-                  for (int m = 0; m <= array.length - 1; m++) {
-                      System.out.print(array[m] + "\t");
-                  }
-                  System.out.println();
-              }
-          }
-      }
-       public static void main(String[] args) {
-          ShellSort shellSort = new ShellSort();
-          int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
-          shellSort.shellSort(array, array.length);        
-          for (int m = 0; m <= array.length - 1; m++) {
-              System.out.print(array[m] + "\t");
-          }
-      }
-  }
-  ```
+### 170，堆和栈在内存中的区别是什么？
+
+  **概念**：
+
+  **栈（stack）** 是为执行线程留出的内存空间。当函数被调用的时候，栈顶为局部变量和一些 bookkeeping 数据预留块。当函数执行完毕，块就没有用了，可能在下次的函数调用的时候再被使用。栈通常用后进先出的方式预留空间；因此最近的保留块通常最先被释放。这么做可以使跟踪堆栈变的简单；从栈中释放块只不过是指针的偏移而已。
+
+  **堆（heap）** 是为动态分配预留的内存空间。和栈不一样，从堆上分配和重新分配块没有固定模式；你可以在任何时候分配和释放它。这样使得跟踪哪部分堆已经被分配和被释放变的异常复杂；有许多定制的堆分配策略用来为不同的使用模式下调整堆的性能。
+
+  **区别**：
+
+  `内存分配`：
+
+  栈：由编译器自动分配和释放，存放函数的参数、局部变量、临时变量、函数返回地址等。
+
+  堆：一般人为分配和释放，对Java而言由系统释放回收，但对于C++等，必须手动释放，如果没有手动释放会引起内存泄漏。
+
+  `系统响应`：
+
+  栈：只要栈的剩余空间大于所申请的空间，系统将为程序提供内存，否则将报异常提示栈溢出。
+
+  堆：在记录空闲内存地址的链表中寻找一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。
+
+  `大小限制`：
+
+  栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 windows下，栈的大小是2M，如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
+  堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。
+
+  结论：堆获得的空间比较灵活，也比较大。
+
+  **分配效率**：
+  栈：由系统自动分配，速度较快，无法人为控制。
+
+  堆：由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
+
+  **存储内容**：
+
+  栈：在栈中，第一个进栈的是主函数下一条指令的地址，然后是函数的各个参数，在大多数编译器中，参数是由右往左入栈，然后是函数中的局部变量。注意，静态变量不入栈。出栈则刚好顺序相反。
+
+  堆：一般在堆的头部用一个字节存放堆的大小，具体内容受人为控制。
+
+
+
+### 171，求出1000之内的所有水仙花数
+
+  概念：
+
+  水仙花数指的是一个三位整数，它的各位数字的立方和等于这个数本身.。
+
+  解法：
+  ``` java
+  public class NumberOfDaffodils {    
+      public static void main(String[] args) {  
+          // TODO Auto-generated method stub  
+          int hundred, ten, bits;    
+          System.out.println("水仙花数为：");    
+          for (int i = 100; i <= 999; i++){    
+              hundred = i / 100;    
+              ten = i % 100 / 10;    
+              bits = i % 10;    
+              if (i == hundred * hundred * hundred + ten * ten * ten + bits * bits * bits){    
+                  System.out.print(i + "    ");    
+              }    
+          }      
+      }  
+  }
+  ```
+### 172，比较一下几种常用的排序算法，简单的写一下你知道的几种排序算法？
+
+  比较：
+
+  **1.稳定性比较**
+
+  `插入排序`、`冒泡排序`、`二叉树排序`、`二路归并排序`及`其他线形排序`是`稳定`的
+
+  `选择排序`、`希尔排序`、`快速排序`、`堆排序`是不稳定的
+
+  **2.时间复杂性比较**
+
+  插入排序、冒泡排序、选择排序的时间复杂性为`O(n2)`
+
+  其它非线形排序的时间复杂性为`O(nlog2n)`
+
+  线形排序的时间复杂性为`O(n)`;
+
+  **3.辅助空间的比较**
+
+  线形排序、二路归并排序的辅助空间为O(n)；
+
+  其它排序的辅助空间为O(1);
+
+  **4.其它比较**
+
+  * 插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度，但是在这种情况下，快速排序反而慢了。
+
+  * 当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
+
+  * 若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
+
+  * 当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
+
+  * 当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下宜用归并排序。
+
+  * 当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
+
+  常见的排序算法：
+
+  选择排序
+  ```java
+  public class SelectionSort {
+      public void selectionSort(int[] array) {
+          int temp;
+          for (int i = 0; i < array.length - 1; i++) {
+              for (int j = i + 1; j <= array.length - 1; j++) {
+                  if (array[i] > array[j]) {    
+                      // 注意和冒泡排序的区别，这里是i和j比较。
+                      temp = array[i];
+                      array[i] = array[j];
+                      array[j] = temp;
+                  }
+              }// 打印每趟排序结果
+              for (int m = 0; m <= array.length - 1; m++) {
+                  System.out.print(array[m] + "\t");
+              }
+              System.out.println();
+          }
+      }    
+      public static void main(String[] args) {
+          SelectionSort selectionSort = new SelectionSort();
+          int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
+          selectionSort.selectionSort(array);        
+          for (int m = 0; m <= array.length - 1; m++) {
+              System.out.print(array[m] + "\t");
+          }
+      }
+  }
+  ```
+  插入排序
+  ```java
+  public class InsertSort {
+      public void insertSort(int[] array, int first, int last) {        
+      int temp, i, j;        
+      for (i = first + 1; i <= last - 1; i++) {
+              temp = array[i];
+              j = i - 1;            
+          while (j >= first && array[j] > temp) {
+                  array[j + 1] = array[j];
+                  j--;
+              }
+              array[j + 1] = temp;            // 打印每次排序结果
+              for (int m = 0; m <= array.length - 1; m++) {
+                  System.out.print(array[m] + "\t");
+              }
+              System.out.println();
+          }
+      }    
+       public static void main(String[] args) {
+          InsertSort insertSort = new InsertSort();
+              int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
+          insertSort.insertSort(array, 0, array.length);      
+               for (int i = 0; i <= array.length - 1; i++) {
+              System.out.print(array[i] + "\t");
+          }
+      }
+  }
+  ```
+  快速排序
+  ```java
+  public class QuickSort {    
+      public int partition(int[] sortArray, int low, int height) {        
+      int key = sortArray[low];        
+      while (low < height) {            
+          while (low < height && sortArray[height] >= key)
+              height--;
+              sortArray[low] = sortArray[height];            
+              while (low < height && sortArray[low] <= key)
+                  low++;
+                  sortArray[height] = sortArray[low];
+              }
+              sortArray[low] = key;        // 打印每次排序结果
+          for (int i = 0; i <= sortArray.length - 1; i++) {
+              System.out.print(sortArray[i] + "\t");
+          }
+          System.out.println();        
+          return low;
+      }    
+      public void sort(int[] sortArray, int low, int height) {        
+          if (low < height) {            
+              int result = partition(sortArray, low, height);
+              sort(sortArray, low, result - 1);
+              sort(sortArray, result + 1, height);
+          }
+      }
+      public static void main(String[] args) {
+          QuickSort quickSort = new QuickSort();        
+          int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };        
+          for (int i = 0; i <= array.length - 1; i++) {
+              System.out.print(array[i] + "\t");
+          }
+          System.out.println();
+          quickSort.sort(array, 0, 8);        
+          for (int i = 0; i <= array.length - 1; i++) {
+              System.out.print(array[i] + "\t");
+          }
+      }
+  }
+  ```
+
+  希尔排序
+  ```java
+  public class ShellSort {
+      public void shellSort(int[] array, int n) {
+          int i, j, gap;
+          int temp;
+          for (gap = n / 2; gap > 0; gap /= 2) {
+              for (i = gap; i < n; i++) {       
+                  for (j = i - gap; j >= 0 && array[j] > array[j + gap]; j -= gap) {
+                      temp = array[j];
+                      array[j] = array[j + gap];
+                      array[j + gap] = temp;
+                  }                // 打印每趟排序结果
+                  for (int m = 0; m <= array.length - 1; m++) {
+                      System.out.print(array[m] + "\t");
+                  }
+                  System.out.println();
+              }
+          }
+      }
+       public static void main(String[] args) {
+          ShellSort shellSort = new ShellSort();
+          int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
+          shellSort.shellSort(array, array.length);        
+          for (int m = 0; m <= array.length - 1; m++) {
+              System.out.print(array[m] + "\t");
+          }
+      }
+  }
+  ```
diff --git "a/09 - J/interview/\345\272\223/01.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/01.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/01.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/01.md"
diff --git "a/09 - J/interview/\345\272\223/03.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/03.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/03.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/03.md"
diff --git "a/09 - J/interview/\345\272\223/04.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/04.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/04.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/04.md"
diff --git "a/09 - J/interview/\345\272\223/05.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/05.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/05.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/05.md"
diff --git "a/09 - J/interview/\345\272\223/06.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/06.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/06.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/06.md"
diff --git "a/09 - J/interview/\345\272\223/07.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/07.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/07.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/07.md"
diff --git "a/09 - J/interview/\345\272\223/08.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/08.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/08.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/08.md"
diff --git "a/09 - J/interview/\345\272\223/09.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/09.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/09.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/09.md"
diff --git "a/09 - J/interview/\345\272\223/10.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/10.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/10.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/10.md"
diff --git "a/09 - J/interview/\345\272\223/11.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/11.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/11.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/11.md"
diff --git "a/09 - J/interview/\345\272\223/12.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/12.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/12.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/12.md"
diff --git "a/09 - J/interview/\345\272\223/13.md" "b/09 - J \351\235\242\347\273\217/interview/\345\272\223/13.md"
similarity index 100%
rename from "09 - J/interview/\345\272\223/13.md"
rename to "09 - J \351\235\242\347\273\217/interview/\345\272\223/13.md"
diff --git a/09 - J/java115.md "b/09 - J \351\235\242\347\273\217/java115.md"
similarity index 100%
rename from 09 - J/java115.md
rename to "09 - J \351\235\242\347\273\217/java115.md"
diff --git a/09 - J/java200.md "b/09 - J \351\235\242\347\273\217/java200.md"
similarity index 100%
rename from 09 - J/java200.md
rename to "09 - J \351\235\242\347\273\217/java200.md"
diff --git "a/09 - J/\347\237\245\350\257\206\344\275\223\347\263\273.jpg" "b/09 - J \351\235\242\347\273\217/\347\237\245\350\257\206\344\275\223\347\263\273.jpg"
similarity index 100%
rename from "09 - J/\347\237\245\350\257\206\344\275\223\347\263\273.jpg"
rename to "09 - J \351\235\242\347\273\217/\347\237\245\350\257\206\344\275\223\347\263\273.jpg"
diff --git "a/09 - J/\350\267\257\347\272\277.jpg" "b/09 - J \351\235\242\347\273\217/\350\267\257\347\272\277.jpg"
similarity index 100%
rename from "09 - J/\350\267\257\347\272\277.jpg"
rename to "09 - J \351\235\242\347\273\217/\350\267\257\347\272\277.jpg"
diff --git "a/09 - J/\351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.pdf" "b/09 - J \351\235\242\347\273\217/\351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.pdf"
similarity index 100%
rename from "09 - J/\351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.pdf"
rename to "09 - J \351\235\242\347\273\217/\351\235\242\347\273\217--\345\200\276\345\220\254\346\275\256\346\261\220.pdf"
diff --git a/09 - J/me/JL.txt b/09 - J/me/JL.txt
deleted file mode 100644
index 898ae96b..00000000
--- a/09 - J/me/JL.txt	
+++ /dev/null
@@ -1,29 +0,0 @@
-https://juejin.im/post/5a22b4455188253e2470c991
-
-1. 教育经历
-“文凭对一个程序员很重要？” “我专科毕业怎么了，代码照样写的 666”。我无意引战，对这一点有表达的冲动建议移步 zhihu - 请问文凭对一个程序员的影响有多大？。一言以蔽之：在离职季、特别是校招季，大厂里推送、筛选简历都是批量来的，这时候的时间成本会变得尤为重要。一个不成熟的小建议：常春藤/985/211/一流/双一流之类，请不要吝啬你的校名，加粗最好！至于其他，就硕士写硕士本科写本科，依此类推。当你没有一个亮眼的教育背景时，这一项建议也不要删，因为这样要么直接被 pass，没被 pass 后面 HR 也一定会问到。别放在最显眼的位置就 OK。
-2. 工作/实习/获奖经历
-社招突出工作经验，主要是重要项目的介绍，按照得意程度排序（一般企业项目居多的情况下，有自己独立维护的优秀项目则更为加分）。校招突出技术相关的获奖（ACM、数学建模、软件设计大赛等，没得奖？各种 OJ 刷题数目也可以是算是体现吧）和校内或者实习项目经历。
-3. 自我评价
-客观且简洁的自我评价很有可能就是面试官对你的整体印象。切记不要太多。
-再说说内容上的常见问题吧：
-1. 切忌夸大、绝不能造假 （真实！真实！真实！）
-造假是万万不能接受的。岗位要求三年经验，你只有两年，为了应聘你写成三年？在网上搜出来的文章/copy的项目你告诉别人自己的原创然后一问三不知？我认为甚至“精通”、“熟悉” 这种词汇也要慎用。你用过 Express 就真的敢写“精通” Node 吗？“精通” Angular/React/Vue ！（哈哈哈哈感觉已被玩坏）。这些我基本都真实的遇见过，也真的难以接受这种程度的“润色”。
-2. 务必突出优势
-你的优势是什么？良好的学历背景？丰富的项目经验？你最得意的项目或者研究的最透彻的技术是哪一个？简历不是流水账，最重要的请放最醒目显眼的位置。有候选人在首页赫然用大大的字体写着 Github 地址和个人项目地址。但我发现 Github 都是 folk 别人的仓库，个人项目访问直接 503，囧。当然这个例子听起来很极端，但确确实实被我遇见了。你应该在真实的前提下，把自己最好的一面展现出来。什么？你觉得你没有任何优势？好吧，你的优势是为人耿直 =,=
-3. 控制篇幅
-不说了，今天刚看到一个 8 页纸的简历。HTML + CSS + JS 技能 5 星（你没看错，真的给自己画一排一排的彩色大星星），Node 技能 5 星，Python 技能 4 星半 。。。精通 Vue， 精通 Linux，精通 Webpack 。。。最可以的是，代码大截图！项目交互稿大截图！工位正面照！工位侧面照！团建合照！（给你们一个眼神自己体会）
-关于样式 or 格式，我认为整洁大方就可以。
-样式中的一些黑点：
-1. 普通人刀耕火种（平面设计专业/处女座且有设计天赋的除外）
-因为几乎所有人都认为自己“精通”或者至少“熟悉” Word、Excel，所以很多人可能会徒手从零开始制作简历。从而一些基本格式问题：项目列表没有完全对齐、随心所欲的字体（中文可选：微软雅黑宋体楷体，英文可选：Arial/Helvetica/Times New Roman）、蹩脚表格和丑陋的边框、相同内容行间距忽大忽小时常发生。可能我对于细节的龟毛程度高于常人，外观不精致加上内容不出彩一般都会直接 bye bye。
-2. 套用粗糙的模版
-套模版是一个很好的选择，但需要套用优秀的模版，否则就和第一种情况毫无区别。好的模版就如 Markdown 之于技术博主，它把样式留给自己，把内容留给你。试一试《求职向 15+优质实用的个人简历模板》 , 《7款简洁精致的求职简历模板》。总有一款适合你，稍作改动也可以有极具个性的表现
-为了更平滑的过度到 Part2，我给出几个个性化简历表现方式的示例：
-
-技术人员中流行的在线简历：http://pinkyjie.com/resume/
-前端工程师可以这么玩： http://strml.net/
-国人版：https://github.com/jirengu-inc/animating-resume
-还有一种我认为技术人员通用的玩法： https://segmentfault.com/a/1190000011991761
-
-http://elevenbeans.me/
diff --git a/09 - J/me/salary.md b/09 - J/me/salary.md
deleted file mode 100644
index 2c00eb90..00000000
--- a/09 - J/me/salary.md	
+++ /dev/null
@@ -1,31 +0,0 @@
-阿里巴巴（杭州） 16薪  15/17
-
-腾讯（深圳）  17薪 15k房补  13.5/16.5/18.5
-
-百度（北京） 14.6 薪 16
-
-京东（北京） 13薪
-
-美团（北京 上海） 15.5薪 14.5/16.5
-
-携程（上海） 15薪  13/14/15/16.5
-
-滴滴（北京） 15薪
-
-
-面试造火箭，上班拧螺丝，回家造轮子
-
-上海：
-
-游族网络 15薪
-
-平安 16.8 薪 加薪20%
-校招技术岗统一价 硕士12*16.5 本科9.5*16.5 加班费每天30块 无车补房补一切补贴福利 offer座谈会从10点一直开到12点半 连工作餐都不请吃一顿。同车的同学怨声载道。
-
-东方财富 13薪
-
-招商信用卡中心
-公司额外5%公积金 180万低息贷款，每年可省2-3万 年假7天 上班时间965，有加班费 试用期8折
-
-喜马拉雅 16薪
-试用期3个月，试用期8折，不加班，双休
diff --git a/09 - J/me/work.txt b/09 - J/me/work.txt
deleted file mode 100644
index 0fc621be..00000000
--- a/09 - J/me/work.txt	
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-cas 单点登录
-
-redis 
-
-elasticsearch
-
-
diff --git "a/09 - J/question/180119 \347\224\265\350\257\235.txt" "b/09 - J/question/180119 \347\224\265\350\257\235.txt"
deleted file mode 100644
index b27778a7..00000000
--- "a/09 - J/question/180119 \347\224\265\350\257\235.txt"	
+++ /dev/null
@@ -1,37 +0,0 @@
-
-基本类型
-	8个
-	byte short int long
-	float double
-	char
-	boolean
-
-构造方法重载
-	重载 含义掌握 就知道构造方法无法重载
-
-重载的含义
-
-多线程实现方式 runnable
-	Callable不太了解
-	相同点：
-		两者都是接口；（废话）
-		两者都可用来编写多线程程序；
-		两者都需要调用Thread.start()启动线程；
-	不同点：
-		两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
-		Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；
-	注意点：
-		Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！
-
-voliate
-	含义
-	与 synchronize分清楚
-
-
-接口与抽象类	区别
-
-jdbc
-	PreparedStatement
-
-快排
-	思想
diff --git a/09 - J/question/180124.txt b/09 - J/question/180124.txt
deleted file mode 100644
index 9c36f5d8..00000000
--- a/09 - J/question/180124.txt	
+++ /dev/null
@@ -1,33 +0,0 @@
-链表反转 pre cur next
-数组中最多存在的数是否大于其余数个数总和
-
-object.wait()
-thread.sleep()
-
-Thread.sleep不会导致锁行为的改变，如果当前线程是拥有锁的，那么Thread.sleep不会让线程释放锁。
-如果能够帮助你记忆的话，可以简单认为和锁相关的方法都定义在Object类中，因此调用Thread.sleep是不会影响锁的相关行为。
-
-Thread.sleep和Object.wait都会暂停当前的线程，对于CPU资源来说，不管是哪种方式暂停的线程，都表示它暂时不再需要CPU的执行时间。
-OS会将执行时间分配给其它线程。区别是，调用wait后，需要别的线程执行notify/notifyAll才能够重新获得CPU执行时间。
-
-线程的状态参考 Thread.State的定义。新创建的但是没有执行（还没有调用start())的线程处于“就绪”，或者说Thread.State.NEW状态。
-
-Thread.State.BLOCKED（阻塞）表示线程正在获取锁时，因为锁不能获取到而被迫暂停执行下面的指令，一直等到这个锁被别的线程释放。
-BLOCKED状态下线程，OS调度机制需要决定下一个能够获取锁的线程是哪个，这种情况下，就是产生锁的争用，无论如何这都是很耗时的操作。
-
-sleep不会交出任何已获得的对象锁The thread does not lose ownership of any monitors Thread (Java Platform SE 7 )
-
-wait会交出调用wait对象的对象锁。而且wait存在notify方法来唤醒调用wait的线程，这个是sleep没有的。
-
-sleep 让线程从 【running】 -> 【阻塞态】 时间结束/interrupt -> 【runnable】
-wait 让线程从 【running】 -> 【等待队列】notify  -> 【锁池】 -> 【runnable】
-
-
-
-
-
-int byte 字节 范围
-
-数组 装篮子 arr[] n
-递归法
-贪心算法
diff --git "a/09 - J/question/JAVA\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\346\200\273\347\273\223\357\274\214\351\253\230\346\211\213\346\225\264\347\220\206\345\212\240\345\274\272\347\211\210.txt" "b/09 - J/question/JAVA\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\346\200\273\347\273\223\357\274\214\351\253\230\346\211\213\346\225\264\347\220\206\345\212\240\345\274\272\347\211\210.txt"
deleted file mode 100644
index 817080e3..00000000
--- "a/09 - J/question/JAVA\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\346\200\273\347\273\223\357\274\214\351\253\230\346\211\213\346\225\264\347\220\206\345\212\240\345\274\272\347\211\210.txt"	
+++ /dev/null
@@ -1 +0,0 @@
-http://blog.csdn.net/javaniuniu/article/details/51788055
\ No newline at end of file
diff --git "a/09 - J/question/JVM\347\232\204GC ROOTS\345\255\230\345\234\250\344\272\216\351\202\243\344\272\233\345\234\260\346\226\271.txt" "b/09 - J/question/JVM\347\232\204GC ROOTS\345\255\230\345\234\250\344\272\216\351\202\243\344\272\233\345\234\260\346\226\271.txt"
deleted file mode 100644
index 52657e31..00000000
--- "a/09 - J/question/JVM\347\232\204GC ROOTS\345\255\230\345\234\250\344\272\216\351\202\243\344\272\233\345\234\260\346\226\271.txt"	
+++ /dev/null
@@ -1,16 +0,0 @@
-
-问到这个问题应该是前面一步步引导过来的，如果没有，在直接回答这个问题之前，最好简要描述一下JVM的内存结构和根搜索算法（GC ROOTS Tracing）做可达性分析。
-
-GC Roots的对象包括如下几种：
-
-⭐️  虚拟机栈(栈桢中的本地变量表)中的引用的对象
-
-⭐️  方法区中的类静态属性引用的对象
-
-⭐️  方法区中的常量引用的对象
-
-⭐️  本地方法栈中JNI的引用的对象
-
-GC管理的主要区域是Java堆，一般情况下只针对堆进行垃圾回收。
-
-方法区、栈和本地方法区不被GC所管理，因而选择这些区域作为GC ROOTS。被GC ROOTS引用的对象不会被垃圾回收。
\ No newline at end of file
diff --git "a/09 - J/question/java cas\347\232\204\346\246\202\345\277\265.txt" "b/09 - J/question/java cas\347\232\204\346\246\202\345\277\265.txt"
deleted file mode 100644
index 0d25dcad..00000000
--- "a/09 - J/question/java cas\347\232\204\346\246\202\345\277\265.txt"	
+++ /dev/null
@@ -1,6 +0,0 @@
-cas:compare and swap，比较并交换
-
-java的concurrent包中借助cas实现了区别于synchronized同步锁的一种乐观锁。
-
-CAS利用CPU的CAS指令，同时借助JNI来完成java的非阻塞算法，其他的原子操作都是利用类似的特性完成的。
-java的concurrent包相对于使用synchronized性能提升也是主要依赖于它。
\ No newline at end of file
diff --git "a/09 - J/question/mysql innodb\346\200\216\346\240\267\345\201\232\346\237\245\350\257\242\344\274\230\345\214\226.txt" "b/09 - J/question/mysql innodb\346\200\216\346\240\267\345\201\232\346\237\245\350\257\242\344\274\230\345\214\226.txt"
deleted file mode 100644
index 72cc2d72..00000000
--- "a/09 - J/question/mysql innodb\346\200\216\346\240\267\345\201\232\346\237\245\350\257\242\344\274\230\345\214\226.txt"	
+++ /dev/null
@@ -1,16 +0,0 @@
-
-这个问题的答案就比较多了，各人的心得都是不一样的。主要考察在工作实践中的总结和思考能力。最好面试者能在总结的通用答案之后加上实际项目中的使用例子。
-
-　　⭐️  innodb_buffer_pool_size 此参数的作用是缓冲数据和索引，对性能可以产生线性的提高，最大可设置为内存大小的百分之七八十的样子
-
-　　⭐️  打开慢查询日志，增加参数：log-queries-not-using-indexes，方便把系统中没有走索引的sql语句全抓出来优化
-
-　　⭐️  通过explain做查询分析，看看有没有用索引，访问的行数rows
-
-　　⭐️  关闭skip_name_resolve，减少逆向DNS解析的消耗
-
-　　另外还有一些实际写代码过程中深入骨髓的，比如数据动静分离提高query_cache的命中率啦，减少字段冗余，减少查询次数啦，复杂查询分解啦，分页优化啦啥的。
-
-　　很多人说面试题和实际开发联系不大，觉得没啥用。其实很多活培训两个月都是能干的。人和人之间的差距确实没有明显到你能干我不能干的程度。但是之前做过一个项目，我和别人一起干，干完之后我要修改很多其他人的各种慢查询问题啦，性能问题啦之类。我看了他们写的sql，我发现这些sql我会理所当然不那么用的。因为我在人人的时候就很注意这些方面，我认为是理所当然的，知道这样影响性能。
-
-　　还有就是面试评价好的人实际写代码的时候确实出的问题要少，因为他们考虑更全面。很多人不是有意要出bug的，但是确实是不知道啊，不知道要考虑情况A，情况B，不知道JVM底层的实现，所以有可能会产生的意想不到的结果。出了问题了也不知道往哪个方向去想。
\ No newline at end of file
diff --git "a/09 - J/question/\345\246\202\344\275\225\345\256\232\344\275\215\347\272\277\344\270\212\346\234\215\345\212\241OOM\351\227\256\351\242\230\343\200\200.txt" "b/09 - J/question/\345\246\202\344\275\225\345\256\232\344\275\215\347\272\277\344\270\212\346\234\215\345\212\241OOM\351\227\256\351\242\230\343\200\200.txt"
deleted file mode 100644
index 9b477987..00000000
--- "a/09 - J/question/\345\246\202\344\275\225\345\256\232\344\275\215\347\272\277\344\270\212\346\234\215\345\212\241OOM\351\227\256\351\242\230\343\200\200.txt"	
+++ /dev/null
@@ -1,14 +0,0 @@
-
-Java服务OOM，比较常见的原因是
-
-有可能是内存分配确实过小，而正常业务使用了大量内存
-
-	比如jmap -heap命令可以查看新生代老年代的堆内存大小及使用情况，看看是否内存本身分配过小。
-
-某一个对象被频繁申请，却没有释放，内存不断泄漏，导致内存耗尽
-
-	比如jmap -histo:live 对象显示存活对象的信息，并按照所占内存大小的排序。因为包含了实例数、所占内存大小、类名，所以很直观。
-
-某一个资源被频繁申请，系统资源耗尽，例如：不断创建线程，不断发起网络连接　　
-	
-	可以用pstree、netstat查看进程创建线程数，网络连接数，如果资源耗尽，也会出现OOM。也可以查看/proc/${PID}/fd  和/proc/${PID}/task，查看句柄详情和线程数。
\ No newline at end of file
diff --git "a/09 - J/question/\346\200\216\346\240\267\347\220\206\350\247\243\351\230\273\345\241\236\351\235\236\351\230\273\345\241\236\344\270\216\345\220\214\346\255\245\345\274\202\346\255\245\347\232\204\345\214\272\345\210\253\357\274\237.txt" "b/09 - J/question/\346\200\216\346\240\267\347\220\206\350\247\243\351\230\273\345\241\236\351\235\236\351\230\273\345\241\236\344\270\216\345\220\214\346\255\245\345\274\202\346\255\245\347\232\204\345\214\272\345\210\253\357\274\237.txt"
deleted file mode 100644
index cddcfaf9..00000000
--- "a/09 - J/question/\346\200\216\346\240\267\347\220\206\350\247\243\351\230\273\345\241\236\351\235\236\351\230\273\345\241\236\344\270\216\345\220\214\346\255\245\345\274\202\346\255\245\347\232\204\345\214\272\345\210\253\357\274\237.txt"	
+++ /dev/null
@@ -1,31 +0,0 @@
-
-“阻塞”与"非阻塞"与"同步"与“异步"不能简单的从字面理解，提供一个从分布式系统角度的回答。
-
-1.同步与异步
-同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication)
-所谓同步，就是在发出一个*调用*时，在没有得到结果之前，该*调用*就不返回。但是一旦调用返回，就得到返回值了。
-换句话说，就是由*调用者*主动等待这个*调用*的结果。
-
-而异步则是相反，*调用*在发出之后，这个调用就直接返回了，所以没有返回结果。
-换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在*调用*发出后，*被调用者*通过状态、通知来通知调用者，或通过回调函数处理这个调用。
-典型的异步编程模型比如Node.js
-
-举个通俗的例子：你打电话问书店老板有没有《分布式系统》这本书，如果是同步通信机制，
-书店老板会说，你稍等，”我查一下"，然后开始查啊查，等查好了（可能是5秒，也可能是一天）告诉你结果（返回结果）。
-而异步通信机制，书店老板直接告诉你我查一下啊，查好了打电话给你，然后直接挂电话了（不返回结果）。然后查好了，他会主动打电话给你。在这里老板通过“回电”这种方式来回调。
-
-2. 阻塞与非阻塞
-阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
-阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
-
-非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。
-
-还是上面的例子，你打电话问书店老板有没有《分布式系统》这本书，
-你如果是阻塞式调用，你会一直把自己“挂起”，直到得到这本书有没有的结果，
-如果是非阻塞式调用，你不管老板有没有告诉你，你自己先一边去玩了， 
-
-当然你也要偶尔过几分钟check一下老板有没有返回结果。
-
-在这里阻塞与非阻塞与是否同步异步无关。跟老板通过什么方式回答你结果无关。
-
-如果是关心blocking IO/ asynchronous IO, 参考  Unix Network Programming View Book
\ No newline at end of file
diff --git "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/2017-10-23.txt" "b/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/2017-10-23.txt"
deleted file mode 100644
index 7abd196a..00000000
--- "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/2017-10-23.txt"	
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
-1. JAVA基础扎实：精通多线程编程，熟悉分布式,缓存,消息队列等机制；熟悉JVM，包括内存模型、类加载机制以及性能优化；
-2. 对各种开源的框架如Spring、Hibernate等有深入的了解，对框架本身有过开发或重构者可优先考虑；
-3. 精通关系型数据库设计及SQL,精通unix/linux操作系统；
-4. 具备良好的识别业务关键需求和设计领域模型的能力；
-5. 热爱技术，工作认真、严谨，对系统质量有近乎苛刻的要求意识，善于沟通与团队协作；
-6. 有大型分布式、高并发、高负载、高可用性系统设计和稳定性经验优先；
-
-1. 扎实的Java编程基础，熟悉Linux下高并发，多线程原理，三年以上分布式系统开发工作经验；
-2. 对常见分布式开源项目（RPC，MQ，Spark等）原理有深入理解，深入源码研究，有造轮子或重构经验者更佳；
-3. 具备良好业务理解和沟通能力，工作认真、严谨、敬业，对系统质量有近乎苛刻的要求意识；
-4. 具有良好的数据敏感度，有数据分析，数据相关工作经验优先；
-5. 愿景驱动，愿投身推动无现金社会事业挖掘自身潜力；
-
-1、扎实的java编程基础，精通Java EE、SOA、OSGI等相关技术；对各种开源的框架如Spring、Hibernate等有深入的了解，对框架本身有过开发或重构者可优先考虑；
-2、三年以上大型数据库如oracle使用经验，3年以上大规模高并发访问的Web应用系统设计和开发经验；
-3、熟练掌握unix/linux操作系统，对常用命令运用娴熟，能够根据实际需要快速编写shell脚本；
-4、具备良好的识别和设计通用框架及模块的能力；
-5、较强的表达和沟通能力；工作认真、严谨、敬业，对系统质量有近乎苛刻的要求意识；
-6、具有大型电子商务网站以及银行业核心系统、电信boss系统设计与研发经验背景的优先考虑。
-
-1 ）本科及以上学历，计算机相关专业，2 年以上 Java 开发经验；
-2 ）了解高并发、高性能分布式系统设计方法；
-3 ）熟悉主流技术框架，熟悉 Spring Boot, Spring Cloud 等微服务框架；
-4 ）熟悉 MongoDB、MYSQL 数据库，有 NoSQL 数据库应用经验；
-5 ）了解消息中间件（ RocketMQ、RabbitMQ、Kafaka 等一种或多种）的原理及应用；
-6 ）熟悉 HTTP(S)协议，了解 TCP/IP 协议相关知识；
-7 ）有开源项目经验优先；
-
-高级
-1 ）具有分布式、大流量系统，具有大型分布式、高并发、高负载、高可用、强一致性系统设计开发经验；
-2 ） 3 年以上 Java 经验，1 年以上（或特别熟悉） SpringCloud 微服务开发部署调优经验；
-3 ）熟悉基于 Spring boot、Spring Cloud 的微服务架构，能够出具完善的应用实施解决方案；
-4 ）扎实的 java 编程基础， 熟练使用 Java EE、SOA、OSGI、线程等相关技术；对各种开源的框架如 Spring、mybatis、spring boot、spring cloud 等有深入的了解，对框架本身有过开发或重构者可优先考虑；
-5 ）熟悉 Redis、Mysql 调优者优先；
-6 ）熟悉 Hadoop、Spark、Storm 等大数据技术者优先；
-7 ） 熟悉 Linux 操作系统，熟悉分布式系统的性能监控，性能分析与性能调优者优先；
-
-
-JAVA P5/P6/P7
-职位描述
-1、数据分析层多维 /统计 /智能分析业务功能的功能研发，迭代与优化
-2、开放平台的网关、API 开发和对外开放和集成相关文档维护
-3、对接底层智能数据分析引擎，统一向下游 /外部提供准确，稳定，快速的数据查询与分析能力
-4、java spring mvc 基础架构的能力提供。包括抽象领域模型设计实现，Bi 分析组件模块搭建，消息告警通知，安全与权限管控，上传下载功能，协作能力。
-5、持续优化整个基础商业智能分析模块的架构，规范化调优整个平台的性能与稳定性。保障架构的健壮性，容灾能力和可发展性。在多线程高并发高压力恶意 hack 的外部环境下保障整个系统的稳定性。
-6、对 BI 业务保有极高的研发热情。能快速对理解业务并作出合理的技术应用逻辑推导并且落地实现。
-7、移动端基础服务开放的研发 /维护 /优化工作
-8、web 端基础架构，模块与服务的研发 /维护 /优化工作
-9、各个云环境功能的研发 /运维 /优化工作
-
-职位要求
-1、熟悉 Spring、SpringMVC,、Mybatis，清楚框架实现原理和核心思想
-2、熟悉 SQL，数据库事务，多线程，缓存技术
-3、熟悉 Maven、Git 等项目管理和构建工具
-4、熟悉 JAVA，了解 JVM 原理
-5、熟悉常见的设计模式
-6、能够快速理解业务，并转化为合适的技术方案
-7、拥有良好的团队合作精神
-8、拥有良好的表达沟通能力，能够快速理解问题，并能够准确流畅地阐述自己的观点
diff --git "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/ctrip.md" "b/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/ctrip.md"
deleted file mode 100644
index 36c19d49..00000000
--- "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/ctrip.md"	
+++ /dev/null
@@ -1,51 +0,0 @@
-工作职责：
-1、负责相关项目及变更的设计与开发，确保代码的质量；
-2、参与相关产品需求讨论与产品系统架构的设计优化工作；
-3、负责相关系统的技术运营，确保系统的性能及稳定。
-任职资格：
-1、2年以上Java开发经验，熟练掌握JVM基础原理，JAVA基础知识
-2、了解内存/CPU相关基础知识
-3、了解TCP/HTTP协议
-4、理解SOA架构，OO/AOP
-5、了解MSSQL/MYSQL，了解常用SQL最佳实践
-6、了解MQ/Schedule/ES等使用场景和基本原理
-7、有.NET/python经验者更佳
-8、具备较好的沟通表达能力、较强的团队精神，工作积极、勇于创新。
-
-工作职责：    
-1、按照业务需求完成系统的开发，自测，上线；    
-2、负责对所开发系统不断优化，确保核心技术指标不断改善；    
-3、负责提升系统的用户体验，对性能、稳定性等不懈追求。    
-任职资格：    
-1、计算机或相关专业本科以上学历；    
-2、三年及以上Java经验，两年以上互联网行业大型企业应用系统开发相关经验；    
-3、熟悉JavaEE相关技术和框架（包括Java语言/Struts/Spring/iBatis/hibernet等）；  
-4、配置人员需熟悉Windows 2003和windows2008 R2的IIS配置，ServU配置，对.Net Framework有初步了解；    
-5、做事积极主动，沟通能力强，对工作认真负责，有较强责任心和事业心，有团队精神；    
-6、熟悉接口技术，如webservice等；    
-7、熟悉sqlserver，mysql等数据库，能熟练运用sql语言等；    
-8、了解Java环境下的并发编程以及应用优化。    
-
-工作职责：
-1、负责相关项目及变更的设计与开发，确保代码的质量；
-2、参与相关产品需求讨论与产品系统架构的设计优化工作；
-3、负责相关系统的技术运营，确保系统的性能及稳定。
-任职资格：
-1、2年以上Java开发经验，熟悉Java core和开源项目，有互联网开发经验者优先；
-2、具备丰富的JQuery、SpringMVC、Mybatis、Hibernate等开源框架的编程经验；
-3、熟悉MySQL/Sql Server/HBase数据库技术，有数据库调优经验者优先；
-4、熟悉SOA、Cache(Redis/Memcached)、Elasticsearch、NoSQL、MQ等知识，有后台开发经验者优先；
-5、具备较好的沟通表达能力、较强的团队精神，工作积极、勇于创新。
-
-工作职责：
-1.负责旅行日程和直播业务后台系统的开发和维护工作；
-2.对线上系统进行bug修复以及日常维护发布等工作。
-任职资格：
-1.全日制大学本科以上学历，计算机、软件工程及相关专业毕业；
-2.具有2年以上Java使用经验以及Web开发经验；
-3.熟练使用Java主流框架，如Spring，Spring-boot等；
-4.熟练使用Web开发的主流框架，如AngularJS，Bootstrap等；
-5.熟练使用SQL Server，My SQL等数据库；
-6.具备良好地沟通能力，责任心以及耐心；
-7.具备良好地分析，定位以及解决问题的能力；
-8.有C#使用/开发经验者优先考虑。
diff --git "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/\345\226\234\351\251\254\346\213\211\351\233\205.md" "b/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/\345\226\234\351\251\254\346\213\211\351\233\205.md"
deleted file mode 100644
index 39f43954..00000000
--- "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/java/\345\226\234\351\251\254\346\213\211\351\233\205.md"	
+++ /dev/null
@@ -1,44 +0,0 @@
-职位诱惑：
-年终4薪,技术大牛,音频独角兽,弹性工作
-
-职位描述：
-职位要求：
-1. 本科及以上学历，计算机相关专业；良好的英文读写能力；
-2. 1年以上大型互联网电子商务系统或者其他大型企业应用系统开发相关经验；精通Java相关技术和框架
-（包括Java语言基础/多线程Velocity/Spring/Hibernate/iBatis/Cache/Message等）；
-3. 有Web及前端技术开发经验（包括Javascript， ajax， json， HTML， XML， MVC 类Web开发框架）；
-4. 熟悉MySQL等数据库设计和开发；
-5. 熟悉Redis， Memcached， Hbase， Mongodb等NOSQL的设计和开发
-6. 熟悉企业应用设计模式、面向对象的分析和设计技术，包括设计模式、 UML建模等；
-7. 熟练掌握数据结构、常用算法；
-8. 思路清晰，善于思考，能独力分析和解决问题；
-9. 热衷于互联网技术的研究和创新；
-10. 责任心强，具备良好的团队合作精神；
-11. 符合如下条件者优先： 具有高并发开发经验； 有SNS应用开发经验； 有移动互联网开发经验； 熟练掌
-握Python， Groovy， Scala或其他动态语言中的一种以上；
-
-
-职位诱惑：
-技术大牛、音频独角兽、发展平台、弹性工作
-
-职位描述：
-职位描述：
-
-1.开发网络营销SEM/SEO后台管理系统；
-2.从事核心部分代码的编写；
-3.进行业务需求分析和软件设计，并编码实现；
-
-
-任职要求：
-1.本科及以上学历，计算机相关专业；良好的英文读写能力；
-2.两年以上互联网或者其他企业应用系统开发相关经验；精通Java EE相关技术和框架（包括Java语言基础/多线程Velocity/FreeMaker,Spring,Hibernate/iBatis,Cache,Messaging,Workflow 等）；
-3.有Web及前端技术开发经验（包括Javascript，ajax，jason，HTML，XML，MVC 类Web开发框架）；
-4.熟悉MySQL或Oracle的数据库设计和开发；
-5.熟悉Redis，Memcached，Hbase，Mongodb等一种或多种NOSQL的设计和开发；
-
-6.了解JMS或AMQ，如activemq，rabbitmq等；
-7.了解企业应用设计模式、面向对象的分析和设计技术，包括设计模式、UML建模等；
-8.熟练掌握数据结构、常用算法；
-9.思路清晰，善于思考，能独立分析和解决问题；
-10.热衷于互联网技术的研究和创新；
-11.责任心强，具备良好的团队合作精神
diff --git "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/\344\272\272\345\267\245\346\231\272\350\203\275AI/JD.md" "b/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/\344\272\272\345\267\245\346\231\272\350\203\275AI/JD.md"
deleted file mode 100644
index f6e24c95..00000000
--- "a/09 - J/\345\205\254\345\217\270\350\246\201\346\261\202 JOB Detail JD/\344\272\272\345\267\245\346\231\272\350\203\275AI/JD.md"	
+++ /dev/null
@@ -1,77 +0,0 @@
-#### 沪江 25k-35k /上海 / 经验3-5年 / 本科及以上 / 全职
-工作职责：<br/>
-1.利用深度学习技术进行前沿人工智能技术研发；进行人工智能相关前沿算法的研究，包括机器学习、知识图谱等技术的研究；<br/>
-2.负责深度学习，强化学习平台的选型，框架搭建，开发及优化<br/>
-3.探索研究人工智能在自适应学习的应用；开发基于互联网教育大数据的人工智能应用系统和平台。<br/>
-4.开发自然语言处理（NLP）应用系统，负责模型算法的工程化实现、服务接口的实现。 <br/>
-
-任职资格：<br/>
-1.专业不限、背景不限；仅限对人工智能、机器学习及互联网教育有浓厚兴趣和充满热情，有的责任心、好奇心。<br/>
-2.熟悉深度神经网络的常用模型（CNN、RBN、RCNN、DNN等），并能够将其应用特定场景中；熟练掌握常用的统计机器学习算法（神经网络、逻辑回归、决策树、SVM、Boosting等）<br/>
-3.具有熟练的编程能力，熟悉Java或C++或Python、主流开发框架，有大型项目的开发经验和工作能力。<br/>
-4.有机器学习的算法基础和经验优先，有NLP经验优先，熟练使用Caffe、Theano、Torch、Tensorflow等任一种主流的深度学习框架优先。<br/>
-
-#### 15k-30k /上海 / 经验3-5年 / 本科及以上 / 全职
-
-工作职责： <br/>
--从事机器学习算法的研究与分布式开发<br/>
--将算法应用到海量数据处理中，解决项目的机器学习问题，比如视频识别等。 <br/>
--利用机器学习从海量异构数据中进行有价值信息的挖掘和整合。<br/>
-
-职位要求： <br/>
--计算机、数学相关专业本科以上学位 。<br/>
--了解机器学习的基本算法模型，了解机器学习问题求解方法 。<br/>
--能够使用一种编程语言实现各种算法。<br/>
--有使用tensorflow实现机器学习算法经验者优先。<br/>
--良好的算法基础，有相关竞赛经历者优先。<br/>
--能够阅读英文技术文档及论文，具有良好的自学能力。<br/>
-
-#### 40k-70k /上海 / 经验5-10年 / 本科及以上 / 全职
-岗位职责：<br/>
-1. 调研，设计并落实人工智能（AI）在集团不同业务部门，不同应用场景中的实现； 规划智能人机交互包括语音合成、语音识别、手势识别、自然语言处理、情绪识别、人脸识别、图像处理等AI技术在集团整体的发展路线图；<br/>
-2.与技术团队共同参与核心代码的书写，组织解决项目开发过程中的重大技术问题；<br/>
-3. 对人工智能技术的研究，包括机器学习、智能控制、知识应用、智能决策等技术的研究；<br/>
-4. 负责人工智能技术的对外合作、引进、协调和沟通。<br/>
-
-岗位要求：<br/>
-1. 985/211大学硕士学历及以上，计算机科学、电子信息、数学等相关专业；<br/>
-2. 5年以上从事人工智能、文字、图像、语音和语言处理，或智能机器人领域的工作经验；<br/>
-4. 对人工智能领域的发展方向有清楚明确的认识，有较强的技术前瞻能力；能站在战略全局高度来统筹协调业务的能力；<br/>
-5. 具备图像处理及模式识别的基础理论和算法知识；<br/>
-6. 熟悉机器学习、智能控制、知识表示、知识应用、智能决策等方面的知识；<br/>
-7. 熟悉语音识别、声纹识别技术等相关语音处理技术；<br/>
-8. 良好的编程能力，熟悉C/C++, Java, 或 Perl, Python 等编程语言，能够对算法进行验证和实现。<br/>
-
-#### 30k-35k /上海 / 经验1-3年 / 本科及以上 / 全职
-
-工作职责<br/>
-1.参与机器学习平台的搭建，为数据分析提取提供平台支持。<br/>
-2.参与各类业务的机器学习相关需求的开发和支持。<br/>
-3.集成各类成熟的机器学习算法以及计算平台。<br/>
-4.主要偏向智能搜索方向的AI工作<br/>
-
-任职要求<br/>
-1.本科及以上学历,计算机及相关专业，有扎实的数据结构和算法基础；<br/>
-2.精通 Java、Python 或 C++ 等任意一种主流开发语言；<br/>
-3.熟悉数理统计、数据分析及挖掘、常用机器学习算法;<br/>
-4.熟悉开源机器学习平台其中一种或几种，如 Tensorflow、DeepLearning4J、Keras、Theano、PyTorch、Caffe ，研究过相关源码或者做过相关的优化更佳<br/>
-5.熟悉关系数据、NoSQL数据工具以及大数据技术至少一种产品，如 MySQL、MongoDB、Redis、Hadoop、Hive、Spark等；<br/>
-6.数据挖掘、机器学习相关方向2年以上工作经验，有机器学习、数据挖掘等相关项目实际经验者优先；<br/>
-7.富有创新精神，充满激情，乐于接受挑战，良好的沟通技巧和团队合作精神；<br/>
-
-#### 携程 20k-40k /上海 / 经验3-5年 / 本科及以上 / 全职
-
-工作职责：<br/>
-1.利用机器学习、深度学习、强化学习技术进行前沿人工智能技术研发；进行人工智能相关前沿算法的研究，包括机器学习、知识图谱等技术的研究；<br/>
-2.负责机器学习、深度学习、强化学习平台的选型，框架搭建，开发及优化；<br/>
-3.或具有图形图像、视频处理、识别软件开发经验，熟悉OpenGL\OpenCV；<br/>
-4.开发相关应用系统，负责模型算法的工程化实现、服务接口的实现；<br/>
-5.熟练使用Tensorflow、Caffe等。<br/>
-
-任职资格：<br/>
-1.对人工智能、机器学习有扎实的理论功底和实践经验；<br/>
-2.具有熟练的编程能力，至少熟悉Java、C++、Python其中一门语言；<br/>
-3.国内外知名学术机构本科及以上学历，具备良好的数学和统计学基础。<br/>
-
-
-
diff --git a/10 - Reading Notes/Effective Java/all.md "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Effective Java/all.md"
similarity index 92%
rename from 10 - Reading Notes/Effective Java/all.md
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Effective Java/all.md"
index b784ac5d..7ea0d302 100644
--- a/10 - Reading Notes/Effective Java/all.md	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Effective Java/all.md"	
@@ -1,21 +1,21 @@
-第1章   引言
-
-第2章   创建和销毁对象
-
-第3章   对于所有对象都通用的方法
-
-第4章   类和接口
-
-第5章   泛型
-
-第6章   枚举和注解
-
-第7章   方法
-
-第8章   通用程序设计
-
-第9章   异常
-
-第10章  并发
-
-第11章  序列化
+第1章   引言
+
+第2章   创建和销毁对象
+
+第3章   对于所有对象都通用的方法
+
+第4章   类和接口
+
+第5章   泛型
+
+第6章   枚举和注解
+
+第7章   方法
+
+第8章   通用程序设计
+
+第9章   异常
+
+第10章  并发
+
+第11章  序列化
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/01 HTTP \346\246\202\350\277\260.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/01 HTTP \346\246\202\350\277\260.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/01 HTTP \346\246\202\350\277\260.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/01 HTTP \346\246\202\350\277\260.md"
index 8f58c99c..5561329a 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/01 HTTP \346\246\202\350\277\260.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/01 HTTP \346\246\202\350\277\260.md"	
@@ -1,99 +1,99 @@
-### 内容提要
-
-* 这一章主要介绍了什么是http以及http是干嘛的，以及与之有关的相关概念，当然了这些概念都是概览式的介绍一些。所以我将采用问答式的方式描述这一章！
-
-
-**Q:http是干嘛的？**
-
-A:http是数据传输协议（超文本传输协议），用来沟通客户端和服务器的！
-
-
-**Q:什么是资源？**
-
-A:记住一句话，网络上的一切内容皆资源，无论是静态文件，还是动态生成的代码等！
-
-**Q:什么是媒体类型？**
-
-A:其实就是一种数据类型标记，用来告诉接收端，接收到的数据是什么类型，让接收端知道怎么才能处理该文件！常见标记方式就是MIME，MIME描述了文件的主要类型以及特定子类型，例如："Content-Type":"text/html"，其中text描述的文件的主要类型是文本，而其特定类型是html文档！
-
-
-**Q:怎么理解URI以及它的子集？**
-
-A:首先URI从其概念来说是*统一资源标识符*，它的作用就是在网络上唯一确定一个资源，就好比，在中国，身份证能唯一确定一个人一样！知道身份证号，就一定能确定一个人姓甚名谁一样！它有两个子集：URL(统一资源定位符)和URN(统一资源名)，首先不特别声明，我们所说的URI就是指URL，URL是跟资源其在网络上的位置有关！而URN是指资源跟其名字有关，URN是未来的趋势，不过貌似具体实施现在还在商讨中！所以短时间之内URN难以取代URL！
-
-
-**Q:什么是事务？**
-
-A:说白了事务就是“一次http链接（不包括tcp/ip连接，只包括一次http报文发送与接收）”的整个过程，由请求命令和响应结果组成！中间数据格式是http报文。我们平常打开一个网站，里面包括很多事务！如：请求网页文档、请求某个logo图片及请求某个视频等！
-
-**Q:方法指什么？**
-
-A:方法就是客户端向服务器发起的请求命令！常见方法有：get、post、delete、put、head！
-
-
-**Q:状态码有什么用？**
-
-A:状态码对程序有用，便于程序进行相关控制！原因短语对人有用！
-
-
-**Q:简单介绍一些报文！**
-
-A:首先报文是http协议一种纯文本的数据格式，分为请求报文和响应报文，两种报文都具有类似的结构，分别由三个部分构成：起始行、首部、主体，起始行描述报文干了什么！首部描述报文传输的具体细节！主体描述传输的实际内容！
-
-**Q:什么是TCP/IP？跟HTTP有什么关系？**
-
-A:tcp/ip是全世界的计算机和网络设备常用的层次化分组交换网络协议集！简单的说，http协议是一个应用层协议，位于tcp/ip协议的上一层，tcp/ip协议的主要作用就是过滤掉每个计算机的差异性，隐藏相关弱点，使得对于http协议来说提供的都是“相同的”接口！
-
-**Q:在一次网络请求中，分别经历那些过程？**
-
-A:步骤如下：
->> (a)浏览器从url中解析处服务器的主机名；
-
->> (b)浏览器将服务器的主机名转换成服务器的的ip地址；（可能经过去dns服务器查询）
-
->> (c)浏览器将端口号（如果有的话）从url中解析出来；
-
->> (d)浏览器建立一条与web服务器的tcp连接；
-
->> (e)浏览器向服务器发送一条http请求报文；
-
->> (f)服务器向浏览器回送一条http响应报文；
-
->> (g)关闭连接，浏览器显示文档
-
-
-Q:http协议有哪些版本？
-
-A:
->> http/0.9，这个版本有严重设计权限
-
->> http/1.0，广泛使用
-
->> http/1.0+ 非官方的http/1.0的扩展版本
-
->> http/1.1 目前正在使用的版本，修复的相关设计缺陷，增加的相关特性
-
->> http-NG 将来使用与否正在商讨中
-
-
-
-**Q:介绍一下web中的一些结构组件？**
-
-A:主要有代理、缓存、网关以及隧道！分别简介如下：
-
-- - 代理：代理位于客户端和服务器之间，接收所有客户端的HTTP请求，并把这些请求转发给服务器（可能会对请求进行修改之后转发）。对用户来说，这些应用程序就是一个代理，代表用户访问服务器。代理的主要作用有过滤、屏蔽等！（还有需要注意一点：代理既可以代表服务器对客户端进行响应，又可以代表客户端对服务器进行请求！）
-
-
-- - 缓存：首先说明一下，缓存某种意义上来说也是一种代理服务器。它主要使用代表服务器对客户端进行响应。发送预先缓存好的资源的副本。这样会加快事务响应速度、同时也会减少服务器的负载、减轻带宽等问题！
-
-
-- - 网关：网关是一种特殊的服务器，面对客户端时好像它就是服务器，而对于服务器，他又充当客户端的角色，它的主要作用是协议转换！例如HTTP/FTP网关。
-
-
-- - 隧道：就是一个连接通道，用于在http信道上发送非http协议的资源。
-
-
-- - Agent代理：说白了就是我们平时所说的浏览器，以及web机器人、爬虫等！
-
-
-
+### 内容提要
+
+* 这一章主要介绍了什么是http以及http是干嘛的，以及与之有关的相关概念，当然了这些概念都是概览式的介绍一些。所以我将采用问答式的方式描述这一章！
+
+
+**Q:http是干嘛的？**
+
+A:http是数据传输协议（超文本传输协议），用来沟通客户端和服务器的！
+
+
+**Q:什么是资源？**
+
+A:记住一句话，网络上的一切内容皆资源，无论是静态文件，还是动态生成的代码等！
+
+**Q:什么是媒体类型？**
+
+A:其实就是一种数据类型标记，用来告诉接收端，接收到的数据是什么类型，让接收端知道怎么才能处理该文件！常见标记方式就是MIME，MIME描述了文件的主要类型以及特定子类型，例如："Content-Type":"text/html"，其中text描述的文件的主要类型是文本，而其特定类型是html文档！
+
+
+**Q:怎么理解URI以及它的子集？**
+
+A:首先URI从其概念来说是*统一资源标识符*，它的作用就是在网络上唯一确定一个资源，就好比，在中国，身份证能唯一确定一个人一样！知道身份证号，就一定能确定一个人姓甚名谁一样！它有两个子集：URL(统一资源定位符)和URN(统一资源名)，首先不特别声明，我们所说的URI就是指URL，URL是跟资源其在网络上的位置有关！而URN是指资源跟其名字有关，URN是未来的趋势，不过貌似具体实施现在还在商讨中！所以短时间之内URN难以取代URL！
+
+
+**Q:什么是事务？**
+
+A:说白了事务就是“一次http链接（不包括tcp/ip连接，只包括一次http报文发送与接收）”的整个过程，由请求命令和响应结果组成！中间数据格式是http报文。我们平常打开一个网站，里面包括很多事务！如：请求网页文档、请求某个logo图片及请求某个视频等！
+
+**Q:方法指什么？**
+
+A:方法就是客户端向服务器发起的请求命令！常见方法有：get、post、delete、put、head！
+
+
+**Q:状态码有什么用？**
+
+A:状态码对程序有用，便于程序进行相关控制！原因短语对人有用！
+
+
+**Q:简单介绍一些报文！**
+
+A:首先报文是http协议一种纯文本的数据格式，分为请求报文和响应报文，两种报文都具有类似的结构，分别由三个部分构成：起始行、首部、主体，起始行描述报文干了什么！首部描述报文传输的具体细节！主体描述传输的实际内容！
+
+**Q:什么是TCP/IP？跟HTTP有什么关系？**
+
+A:tcp/ip是全世界的计算机和网络设备常用的层次化分组交换网络协议集！简单的说，http协议是一个应用层协议，位于tcp/ip协议的上一层，tcp/ip协议的主要作用就是过滤掉每个计算机的差异性，隐藏相关弱点，使得对于http协议来说提供的都是“相同的”接口！
+
+**Q:在一次网络请求中，分别经历那些过程？**
+
+A:步骤如下：
+>> (a)浏览器从url中解析处服务器的主机名；
+
+>> (b)浏览器将服务器的主机名转换成服务器的的ip地址；（可能经过去dns服务器查询）
+
+>> (c)浏览器将端口号（如果有的话）从url中解析出来；
+
+>> (d)浏览器建立一条与web服务器的tcp连接；
+
+>> (e)浏览器向服务器发送一条http请求报文；
+
+>> (f)服务器向浏览器回送一条http响应报文；
+
+>> (g)关闭连接，浏览器显示文档
+
+
+Q:http协议有哪些版本？
+
+A:
+>> http/0.9，这个版本有严重设计权限
+
+>> http/1.0，广泛使用
+
+>> http/1.0+ 非官方的http/1.0的扩展版本
+
+>> http/1.1 目前正在使用的版本，修复的相关设计缺陷，增加的相关特性
+
+>> http-NG 将来使用与否正在商讨中
+
+
+
+**Q:介绍一下web中的一些结构组件？**
+
+A:主要有代理、缓存、网关以及隧道！分别简介如下：
+
+- - 代理：代理位于客户端和服务器之间，接收所有客户端的HTTP请求，并把这些请求转发给服务器（可能会对请求进行修改之后转发）。对用户来说，这些应用程序就是一个代理，代表用户访问服务器。代理的主要作用有过滤、屏蔽等！（还有需要注意一点：代理既可以代表服务器对客户端进行响应，又可以代表客户端对服务器进行请求！）
+
+
+- - 缓存：首先说明一下，缓存某种意义上来说也是一种代理服务器。它主要使用代表服务器对客户端进行响应。发送预先缓存好的资源的副本。这样会加快事务响应速度、同时也会减少服务器的负载、减轻带宽等问题！
+
+
+- - 网关：网关是一种特殊的服务器，面对客户端时好像它就是服务器，而对于服务器，他又充当客户端的角色，它的主要作用是协议转换！例如HTTP/FTP网关。
+
+
+- - 隧道：就是一个连接通道，用于在http信道上发送非http协议的资源。
+
+
+- - Agent代理：说白了就是我们平时所说的浏览器，以及web机器人、爬虫等！
+
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/02 URL\344\270\216\350\265\204\346\272\220.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/02 URL\344\270\216\350\265\204\346\272\220.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/02 URL\344\270\216\350\265\204\346\272\220.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/02 URL\344\270\216\350\265\204\346\272\220.md"
index 678f79c5..fa7b4478 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/02 URL\344\270\216\350\265\204\346\272\220.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/02 URL\344\270\216\350\265\204\346\272\220.md"	
@@ -1,73 +1,73 @@
-#### 内容提要
-
-* 本章讲解了URI（统一标识符）严格来说，这一章是介绍URL(统一资源定位符)的!分别介绍了URL是由那些组件构成、每个组件代表的含义是什么、浏览器是如何解析每个组件的以及从URL的完成性和安全性来说如何进行URL不安全字符进行转义。当然最后还简单介绍了URI的另一个子类URN（统一资源名）。
-
-####　URI的分类
-
-* URI（统一资源标识符）由URL（统一资源定位符）和URN（统一资源名）两个子集构成。URL是从资源的位置来定义一个资源的，比如在“中国三东的一只小狗”和在“中国广东的一只小狗”就分别定义了两只不同的狗。而URN是从资源的名字来定义的，比如小明和小李就分别定义了两个人。目前的网络架构来说，大部分都是URL。URL的缺点就是如果资源的位置发生了改变，那么资源也就找不到了，而URN正是解决这个问题的，因为URN不受位置的限制，它只受名字的管理，因为对于URN来说，一个资源的名字是唯一的，所以无论资源移动到什么地方，都能通过名字定位到资源。从某种意义上来说，URN是URI的未来趋势，但是URN的实现需要一个中间架构来满足这种位置到名字的映射，所以要完成从URL到URN的过度，显然是一个工程量的过程，如果不是URL到了不能用的时候，URN的实现需要很长的时间，幸运的是现在URL架构还是很好的满足网络需求的！
-
-#### URL的语法
-
-* URL的语法描述的是URL由哪些组件构成，以及这些组件是怎么组合成一个URL，中间由什么符号连接，每个组件代表什么等！其格式如下：
-
-```
-
-	<scheme>://<user>:<password>@<host>:<port>/<path>;<params>?<query>#<frag>
-
-```
-
-其中：
-
->> scheme:方法描述了请求资源时用了什么协议，用“:”与url其它部分隔开；
-
->> user:用户名描述了访问是带的用户名；
-
->> password:密码描述了用户名后面可能跟的密码，用“:”跟用户名隔开；
-
->> host:主机描述了网站主机名或ip地址，如果前面有用户名和密码，用@分开；
-
->> post:服务器当前正在监听的端口，http默认为80，https默认为443;
-
->> path:路劲描述了资源在服务器上的位置，用‘/’跟前面部分隔开；
-
->> params:参数描述了请求需要附加的参数，用“;”与其他部分隔开；
-
->> query:查询是用来激活服务器程序去执行某些操作，比如查询数据库等，用“?”与其余部分隔开；
-
->> frag:片段只在客户端使用，不发送到服务器端；
-
-
-
-
-
-
-#### URL快捷方式
-
-* url快捷方式描述了一种程序如何通过相对地址解析处绝对地址的过程以及在浏览器地址栏输入部分url浏览器自动补全主机名的一种机制！
-
-* 相对地址转换为绝对地址：首先会根据一个基础地址来得出协议、主机名、端口等！基础地址可以通过base标签显示定义，也可以由当前所在资源的地址得出！相关接口通过继承的方式附在相对地址上，最后得到绝对地址。
-
-* 浏览器扩展地址主要通过主机名扩展和历史扩展等方式实现自动地址补全！
-
-
-
-#### url编码
-
-Q:为什么需要编码？
-
-A:主要从url的一致性、安全性、以及完整性来强调需要对url字符进行编码。比如因为一个url连接的两端可能出现的机器种类很多，为了让大家都能够解析出一个相同的url，所以有必要对某些不安全的url字符进行转义。
-
-Q:url字符集由什么编码构成？
-
-A:早前的url是有US-ASCII码编码，但是随着网络在全世界的流行，有很多字符是US-ASCII不能编码的，因为US-ASCII码最多只能编译127个字符。通过转义序列，就可以用US-ASCII字符集的有限子集对任意字符值或数据进行编码了。
-
-Q:编码机制？
-
-A:为了避开安全字符集表示法带来的限制，人们设计了一种编码机制，用来在URL中表示各种不安全的字符。这种编码机制就是通过一种“转义”表示法来表示不安全字符的，这种转义表示法包含一个百分号（%），后面跟着两个表示字符的ASCII码的十六进制数。
-
-Q:那些字符不建议在URL里面使用？
-
-A:在URL中，有几个字符被保留起来，有着特殊的含义。有些字符不在定义的US-ASCII可打印字符集中。还有些字符会与某些因特网网关和协议产生混淆，因此不赞成使用，比如“%”。
-
-
-
+#### 内容提要
+
+* 本章讲解了URI（统一标识符）严格来说，这一章是介绍URL(统一资源定位符)的!分别介绍了URL是由那些组件构成、每个组件代表的含义是什么、浏览器是如何解析每个组件的以及从URL的完成性和安全性来说如何进行URL不安全字符进行转义。当然最后还简单介绍了URI的另一个子类URN（统一资源名）。
+
+####　URI的分类
+
+* URI（统一资源标识符）由URL（统一资源定位符）和URN（统一资源名）两个子集构成。URL是从资源的位置来定义一个资源的，比如在“中国三东的一只小狗”和在“中国广东的一只小狗”就分别定义了两只不同的狗。而URN是从资源的名字来定义的，比如小明和小李就分别定义了两个人。目前的网络架构来说，大部分都是URL。URL的缺点就是如果资源的位置发生了改变，那么资源也就找不到了，而URN正是解决这个问题的，因为URN不受位置的限制，它只受名字的管理，因为对于URN来说，一个资源的名字是唯一的，所以无论资源移动到什么地方，都能通过名字定位到资源。从某种意义上来说，URN是URI的未来趋势，但是URN的实现需要一个中间架构来满足这种位置到名字的映射，所以要完成从URL到URN的过度，显然是一个工程量的过程，如果不是URL到了不能用的时候，URN的实现需要很长的时间，幸运的是现在URL架构还是很好的满足网络需求的！
+
+#### URL的语法
+
+* URL的语法描述的是URL由哪些组件构成，以及这些组件是怎么组合成一个URL，中间由什么符号连接，每个组件代表什么等！其格式如下：
+
+```
+
+	<scheme>://<user>:<password>@<host>:<port>/<path>;<params>?<query>#<frag>
+
+```
+
+其中：
+
+>> scheme:方法描述了请求资源时用了什么协议，用“:”与url其它部分隔开；
+
+>> user:用户名描述了访问是带的用户名；
+
+>> password:密码描述了用户名后面可能跟的密码，用“:”跟用户名隔开；
+
+>> host:主机描述了网站主机名或ip地址，如果前面有用户名和密码，用@分开；
+
+>> post:服务器当前正在监听的端口，http默认为80，https默认为443;
+
+>> path:路劲描述了资源在服务器上的位置，用‘/’跟前面部分隔开；
+
+>> params:参数描述了请求需要附加的参数，用“;”与其他部分隔开；
+
+>> query:查询是用来激活服务器程序去执行某些操作，比如查询数据库等，用“?”与其余部分隔开；
+
+>> frag:片段只在客户端使用，不发送到服务器端；
+
+
+
+
+
+
+#### URL快捷方式
+
+* url快捷方式描述了一种程序如何通过相对地址解析处绝对地址的过程以及在浏览器地址栏输入部分url浏览器自动补全主机名的一种机制！
+
+* 相对地址转换为绝对地址：首先会根据一个基础地址来得出协议、主机名、端口等！基础地址可以通过base标签显示定义，也可以由当前所在资源的地址得出！相关接口通过继承的方式附在相对地址上，最后得到绝对地址。
+
+* 浏览器扩展地址主要通过主机名扩展和历史扩展等方式实现自动地址补全！
+
+
+
+#### url编码
+
+Q:为什么需要编码？
+
+A:主要从url的一致性、安全性、以及完整性来强调需要对url字符进行编码。比如因为一个url连接的两端可能出现的机器种类很多，为了让大家都能够解析出一个相同的url，所以有必要对某些不安全的url字符进行转义。
+
+Q:url字符集由什么编码构成？
+
+A:早前的url是有US-ASCII码编码，但是随着网络在全世界的流行，有很多字符是US-ASCII不能编码的，因为US-ASCII码最多只能编译127个字符。通过转义序列，就可以用US-ASCII字符集的有限子集对任意字符值或数据进行编码了。
+
+Q:编码机制？
+
+A:为了避开安全字符集表示法带来的限制，人们设计了一种编码机制，用来在URL中表示各种不安全的字符。这种编码机制就是通过一种“转义”表示法来表示不安全字符的，这种转义表示法包含一个百分号（%），后面跟着两个表示字符的ASCII码的十六进制数。
+
+Q:那些字符不建议在URL里面使用？
+
+A:在URL中，有几个字符被保留起来，有着特殊的含义。有些字符不在定义的US-ASCII可打印字符集中。还有些字符会与某些因特网网关和协议产生混淆，因此不赞成使用，比如“%”。
+
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/03 HTTP\346\212\245\346\226\207.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/03 HTTP\346\212\245\346\226\207.md"
similarity index 97%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/03 HTTP\346\212\245\346\226\207.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/03 HTTP\346\212\245\346\226\207.md"
index 599246c2..0f907f78 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/03 HTTP\346\212\245\346\226\207.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/03 HTTP\346\212\245\346\226\207.md"	
@@ -1,452 +1,452 @@
-### 内容提要
-
-这一章内容较多，介绍了http报文的诸多相关概念，譬如起始行、首部、主体以及它们代表的含义等！同时还介绍了常见的状态码及其含义，常见的首部字段及其含义。本章内容较丰实，所以概念模糊的部分可以参阅原书相关章节！
-
-
-####　报文流
-
-**这是形容http报文的**
-
-* http报文是以一种类似的流的方式来发送数据的，所以报文流讲述了http报文的一些客观状态，相关术语：流入、流出形容事务处理。http报文任何时候是从上游向下游流入的！其中进过的节点既可能是上游，有可能是下游，如果从某个节点流出，那么相对于此节点流入的那个节点，它就是上游，翻过它就是下游！
-
-
-####　报文的组成部分
-
-* *首先说明，报文由三个部分组成，起始行、首部、主体。起始行和首部都是ascll文本，而主体则可以是任意类型文件，比如二进制，视频等！且起始行和首部都已一个crlf作为结束符，并且首部与主体之间应始终存在一个以crlf序列作为结束的空行。当然了为了兼容老版本的http，这里有时并不是那么严格要求非要crlf同时存在！*
-
-
-* 报文的语法
-
-http报文分为请求报文和相应报文，其语法分别如下：
-
-```
-	//请求报文
-
-	<method> <request-URL> <version>
-	<headers>
-
-	<entity-body>
-
-```
-
-```
-	//响应报文
-
-	<version> <status> <reason-phrase>
-	<headers>
-
-	<entity-body>
-
-```
-
-相关概念分别如下：
-
-	*方法是客户端希望执行的动作，如GET、POST等*
-
-	*请求url是指请求资源的路劲*
-
-	*报文版本号，格式为http/<major>.<minor>,分别代表主要版本号和次要版本号，其含义应分开理解*
-
-	*其实说白了就是用一个数字表示当前事务处于什么状态，便于开发者处理*
-
-	*原因短语，实际意义不大，就是为了方便人看的*
-
-	*首部就是一个包含零个或多个的键值对，键值对以crlf隔开，而键、值之间以‘:’隔开，期间包含一个可选的空格*
-
-	*任意格式组成的数据块，也是实际发送的内容*
-
-* 起始行
-
-分为请求行和响应行，格式前面一个在前面，相关概念不在赘述！
-
-* 首部
-
-说一下首部分类，主要有五类：通用首部、请求首部、响应首部、主体首部、扩展首部。通用首部就是请求报文和响应报文都可以用，用以说明报文的一般属性；请求首部出现在请求报文中，用于客户端告诉服务器是什么情况，比如能接受什么，不能接受什么等；响应报文用于响应报文中，服务器端用来告诉客户端什么情况；主体首部用来描述主体的信息，比如主体的长度是多少等；扩展报文是非官方的报文，但是http也支持发送。
-
-
-
-#### 方法
-
-* 安全方法
-
-能在服务器端有操作的就是非安全方法，比如delete、put、post,不在服务器端有操作的就是安全方法，比如get、header，当然了安全方法并非不能在服务器端有操作，这是开发者可以控制的！
-
-* GET方法用于请求服务器端发送某个资源
-
-* HEADER方法跟GET方法类似，区别就是不返回主体
-
-* PUT方法用于向服务器端修改、插入数据
-
-* POST方法用于向服务器端发送数据
-
-* TRACK方法用于向服务器端请求报文在发送的过程中经过了什么修改，主要用于测试
-
-* OPTIONS用于请求服务器告知其支持什么功能
-
-* DELETE用于向服务器删除某个指定的资源
-
-* 扩展方法其实类似于自定义方法
-
-
-
-####　状态码
-
-* 100-199 信息性状态码
-
-* 200-299 成功状态码 （常见200表示请求成功）
-
-* 300-399 重定向状态码 （常见302重定向）
-
-* 400-499 客户端错误状态码 （常见404，请求资源不存在）
-
-* 500-599 服务端错误状态码
-
-
-#### 常见状态码及其含义整理
-
-```
-
-	状态码				原因短语     				含义
-
-	100					Continue 			说明收到了请求的初始部分，请客户端继续，发送了这个状态码之后，
-											服务器在收到请求之后必须进行响应。
-
-	101					Switching Protocols 说明服务器正在根据客户端的指定，将协议切换成Update首部所列的
-											协议
-
-	200 				OK					请求没问题，实体的主体部分包含了所请求的资源
-
-	201 				Created				用于创建服务器对象的请求（比如，PUT）。响应的实体主体部分中
-											应该包含各种引用了已创建的资源的URL，Location首部包含的则是最具体的引用。
-
-	202 				Accepted			请求已被接受，但服务器还未对其执行任何动作。不能保证服务器会完成这
-											个请求；这只是意味着接受请求时，它看起来是有效的。服务器应该在实体的主体部分包含对请求状态的描述，或许还应该有对请求完成时间的估计（或者包含一个指针，指向可以获取此信息的位置）
-
-    203 				Non-Authoritative   实体首部包含的信息不是来自原远端服务器，而是来自于资源的一份副本。 
-    					Information 		如果中间节点上有一份资源副本，但无法或者没有对它所发送的与资源有关的
-    										元信息进行验证，就会出现这种情况
-
-    204					No 	Content         响应报文中包含若干首部和一个状态行，但没有实体的主体部分。主要用于在
-    										浏览器不转为显示新文档的情况下，对其进行更新（比如刷新一个表单页面）
-
-    205					Reset Content 		另一个主要用于浏览器的代码。负责告知浏览器清除当前页面中的所有HTML
-    										表单元素
-
-    206					Partial Content 	成功执行了一个部分或Range(范围)请求。稍后我们会看到，客户端可以通过
-    										一些特殊的首部来获取部分或某个范围内的文档————这个状态码就说明范围请求成功了。
-
-
-    注：在对那些包含了重定向状态码的非HEAD请求进行响应时，最好要包含一个实体，并在实体中包含描述信息和指向（多个）重定向URL的链接。如：
-
-    HTTP/1.1 301 OK
-    Location: http://www.gentle-grooming.com/
-    Content-Length: 56
-    Content-Type: text/plain
-
-    Please go to our partner site,
-    www.gentle-grooming.com
-
-
-
-    300					Multiple Choices 	客户端请求一个实际指向多个资源的URL时会返回这个状态码，比如服务器
-    										上有某个HTML文档的英语和法语版本。返回这个代码时会带有一个选项列表；这样用户就可以选择它希望使用的那一项了。有多个版本可用时，客户端需要沟通解决。
-
-    301					Moved Permanently	在请求的URL已被移除时使用。响应的Location首部中应该包含资源现在所处
-    										的URL
-
-    302 				Found 				与301状态码类似，但是，客户端应该使用Location首部给出的URL来临时定位
-    										资源。将来的请求仍应该使用老的URL
-
-    303 				See Other 			告知客户端应该用另一个URL来获取资源。新的URL位于响应报文的Location
-    										首部。其主要母的是允许POST请求的响应将客户端定向到某个资源上去
-
-    304  				Not Modified 		客户端可以通过所包含的请求首部，使其请求变成有条件的。如果客户端发起
-    										了一个条件GET请求，而最近资源未被修改的话，就可以用这个状态码来说明
-    										资源未被修改。带有这个状态码的响应不应该包含实体的主体部分。
-
-    305 				Use Proxy  			用来说明必须通过一个代理访问资源；代理的位置由Location首部给出。很
-    										重要的一点是，客户端是相对某个特定资源来解析这条响应的，不能假定所有请求。甚至所有对持有请求资源的服务器的请求都通过这个代理进行。如果客户端错误地让代理介入了某条请求，可能会引发破坏性的行为，而且会造成安全漏洞。
-
-   	307					Temporary Redireat 与301状态码类似；但客户端应该使用Location首部给出的URL来临时定位资源
-   											。将来的请求应该使用老的URL
-
-
-   	400 				Bad Request 		用于告知客户端发起了一个错误的请求
-
-   	401 				Unauthorized 		返回适当的首部，用于获取客户端访问资源的权限
-
-   	402         		Payment Required    此状态码未使用，保留
-
-   	403                 Forbidden           服务器拒绝请求，可在响应主体中告知原因
-
-   	404  				Not Found           用于告知客户端请求的资源在服务器不存在
-
-   	405 				Method Not Allowd   告知客户端不支持当前方法，并在Allow首部返回支持的方法
-
-   	406 				Not Acceptable     	没有客户端支持的资源类型
-
-   	407 				Proxy Authentication  跟401类似，不过用户代理服务器
-   						Requireed 
-
-   	408 				Request Timeout     超时提醒
-
-   	409      			Conflict            请求会造成服务器冲突
-
-   	410  	            Gone   				跟404一样，只不过服务器曾经拥有过该请求资源
-
-   	411 				Length Required    要求客户端发送Content-Length首部
-
-   	412 				Precondition Failed  部分条件验证不通过
-
-   	413   				Request Entity Too Large  客户端发送的主体超过了服务器的希望的长度
-
-   	414 				Request  URL Too Long   客户端请求的时间比服务希望的时间长
-
-   	415 				Unsupported Media Type 	服务器无法理解客户端请求的主体类型
-
-   	416 				Requested Range Not    请求报文所请求的是指定资源的某个范围，而此范围无效或无法满足时
-   						Satisfiable   			，使用此状态码
-
-   	417					Expectation Failed 		请求中包含Expect首部，服务器无法满足
-
-   	500					Internal Server Error  服务器错误
-
-   	501 				Not Implemented         请求超出了服务器能处理的范围
-
-   	502 				Bad Gateway 			作为代理或网关使用的服务器从请求响应链的下一条链路上收到了一条
-   												伪响应（比如，它无法连接到其父网关）时，使用此状态码
-
-   	503    				Service Unavailable 	用来说明服务器现在无法为请求提供服务，但将来可以。如果服务器
-   												知道什么时候资源会变为可用的，可以在响应中包含包含一个
-   												Retry-After首部。
-
-   	504 				Gateway Timeout 		与状态码408类似，只是这里的响应来自一个网关或代理，它们在等待另
-   												一服务器对其请求进行响应时超时了
-
-    505 				HTTP Version Not        服务器收到的请求使用了它无法或不愿支持的协议版本时，使用此
-    					Supported 				状态码。有些服务器应用程序会选择不支持协议的早起版本	
-
-
-```
-
-
-#### 常见首部字段含义介绍
-
-* 注：首部分为通用首部、请求首部、响应首部、主体首部、扩展首部！
-
-* **通用首部**
-
-```
-
-   通用的信息性首部
-
-   首部                                         描述
-
-   Connection               允许客户端和服务器指定与请求/响应连接有关的选项
-
-   Date                     提供了日期的时间标志，说明报文是什么时间创建的
-
-   MIME-Version             给出了发送端使用的MIME版本
-
-   Trailer                  如果报文采用了分块传输编码方式，就可以用这个首部列出位于报文拖挂部分的首部集合
-
-   Transfer-Encoding        告知接收端为了保证报文的可靠传输，对报文采用了什么编码方式
-
-   Update                   给出了发送端可能想要“升级”使用的新版本或协议
-
-   Via                      显示了报文经过的中间节点（代理、网关）
-
-
-   通用缓存首部
-
-   首部                                 描述
-
-   Cache-Control            用于随报文传送缓存指示
-
-   Pragma                   另一种随报文传送指示的方式，但并不专用缓存
-
-
-```
-
-* **请求首部**
-
-```
-
-    请求的信息性首部
-
-    首部                                描述
-
-    Client-IP               提供了运行客户端的机器的IP地址
-
-    From                    提供了客户端用户的E-mail地址
-
-    Host                    给出了接收请求的服务器的主机名和端口号
-
-    Referer                 提供了包含当前请求URL的文档的URL
-
-    UA-Color                提供了与客户端显示器的显示颜色有关的信息
-
-    UA-CPU                  给出了客户端CPU的类型或制造商
-
-    UA-Disp                 提供了与客户端显示器（屏幕）能力有关的信息
-
-    UA-OS                   给出了运行在客户端机器上的操作系统名称及版本
-
-    UA-Pixels               提供了客户端显示器的像素信息
-
-    User-Agent              将发起请求的应用程序名称告知服务器
-
-    Accept首部
-
-    首部                                  描述
-
-    Accept                  告诉服务器能够发送那些媒体类型
-
-    Accept-Charset          告诉服务器能够给发送那些字符集
-
-    Accept-Encoding         告诉服务器能够发送那些编码方式
-
-    Accept-Language         告诉服务器能够发送那些语言
-
-    TE                      告诉服务器可以使用那些扩展传输编码
-
-
-
-    条件请求首部
-
-    首部                                描述
-
-    Expect                  允许客户端列出某请求所要求的服务器行为
-
-    If-Match                如果实体标记与文档当前的实体标记相匹配，就获取这份文档
-
-    If-Modified-Since       除非在某个指定的日期之后资源被修改过，否则就限制这个请求
-
-    If-None-Match           如果提供的实体标记与当前文档的标记不相符，就获取文档
-
-    If-Range                允许对文档的某个范围进行条件请求
-
-    If-Unmodified-Since     除非在某个指定日期之后资源没有被修改过，否则就限制这个请求
-
-    Range                   如果服务器支持范围请求，就请求资源的指定范围
-
-
-    安全请求首部
-
-    首部                                  描述
-
-    Authorization           包含了客户端提供给服务器，以便对其自身进行认证的数据
-
-    Cookie                  客户端用它向服务器传送一个令牌————它并不是真正的安全首部，但确实隐含了安全功能
-
-    Cookie2                 用来说明请求端支持的cookie版本
-
-
-
-    代理请求首部
-
-    首部                                  描述
-
-    Max-Forward             在通往源端服务器的路径上，将请求转发给其他代理或网关的最大次数————与TRACE方法一同
-                            使用
-
-    Proxy-Authorization     与Authorization首部相同，但这个首部是在与代理进行认证时使用的
-
-    Proxy-Connection        与Connection首部相同，但这个首部是在与代理建立连接时使用的
-
-
-```
-
-* **响应首部**
-
-```
-
-    响应的信息性首部
-
-    首部                                        描述
-
-    Age                     （从最初创建开始）响应持续时间
-
-    Public                   服务器为其资源支持的请求方法列表
-
-    Retry-After              如果资源不可用的话，在此日期或时间重试
-
-    Server                   服务器应用程序软件的名称和版本
-
-    Title                    对HTML文档来说，就是HTML文档的源端给出的标题
-
-    Warning                  比原因短语中更详细的警告报文
-
-
-    协商首部
-
-    首部                                  描述
-
-    Accept-Ranges           对此资源来说，服务器可接受的范围类型
-
-    Vary                    服务器查看的其他首部的列表，可能会使响应发生变化；也就是说，这是一个首部列表，
-                            服务器会根据这些首部的内容挑选处最合适的资源版本发送个客户端
-
-    安全响应首部
-
-    首部                                    描述
-
-    Proxy-Authenticate      来自代理的对客户端的质询列表
-
-    Set-Cookie              不是真正的安全首部，但隐含有安全功能；可以在客户端设置一个令牌，以便服务器对客户端
-                            进行标志
-
-    Set-Cookie2             与Set-Cookie类似
-
-    WWW-Authenticate        来自服务器的对客户端的质询列表
-
-
-
-```
-
-
-* **实体首部**
-
-
-```
-
-  实体的信息性首部
-
-  首部                                          描述
-
-  Allow                       列出了可以对此实体执行的请求方法
-
-  Location                    告知客户端实体实际上位于何处；用于将接收端丁香到资源的位置上去
-
-
-  内容首部
-
-  首部                                          描述
-
-  Content-Base                解析主体中的相对URL时使用的基础URL
-
-  Content-Encoding            对主体执行的任意编码方式
-
-  Content-Language            理解主体时最适宜使用的自然语言
-
-  Content-Length              主体的长度或者尺寸
-
-  Content-Location            资源实际所处的位置
-
-  Content-MD5                 主体的MD5校验和
-
-  Content-Range               在整个资源中此实体表示的字节范围
-
-  Content-Type                这个主体的对象类型
-
-  实体缓存首部
-
-  首部                                                  描述
-
-  ETag                        与此实体相关的实体标记
-
-  Expires                     实体不再有效，要从原始的源端再次获取此实体的日期和时间
-
-  Last-Modified               这个实体最后一次被修改的日期和时间
-
+### 内容提要
+
+这一章内容较多，介绍了http报文的诸多相关概念，譬如起始行、首部、主体以及它们代表的含义等！同时还介绍了常见的状态码及其含义，常见的首部字段及其含义。本章内容较丰实，所以概念模糊的部分可以参阅原书相关章节！
+
+
+####　报文流
+
+**这是形容http报文的**
+
+* http报文是以一种类似的流的方式来发送数据的，所以报文流讲述了http报文的一些客观状态，相关术语：流入、流出形容事务处理。http报文任何时候是从上游向下游流入的！其中进过的节点既可能是上游，有可能是下游，如果从某个节点流出，那么相对于此节点流入的那个节点，它就是上游，翻过它就是下游！
+
+
+####　报文的组成部分
+
+* *首先说明，报文由三个部分组成，起始行、首部、主体。起始行和首部都是ascll文本，而主体则可以是任意类型文件，比如二进制，视频等！且起始行和首部都已一个crlf作为结束符，并且首部与主体之间应始终存在一个以crlf序列作为结束的空行。当然了为了兼容老版本的http，这里有时并不是那么严格要求非要crlf同时存在！*
+
+
+* 报文的语法
+
+http报文分为请求报文和相应报文，其语法分别如下：
+
+```
+	//请求报文
+
+	<method> <request-URL> <version>
+	<headers>
+
+	<entity-body>
+
+```
+
+```
+	//响应报文
+
+	<version> <status> <reason-phrase>
+	<headers>
+
+	<entity-body>
+
+```
+
+相关概念分别如下：
+
+	*方法是客户端希望执行的动作，如GET、POST等*
+
+	*请求url是指请求资源的路劲*
+
+	*报文版本号，格式为http/<major>.<minor>,分别代表主要版本号和次要版本号，其含义应分开理解*
+
+	*其实说白了就是用一个数字表示当前事务处于什么状态，便于开发者处理*
+
+	*原因短语，实际意义不大，就是为了方便人看的*
+
+	*首部就是一个包含零个或多个的键值对，键值对以crlf隔开，而键、值之间以‘:’隔开，期间包含一个可选的空格*
+
+	*任意格式组成的数据块，也是实际发送的内容*
+
+* 起始行
+
+分为请求行和响应行，格式前面一个在前面，相关概念不在赘述！
+
+* 首部
+
+说一下首部分类，主要有五类：通用首部、请求首部、响应首部、主体首部、扩展首部。通用首部就是请求报文和响应报文都可以用，用以说明报文的一般属性；请求首部出现在请求报文中，用于客户端告诉服务器是什么情况，比如能接受什么，不能接受什么等；响应报文用于响应报文中，服务器端用来告诉客户端什么情况；主体首部用来描述主体的信息，比如主体的长度是多少等；扩展报文是非官方的报文，但是http也支持发送。
+
+
+
+#### 方法
+
+* 安全方法
+
+能在服务器端有操作的就是非安全方法，比如delete、put、post,不在服务器端有操作的就是安全方法，比如get、header，当然了安全方法并非不能在服务器端有操作，这是开发者可以控制的！
+
+* GET方法用于请求服务器端发送某个资源
+
+* HEADER方法跟GET方法类似，区别就是不返回主体
+
+* PUT方法用于向服务器端修改、插入数据
+
+* POST方法用于向服务器端发送数据
+
+* TRACK方法用于向服务器端请求报文在发送的过程中经过了什么修改，主要用于测试
+
+* OPTIONS用于请求服务器告知其支持什么功能
+
+* DELETE用于向服务器删除某个指定的资源
+
+* 扩展方法其实类似于自定义方法
+
+
+
+####　状态码
+
+* 100-199 信息性状态码
+
+* 200-299 成功状态码 （常见200表示请求成功）
+
+* 300-399 重定向状态码 （常见302重定向）
+
+* 400-499 客户端错误状态码 （常见404，请求资源不存在）
+
+* 500-599 服务端错误状态码
+
+
+#### 常见状态码及其含义整理
+
+```
+
+	状态码				原因短语     				含义
+
+	100					Continue 			说明收到了请求的初始部分，请客户端继续，发送了这个状态码之后，
+											服务器在收到请求之后必须进行响应。
+
+	101					Switching Protocols 说明服务器正在根据客户端的指定，将协议切换成Update首部所列的
+											协议
+
+	200 				OK					请求没问题，实体的主体部分包含了所请求的资源
+
+	201 				Created				用于创建服务器对象的请求（比如，PUT）。响应的实体主体部分中
+											应该包含各种引用了已创建的资源的URL，Location首部包含的则是最具体的引用。
+
+	202 				Accepted			请求已被接受，但服务器还未对其执行任何动作。不能保证服务器会完成这
+											个请求；这只是意味着接受请求时，它看起来是有效的。服务器应该在实体的主体部分包含对请求状态的描述，或许还应该有对请求完成时间的估计（或者包含一个指针，指向可以获取此信息的位置）
+
+    203 				Non-Authoritative   实体首部包含的信息不是来自原远端服务器，而是来自于资源的一份副本。 
+    					Information 		如果中间节点上有一份资源副本，但无法或者没有对它所发送的与资源有关的
+    										元信息进行验证，就会出现这种情况
+
+    204					No 	Content         响应报文中包含若干首部和一个状态行，但没有实体的主体部分。主要用于在
+    										浏览器不转为显示新文档的情况下，对其进行更新（比如刷新一个表单页面）
+
+    205					Reset Content 		另一个主要用于浏览器的代码。负责告知浏览器清除当前页面中的所有HTML
+    										表单元素
+
+    206					Partial Content 	成功执行了一个部分或Range(范围)请求。稍后我们会看到，客户端可以通过
+    										一些特殊的首部来获取部分或某个范围内的文档————这个状态码就说明范围请求成功了。
+
+
+    注：在对那些包含了重定向状态码的非HEAD请求进行响应时，最好要包含一个实体，并在实体中包含描述信息和指向（多个）重定向URL的链接。如：
+
+    HTTP/1.1 301 OK
+    Location: http://www.gentle-grooming.com/
+    Content-Length: 56
+    Content-Type: text/plain
+
+    Please go to our partner site,
+    www.gentle-grooming.com
+
+
+
+    300					Multiple Choices 	客户端请求一个实际指向多个资源的URL时会返回这个状态码，比如服务器
+    										上有某个HTML文档的英语和法语版本。返回这个代码时会带有一个选项列表；这样用户就可以选择它希望使用的那一项了。有多个版本可用时，客户端需要沟通解决。
+
+    301					Moved Permanently	在请求的URL已被移除时使用。响应的Location首部中应该包含资源现在所处
+    										的URL
+
+    302 				Found 				与301状态码类似，但是，客户端应该使用Location首部给出的URL来临时定位
+    										资源。将来的请求仍应该使用老的URL
+
+    303 				See Other 			告知客户端应该用另一个URL来获取资源。新的URL位于响应报文的Location
+    										首部。其主要母的是允许POST请求的响应将客户端定向到某个资源上去
+
+    304  				Not Modified 		客户端可以通过所包含的请求首部，使其请求变成有条件的。如果客户端发起
+    										了一个条件GET请求，而最近资源未被修改的话，就可以用这个状态码来说明
+    										资源未被修改。带有这个状态码的响应不应该包含实体的主体部分。
+
+    305 				Use Proxy  			用来说明必须通过一个代理访问资源；代理的位置由Location首部给出。很
+    										重要的一点是，客户端是相对某个特定资源来解析这条响应的，不能假定所有请求。甚至所有对持有请求资源的服务器的请求都通过这个代理进行。如果客户端错误地让代理介入了某条请求，可能会引发破坏性的行为，而且会造成安全漏洞。
+
+   	307					Temporary Redireat 与301状态码类似；但客户端应该使用Location首部给出的URL来临时定位资源
+   											。将来的请求应该使用老的URL
+
+
+   	400 				Bad Request 		用于告知客户端发起了一个错误的请求
+
+   	401 				Unauthorized 		返回适当的首部，用于获取客户端访问资源的权限
+
+   	402         		Payment Required    此状态码未使用，保留
+
+   	403                 Forbidden           服务器拒绝请求，可在响应主体中告知原因
+
+   	404  				Not Found           用于告知客户端请求的资源在服务器不存在
+
+   	405 				Method Not Allowd   告知客户端不支持当前方法，并在Allow首部返回支持的方法
+
+   	406 				Not Acceptable     	没有客户端支持的资源类型
+
+   	407 				Proxy Authentication  跟401类似，不过用户代理服务器
+   						Requireed 
+
+   	408 				Request Timeout     超时提醒
+
+   	409      			Conflict            请求会造成服务器冲突
+
+   	410  	            Gone   				跟404一样，只不过服务器曾经拥有过该请求资源
+
+   	411 				Length Required    要求客户端发送Content-Length首部
+
+   	412 				Precondition Failed  部分条件验证不通过
+
+   	413   				Request Entity Too Large  客户端发送的主体超过了服务器的希望的长度
+
+   	414 				Request  URL Too Long   客户端请求的时间比服务希望的时间长
+
+   	415 				Unsupported Media Type 	服务器无法理解客户端请求的主体类型
+
+   	416 				Requested Range Not    请求报文所请求的是指定资源的某个范围，而此范围无效或无法满足时
+   						Satisfiable   			，使用此状态码
+
+   	417					Expectation Failed 		请求中包含Expect首部，服务器无法满足
+
+   	500					Internal Server Error  服务器错误
+
+   	501 				Not Implemented         请求超出了服务器能处理的范围
+
+   	502 				Bad Gateway 			作为代理或网关使用的服务器从请求响应链的下一条链路上收到了一条
+   												伪响应（比如，它无法连接到其父网关）时，使用此状态码
+
+   	503    				Service Unavailable 	用来说明服务器现在无法为请求提供服务，但将来可以。如果服务器
+   												知道什么时候资源会变为可用的，可以在响应中包含包含一个
+   												Retry-After首部。
+
+   	504 				Gateway Timeout 		与状态码408类似，只是这里的响应来自一个网关或代理，它们在等待另
+   												一服务器对其请求进行响应时超时了
+
+    505 				HTTP Version Not        服务器收到的请求使用了它无法或不愿支持的协议版本时，使用此
+    					Supported 				状态码。有些服务器应用程序会选择不支持协议的早起版本	
+
+
+```
+
+
+#### 常见首部字段含义介绍
+
+* 注：首部分为通用首部、请求首部、响应首部、主体首部、扩展首部！
+
+* **通用首部**
+
+```
+
+   通用的信息性首部
+
+   首部                                         描述
+
+   Connection               允许客户端和服务器指定与请求/响应连接有关的选项
+
+   Date                     提供了日期的时间标志，说明报文是什么时间创建的
+
+   MIME-Version             给出了发送端使用的MIME版本
+
+   Trailer                  如果报文采用了分块传输编码方式，就可以用这个首部列出位于报文拖挂部分的首部集合
+
+   Transfer-Encoding        告知接收端为了保证报文的可靠传输，对报文采用了什么编码方式
+
+   Update                   给出了发送端可能想要“升级”使用的新版本或协议
+
+   Via                      显示了报文经过的中间节点（代理、网关）
+
+
+   通用缓存首部
+
+   首部                                 描述
+
+   Cache-Control            用于随报文传送缓存指示
+
+   Pragma                   另一种随报文传送指示的方式，但并不专用缓存
+
+
+```
+
+* **请求首部**
+
+```
+
+    请求的信息性首部
+
+    首部                                描述
+
+    Client-IP               提供了运行客户端的机器的IP地址
+
+    From                    提供了客户端用户的E-mail地址
+
+    Host                    给出了接收请求的服务器的主机名和端口号
+
+    Referer                 提供了包含当前请求URL的文档的URL
+
+    UA-Color                提供了与客户端显示器的显示颜色有关的信息
+
+    UA-CPU                  给出了客户端CPU的类型或制造商
+
+    UA-Disp                 提供了与客户端显示器（屏幕）能力有关的信息
+
+    UA-OS                   给出了运行在客户端机器上的操作系统名称及版本
+
+    UA-Pixels               提供了客户端显示器的像素信息
+
+    User-Agent              将发起请求的应用程序名称告知服务器
+
+    Accept首部
+
+    首部                                  描述
+
+    Accept                  告诉服务器能够发送那些媒体类型
+
+    Accept-Charset          告诉服务器能够给发送那些字符集
+
+    Accept-Encoding         告诉服务器能够发送那些编码方式
+
+    Accept-Language         告诉服务器能够发送那些语言
+
+    TE                      告诉服务器可以使用那些扩展传输编码
+
+
+
+    条件请求首部
+
+    首部                                描述
+
+    Expect                  允许客户端列出某请求所要求的服务器行为
+
+    If-Match                如果实体标记与文档当前的实体标记相匹配，就获取这份文档
+
+    If-Modified-Since       除非在某个指定的日期之后资源被修改过，否则就限制这个请求
+
+    If-None-Match           如果提供的实体标记与当前文档的标记不相符，就获取文档
+
+    If-Range                允许对文档的某个范围进行条件请求
+
+    If-Unmodified-Since     除非在某个指定日期之后资源没有被修改过，否则就限制这个请求
+
+    Range                   如果服务器支持范围请求，就请求资源的指定范围
+
+
+    安全请求首部
+
+    首部                                  描述
+
+    Authorization           包含了客户端提供给服务器，以便对其自身进行认证的数据
+
+    Cookie                  客户端用它向服务器传送一个令牌————它并不是真正的安全首部，但确实隐含了安全功能
+
+    Cookie2                 用来说明请求端支持的cookie版本
+
+
+
+    代理请求首部
+
+    首部                                  描述
+
+    Max-Forward             在通往源端服务器的路径上，将请求转发给其他代理或网关的最大次数————与TRACE方法一同
+                            使用
+
+    Proxy-Authorization     与Authorization首部相同，但这个首部是在与代理进行认证时使用的
+
+    Proxy-Connection        与Connection首部相同，但这个首部是在与代理建立连接时使用的
+
+
+```
+
+* **响应首部**
+
+```
+
+    响应的信息性首部
+
+    首部                                        描述
+
+    Age                     （从最初创建开始）响应持续时间
+
+    Public                   服务器为其资源支持的请求方法列表
+
+    Retry-After              如果资源不可用的话，在此日期或时间重试
+
+    Server                   服务器应用程序软件的名称和版本
+
+    Title                    对HTML文档来说，就是HTML文档的源端给出的标题
+
+    Warning                  比原因短语中更详细的警告报文
+
+
+    协商首部
+
+    首部                                  描述
+
+    Accept-Ranges           对此资源来说，服务器可接受的范围类型
+
+    Vary                    服务器查看的其他首部的列表，可能会使响应发生变化；也就是说，这是一个首部列表，
+                            服务器会根据这些首部的内容挑选处最合适的资源版本发送个客户端
+
+    安全响应首部
+
+    首部                                    描述
+
+    Proxy-Authenticate      来自代理的对客户端的质询列表
+
+    Set-Cookie              不是真正的安全首部，但隐含有安全功能；可以在客户端设置一个令牌，以便服务器对客户端
+                            进行标志
+
+    Set-Cookie2             与Set-Cookie类似
+
+    WWW-Authenticate        来自服务器的对客户端的质询列表
+
+
+
+```
+
+
+* **实体首部**
+
+
+```
+
+  实体的信息性首部
+
+  首部                                          描述
+
+  Allow                       列出了可以对此实体执行的请求方法
+
+  Location                    告知客户端实体实际上位于何处；用于将接收端丁香到资源的位置上去
+
+
+  内容首部
+
+  首部                                          描述
+
+  Content-Base                解析主体中的相对URL时使用的基础URL
+
+  Content-Encoding            对主体执行的任意编码方式
+
+  Content-Language            理解主体时最适宜使用的自然语言
+
+  Content-Length              主体的长度或者尺寸
+
+  Content-Location            资源实际所处的位置
+
+  Content-MD5                 主体的MD5校验和
+
+  Content-Range               在整个资源中此实体表示的字节范围
+
+  Content-Type                这个主体的对象类型
+
+  实体缓存首部
+
+  首部                                                  描述
+
+  ETag                        与此实体相关的实体标记
+
+  Expires                     实体不再有效，要从原始的源端再次获取此实体的日期和时间
+
+  Last-Modified               这个实体最后一次被修改的日期和时间
+
 ```
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/04 \350\277\236\346\216\245\347\256\241\347\220\206.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/04 \350\277\236\346\216\245\347\256\241\347\220\206.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/04 \350\277\236\346\216\245\347\256\241\347\220\206.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/04 \350\277\236\346\216\245\347\256\241\347\220\206.md"
index e8a62b0b..38890204 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/04 \350\277\236\346\216\245\347\256\241\347\220\206.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/04 \350\277\236\346\216\245\347\256\241\347\220\206.md"	
@@ -1,141 +1,141 @@
-### 内容提要
-
-* 这一章主要讲解了http的下层协议tcp/ip的一些知识点：tcp/ip建立连接需要做的事情，tcp/ip所带来的时延，以及从http的角度出发，提升网络性能的一些方法，涉及到串行连接、并行连接、持久连接、管道连接等概念！以及介绍了如何关闭连接等概念。
-
-
-#### TCP/IP连接
-
-* TCP/IP是全球计算机及网络设备都在使用的一种常用的分组交换网络分层协议集，位于http下层。其实常谈论的http连接实际上就是tcp连接加上一些使用连接的规则，tcp为http提供了一条可靠的比特传输管道。一旦连接建立起来，在客户端和服务器的计算机之间交换的报文就永远不会丢失、受损或失序。
-
-* 通常http事务发生时会经过几个步骤，下面以访问http://www.xxx.com:80/path/index.html为例说明：
-
-1. 浏览器从地址栏中解析处域名（主机名），也就是拿到www.xxx.com
-
-2. 浏览器根据得到的主机名查询出ip地址，比如算出ip为202.43.78.3，（中间可能经过查找host文件或去查询dns服务器）
-
-3. 浏览器解析出端口（http默认为80，https默认为443）
-
-4. 浏览器发起一条到202.43.78.3端口为80的链接，（重建需要经过几次确定相关参数的来回“握手”）
-
-5. 浏览器发起请求报文
-
-6. 服务器返回响应报文
-
-7. 浏览器关闭连接（其实浏览器和服务器都可以在不通知对方的情况关闭连接）
-
-
-* TCP流是分段的，由IP分组传输，也就是说最终http报文是以ip分组的形式在网络之间传输。一个ip分组包含的数据信息如下：
-
-``` 
-	1. ip分组首部（通常为20字节）
-	2. tcp段首部 （通常为20字节）
-	3. tcp数据块 （0个或多个字节，实际http报文数据就在这里） 
-```
-
-用一句话描述这个过程就是，http报文流给到tcp，tcp把报文分成一段一段的，然后tcp把每个tcp段交给ip，ip封装成一个ip分组，最后传输的是ip分组。（当然了这里我们忽略了ip下面的数据链路层和物理层）
-
-**TCP确定一个连接**
-
-* TCP用四个信息来唯一确定一条连接：源ip地址、源端口号、目的ip地址、目的端口号。只要其中有一个不同，那么就不是同一条连接。在任意时刻计算机都可以有几条tcp连接在打开状态。
-
-#### 对TCP性能的考虑
-
-* 首先相对建立tcp连接、发送http请求报文以及响应报文相比，http事务处理的时间相对短很多很多，此时延可不用讨论，除非你的服务器超负载了或正在处理复杂的运算。因此，http事务的时延往往由以下原因组成：
-
-1. 首先客户端解析ip地址或者端口号需要时间，如果当前没有访问过相关资源，那么解析还需要查询dns服务器，此操作，造成的时延较多，可能花费数十秒。
-
-2. 建立tcp链接会有建立时延，通常2s左右，如果当前的http事务较多，那么会很快叠加上去。
-
-3. 传输、处理请求报文需要时间
-
-4. 回传响应报文需要时间
-
-5. 当然还有其他因素，比如硬件、网络负载，以及报文尺寸等！
-
-* **性能聚焦区域**
-
-这里简要说明一下，建立tcp链接这个过程可能存在的时延分析，包括：经典三次“握手”、tcp慢启动拥塞控制机制等！
-
-* 经典三次“握手”说的就是http事务在建立tcp连接是需要做的相关参数确认过程，大概如下：
-
-1. 客户端发送携带“SYN”标记的TCP段说明发起连接请求
-
-2. 服务端返回“SYN”和“ACK”的TCP段说明已接受
-
-3. 最后客户端发送确认信息以确认连接
-
-
-* tcp慢启动说明了，tcp连接会随着时间的增加进行自我调谐。这个主要目的防止突然的tcp连接增多导致网络瘫痪，所以它会慢慢的调整传输速度，这个机制就叫做TCP慢启动。
-
-
-
-#### HTTP连接的处理
-
-##### 常被误解的connection首部
-
-* connection能承载三种字段值：
-
-```
-
-	HTTP首部字段名，列出了只与此有关的首部；
-
-	任意标签值，用于描述此链接的非标准选项；
-
-	值close，说明操作完成之后需关闭这条持久连接。
-
-```
-
-接收端在收到请求报文之后，对报文进行解析，并查看connection首部中列出的首部列表，并在转发出去之前，删除相关首部，这一行为称为：“对首部的保护”。
-
-
-##### 串行处理事务时延
-
-* 此种机制描述了http事务一个一个接着发起，不能同时下载更多的资源，使得界面上用户看不到东西，体验不够好。串行连接没有很好的利用tcp/ip连接的慢启动机制！
-
-* 优化方法主要有：
-
-```
-    并行连接
-
-    通过多条TCP连接发起并发的HTTP连接
-
-    持久连接
-
-    重用TCP连接，以消除连接及关闭时延
-
-    管道化连接
-
-    通过共享的TCP连接发起并发的HTTP请求
-
-
-```
-
-
-##### 并行连接
-
-* 浏览同时发起过个http事务，因为是并行的，所以时延也并行的，这样总时延较小，页面呈现更快，体验较好。但也不是总是这样，因为如果在网络速度很慢的时候，多个连接会去竞争本来不多的带宽，那么就谈不上加快速度了。还有就是并行连接也是需要付出代价的，比如增加系统内训消耗、服务器负载，比如有一个100客户端同时对服务发起100tcp并行连接的话，那么服务器就得负责10000个处理请求，很快的你的服务器就会爆掉。当然了，并行连接确实能带来视觉上的速度提升，因为相比于串行连接慢慢地显示数据而并行一下子能全部显示完信息，视觉上并行连接会给人速度更快的感觉！
-
-##### 持久连接
-
-* 持久连接描述的是：如果对同ip、同端口的发起多个http事务连接，那么可以在前一个事务处理完成之后不要关闭tcp连接，以此来减小建立tcp、tcp慢启动所带来的时延。相关概念不在赘述！
-
-
-##### 管道化连接
-
-HTTP/1.1允许在持久连接上可选地使用请求管道。这是在keep-alive连接上的进一步性能优化。在响应到达之前，可以将多条请求放入队列。当第一条请求通过网络流向地球另一端的服务器时，第二条和第三条请求也可以开始发送了。在高时延网络条件下，这样做可以降低网络的环回时间，提高性能。
-
-* 管道连接的限制
-
-- - 如果不是持久连接就不要使用管道连接
-
-- - 接收端必须按收到请求报文的顺序返回响应报文，因为HTTP报文中没有序列号标签。所以必须靠按序发送响应报文来达到“数据对应”
-
-- - 发送端应该做好数据没有发送完连接就关闭的准备并开始重新发送数据。
-
-- - HTTP客户端不应该用管道化的方式发送会产生副作用的请求（比如POST）。
-
-##### 关闭连接的奥秘
-
- 略
-
-
+### 内容提要
+
+* 这一章主要讲解了http的下层协议tcp/ip的一些知识点：tcp/ip建立连接需要做的事情，tcp/ip所带来的时延，以及从http的角度出发，提升网络性能的一些方法，涉及到串行连接、并行连接、持久连接、管道连接等概念！以及介绍了如何关闭连接等概念。
+
+
+#### TCP/IP连接
+
+* TCP/IP是全球计算机及网络设备都在使用的一种常用的分组交换网络分层协议集，位于http下层。其实常谈论的http连接实际上就是tcp连接加上一些使用连接的规则，tcp为http提供了一条可靠的比特传输管道。一旦连接建立起来，在客户端和服务器的计算机之间交换的报文就永远不会丢失、受损或失序。
+
+* 通常http事务发生时会经过几个步骤，下面以访问http://www.xxx.com:80/path/index.html为例说明：
+
+1. 浏览器从地址栏中解析处域名（主机名），也就是拿到www.xxx.com
+
+2. 浏览器根据得到的主机名查询出ip地址，比如算出ip为202.43.78.3，（中间可能经过查找host文件或去查询dns服务器）
+
+3. 浏览器解析出端口（http默认为80，https默认为443）
+
+4. 浏览器发起一条到202.43.78.3端口为80的链接，（重建需要经过几次确定相关参数的来回“握手”）
+
+5. 浏览器发起请求报文
+
+6. 服务器返回响应报文
+
+7. 浏览器关闭连接（其实浏览器和服务器都可以在不通知对方的情况关闭连接）
+
+
+* TCP流是分段的，由IP分组传输，也就是说最终http报文是以ip分组的形式在网络之间传输。一个ip分组包含的数据信息如下：
+
+``` 
+	1. ip分组首部（通常为20字节）
+	2. tcp段首部 （通常为20字节）
+	3. tcp数据块 （0个或多个字节，实际http报文数据就在这里） 
+```
+
+用一句话描述这个过程就是，http报文流给到tcp，tcp把报文分成一段一段的，然后tcp把每个tcp段交给ip，ip封装成一个ip分组，最后传输的是ip分组。（当然了这里我们忽略了ip下面的数据链路层和物理层）
+
+**TCP确定一个连接**
+
+* TCP用四个信息来唯一确定一条连接：源ip地址、源端口号、目的ip地址、目的端口号。只要其中有一个不同，那么就不是同一条连接。在任意时刻计算机都可以有几条tcp连接在打开状态。
+
+#### 对TCP性能的考虑
+
+* 首先相对建立tcp连接、发送http请求报文以及响应报文相比，http事务处理的时间相对短很多很多，此时延可不用讨论，除非你的服务器超负载了或正在处理复杂的运算。因此，http事务的时延往往由以下原因组成：
+
+1. 首先客户端解析ip地址或者端口号需要时间，如果当前没有访问过相关资源，那么解析还需要查询dns服务器，此操作，造成的时延较多，可能花费数十秒。
+
+2. 建立tcp链接会有建立时延，通常2s左右，如果当前的http事务较多，那么会很快叠加上去。
+
+3. 传输、处理请求报文需要时间
+
+4. 回传响应报文需要时间
+
+5. 当然还有其他因素，比如硬件、网络负载，以及报文尺寸等！
+
+* **性能聚焦区域**
+
+这里简要说明一下，建立tcp链接这个过程可能存在的时延分析，包括：经典三次“握手”、tcp慢启动拥塞控制机制等！
+
+* 经典三次“握手”说的就是http事务在建立tcp连接是需要做的相关参数确认过程，大概如下：
+
+1. 客户端发送携带“SYN”标记的TCP段说明发起连接请求
+
+2. 服务端返回“SYN”和“ACK”的TCP段说明已接受
+
+3. 最后客户端发送确认信息以确认连接
+
+
+* tcp慢启动说明了，tcp连接会随着时间的增加进行自我调谐。这个主要目的防止突然的tcp连接增多导致网络瘫痪，所以它会慢慢的调整传输速度，这个机制就叫做TCP慢启动。
+
+
+
+#### HTTP连接的处理
+
+##### 常被误解的connection首部
+
+* connection能承载三种字段值：
+
+```
+
+	HTTP首部字段名，列出了只与此有关的首部；
+
+	任意标签值，用于描述此链接的非标准选项；
+
+	值close，说明操作完成之后需关闭这条持久连接。
+
+```
+
+接收端在收到请求报文之后，对报文进行解析，并查看connection首部中列出的首部列表，并在转发出去之前，删除相关首部，这一行为称为：“对首部的保护”。
+
+
+##### 串行处理事务时延
+
+* 此种机制描述了http事务一个一个接着发起，不能同时下载更多的资源，使得界面上用户看不到东西，体验不够好。串行连接没有很好的利用tcp/ip连接的慢启动机制！
+
+* 优化方法主要有：
+
+```
+    并行连接
+
+    通过多条TCP连接发起并发的HTTP连接
+
+    持久连接
+
+    重用TCP连接，以消除连接及关闭时延
+
+    管道化连接
+
+    通过共享的TCP连接发起并发的HTTP请求
+
+
+```
+
+
+##### 并行连接
+
+* 浏览同时发起过个http事务，因为是并行的，所以时延也并行的，这样总时延较小，页面呈现更快，体验较好。但也不是总是这样，因为如果在网络速度很慢的时候，多个连接会去竞争本来不多的带宽，那么就谈不上加快速度了。还有就是并行连接也是需要付出代价的，比如增加系统内训消耗、服务器负载，比如有一个100客户端同时对服务发起100tcp并行连接的话，那么服务器就得负责10000个处理请求，很快的你的服务器就会爆掉。当然了，并行连接确实能带来视觉上的速度提升，因为相比于串行连接慢慢地显示数据而并行一下子能全部显示完信息，视觉上并行连接会给人速度更快的感觉！
+
+##### 持久连接
+
+* 持久连接描述的是：如果对同ip、同端口的发起多个http事务连接，那么可以在前一个事务处理完成之后不要关闭tcp连接，以此来减小建立tcp、tcp慢启动所带来的时延。相关概念不在赘述！
+
+
+##### 管道化连接
+
+HTTP/1.1允许在持久连接上可选地使用请求管道。这是在keep-alive连接上的进一步性能优化。在响应到达之前，可以将多条请求放入队列。当第一条请求通过网络流向地球另一端的服务器时，第二条和第三条请求也可以开始发送了。在高时延网络条件下，这样做可以降低网络的环回时间，提高性能。
+
+* 管道连接的限制
+
+- - 如果不是持久连接就不要使用管道连接
+
+- - 接收端必须按收到请求报文的顺序返回响应报文，因为HTTP报文中没有序列号标签。所以必须靠按序发送响应报文来达到“数据对应”
+
+- - 发送端应该做好数据没有发送完连接就关闭的准备并开始重新发送数据。
+
+- - HTTP客户端不应该用管道化的方式发送会产生副作用的请求（比如POST）。
+
+##### 关闭连接的奥秘
+
+ 略
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/05 web\346\234\215\345\212\241\345\231\250.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/05 web\346\234\215\345\212\241\345\231\250.md"
similarity index 97%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/05 web\346\234\215\345\212\241\345\231\250.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/05 web\346\234\215\345\212\241\345\231\250.md"
index 72f95fa1..9517e50d 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/05 web\346\234\215\345\212\241\345\231\250.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/05 web\346\234\215\345\212\241\345\231\250.md"	
@@ -1,160 +1,160 @@
-### 内容提要
-
-* 本章简单介绍了web服务器原理、实现以及实现处理http事务的一些细节！
-
-#### web服务器
-
-* 定义：实现提供资源或应答的提供者都可以谓之为服务器！
-
-* 从不同形式划分，服务器有以下几种：
-
-	1. 标准计算机上安装的通用服务器，如apache
-
-	2. 购买的服务器
-
-	3. 嵌入式服务器
-
-#### web服务器应该做些什么
-
-1. 接受建立连接请求
-
-2. 接受请求
-
-3. 处理请求
-
-4. 访问报文中指定的资源
-
-5. 构建响应
-
-6. 发送响应
-
-7. 记录事务处理过程
-
-
-#### 第一步————接受客户端连接
-
-* 客户端收到一条连接之后，那么它将会把新连接添加到现存web服务器连接列表中，用于监视当前连接上的数据传输情况。期间服务器还应该做到通过一定的设备机制阻止未认证或已知恶意黑名客户端的连接，相关设别技术有：客户端主机名设别、通过ident设别客户端用户等！
-
-
-#### 第二步————接收请求报文
-
-* 主要经过几个步骤来解析报文：
-
-1. 解析请求行，得知方法、url、协议版本，以及crlf符
-
-2. 解析得到以crlf结尾的首部
-
-3. 得到以crlf结尾，标志首部结束的空行（如果有的话）
-
-4. 解析得到主体，（如果有的话）
-
-* web服务可能还会把请求报文用一种自己能快速处理的内部数据结构来存储请求报文！
-
-* 不同的服务器配置预示它能同时处理的事务情况：
-
-1. 单线程web服务器：只能处理一个请求，待当前请求处理完成之后才能处理下一个请求！优点：简单已于实现，适用于低负荷服务器。缺点：不能及时处理其他请求，容易引发延迟过长而导致性能问题。
-
-2. 多线程及多进程web服务器：能同时处理多个请求！优点：响应及时。缺点：构建复杂，容易快速引起内存消耗过大而死机！最好应该对能同时处理的连接数量进行限制！
-
-3. 复用i/o的web服务器：复用i/o
-
-4. 复用i/o和多线程的web服务器：2和3的结合
-
-
-#### 第三步————处理请求
-
-* 这点留在本书其余章节大篇幅介绍！
-
-#### 第四步————对资源的映射及访问
-
-* 这里介绍了请求资源的一种路径映射关系，说白了就是找到客户端请求资源在服务器的上的目录路径！相关概念有：docroot(文档根目录)、不允许访问根目录的上一级目录。
-
-
-* 虚拟托管的docroot:在一个服务器上挂了几个web站点，那么这样当请求的资源路径相同时，服务器应该从请求报文首部的host、uri字段找出真正的资源目录，这些目录都是可以配置的！
-
-* 注：这里对用户配置文件根目录和虚拟目录做一下示例说明，以apache为例：
-
-```
-  配置文件根目录
-  在配置文件httpd.conf中添加一个DocumentRoot行就可以为Apache Web服务器设置文档的根目录了，如：
-
-  	DocumentRoot /user/local/httpd/files
-
-
-  配置虚拟目录
-  对大多数Web服务器来说，配置虚拟托管的文档根目录是很简单的。对常见的Apache Web服务器来说，需要为每个虚拟Web
-  站点配置一个VirtualHosts块，而且每个虚拟服务器都要包含DocumentRoot，如：
-
-  <VirtualHost www.joes-hardware.com>
-  	ServerName www.joes-hardware.com
-  	DocumentRoot /docs/joe
-  	TransferLog /logs/joe.access_log
-  	ErrorLog /logs/joe.error_log
-  </VirtualHost>
-
-  <VirtualHost www.marys-antiques.com>
-  	ServerName www.marys-antiques.com
-  	DocumentRoot /docs/mary
-  	TransferLog /logs/mary.access_log
-  	ErrorLog /logs/mary.error_log
-  </VirtualHost>
-
-     ... 
-
-```
-
-#### 第五步————构建响应
-
-* 构建响应报文：1、正确设置响应主体的长度（content-length）；2、设置报文的mime类型（content-type）,主要通过与一直mime类型文件匹配得到当前的文件的mime类型，还可以通过文件扩展名，以及硬规定特定目录下的文件拥有某个mime类型；3、控制重定向！
-
-* 服务器端如何得出文件的MIME类型：
-
-```
-
-	Web服务器要负责确定响应主体的MIME类型。有很多配置服务器的方法可以将MIME类型与资源关联起来。
-
-	1、MIME类型（mime.types）
-	   Web服务器可以用文件的扩展名来说明MIME类型。Web服务器会为每个资源扫描一个包含了所有扩展名的MIME类型的文件，以确定其MIME类型。这种基于扩展名的类型相关是最常见的！
-
-	2、魔法分类（Magic typing）
-	   Apache Web服务器可以扫描每个资源的内容，并将其与一个已知模式表（被称为魔法文件）进行匹配，以决定每个文
-	   件的MIME类型。这样做可能比较慢，但很方便，尤其是文件没有标准扩展名的时候。
-
-	3、显示分类（Explicit typing）
-	   可以对Web服务器进行配置，使其不考虑文件的扩展名或内容，强制特定文件或目录内容拥有某个MIME类型
-
-	4、类型协商
-	   有些Web服务器经过配置，可以以多种文档格式来存储资源。在这种情况下，可以配置Web服务器，使其可以通过与用户的协商来是决定使用哪种格式（及相关的MIME类型）“最好”。
-
-```
-
-
-##### 重定向
-
-* 有时服务器需要返回重定向报文来构建响应，重定向响应由返回码3XX说明。Location响应首部包含了内容的新地址或优选地址的URL。重定向可用于下列情况。
-
- - - 永久删除的资源，状态码为301
-
- - - 临时删除的资源，状态码为303或307
-
- - - URL增强，状态码为303或307
-
- - - 负载均衡，主要是减少服务器的压力，让请求跑到一个负载不大的服务器上去，状态码为303或307
-
- - - 服务器关联，去保存有用户本地信息的服务器上获取用户信息，状态码为303或307
-
- - - 规范目录名称，客户端请求的URI是一个不带尾部斜线的目录名时，大多数Web服务器都会将客户端重定向到一个加了斜线的URI上，这样相对链接就可以正常工作了！
-
-
-#### 第六步————发送响应
-
-* 略
-
-#### 第七步————记录事务日志
-
-* 在web服务器日志文件中添加一个条目，以描述当前事务处理情况！
-
-
-
-
-
+### 内容提要
+
+* 本章简单介绍了web服务器原理、实现以及实现处理http事务的一些细节！
+
+#### web服务器
+
+* 定义：实现提供资源或应答的提供者都可以谓之为服务器！
+
+* 从不同形式划分，服务器有以下几种：
+
+	1. 标准计算机上安装的通用服务器，如apache
+
+	2. 购买的服务器
+
+	3. 嵌入式服务器
+
+#### web服务器应该做些什么
+
+1. 接受建立连接请求
+
+2. 接受请求
+
+3. 处理请求
+
+4. 访问报文中指定的资源
+
+5. 构建响应
+
+6. 发送响应
+
+7. 记录事务处理过程
+
+
+#### 第一步————接受客户端连接
+
+* 客户端收到一条连接之后，那么它将会把新连接添加到现存web服务器连接列表中，用于监视当前连接上的数据传输情况。期间服务器还应该做到通过一定的设备机制阻止未认证或已知恶意黑名客户端的连接，相关设别技术有：客户端主机名设别、通过ident设别客户端用户等！
+
+
+#### 第二步————接收请求报文
+
+* 主要经过几个步骤来解析报文：
+
+1. 解析请求行，得知方法、url、协议版本，以及crlf符
+
+2. 解析得到以crlf结尾的首部
+
+3. 得到以crlf结尾，标志首部结束的空行（如果有的话）
+
+4. 解析得到主体，（如果有的话）
+
+* web服务可能还会把请求报文用一种自己能快速处理的内部数据结构来存储请求报文！
+
+* 不同的服务器配置预示它能同时处理的事务情况：
+
+1. 单线程web服务器：只能处理一个请求，待当前请求处理完成之后才能处理下一个请求！优点：简单已于实现，适用于低负荷服务器。缺点：不能及时处理其他请求，容易引发延迟过长而导致性能问题。
+
+2. 多线程及多进程web服务器：能同时处理多个请求！优点：响应及时。缺点：构建复杂，容易快速引起内存消耗过大而死机！最好应该对能同时处理的连接数量进行限制！
+
+3. 复用i/o的web服务器：复用i/o
+
+4. 复用i/o和多线程的web服务器：2和3的结合
+
+
+#### 第三步————处理请求
+
+* 这点留在本书其余章节大篇幅介绍！
+
+#### 第四步————对资源的映射及访问
+
+* 这里介绍了请求资源的一种路径映射关系，说白了就是找到客户端请求资源在服务器的上的目录路径！相关概念有：docroot(文档根目录)、不允许访问根目录的上一级目录。
+
+
+* 虚拟托管的docroot:在一个服务器上挂了几个web站点，那么这样当请求的资源路径相同时，服务器应该从请求报文首部的host、uri字段找出真正的资源目录，这些目录都是可以配置的！
+
+* 注：这里对用户配置文件根目录和虚拟目录做一下示例说明，以apache为例：
+
+```
+  配置文件根目录
+  在配置文件httpd.conf中添加一个DocumentRoot行就可以为Apache Web服务器设置文档的根目录了，如：
+
+  	DocumentRoot /user/local/httpd/files
+
+
+  配置虚拟目录
+  对大多数Web服务器来说，配置虚拟托管的文档根目录是很简单的。对常见的Apache Web服务器来说，需要为每个虚拟Web
+  站点配置一个VirtualHosts块，而且每个虚拟服务器都要包含DocumentRoot，如：
+
+  <VirtualHost www.joes-hardware.com>
+  	ServerName www.joes-hardware.com
+  	DocumentRoot /docs/joe
+  	TransferLog /logs/joe.access_log
+  	ErrorLog /logs/joe.error_log
+  </VirtualHost>
+
+  <VirtualHost www.marys-antiques.com>
+  	ServerName www.marys-antiques.com
+  	DocumentRoot /docs/mary
+  	TransferLog /logs/mary.access_log
+  	ErrorLog /logs/mary.error_log
+  </VirtualHost>
+
+     ... 
+
+```
+
+#### 第五步————构建响应
+
+* 构建响应报文：1、正确设置响应主体的长度（content-length）；2、设置报文的mime类型（content-type）,主要通过与一直mime类型文件匹配得到当前的文件的mime类型，还可以通过文件扩展名，以及硬规定特定目录下的文件拥有某个mime类型；3、控制重定向！
+
+* 服务器端如何得出文件的MIME类型：
+
+```
+
+	Web服务器要负责确定响应主体的MIME类型。有很多配置服务器的方法可以将MIME类型与资源关联起来。
+
+	1、MIME类型（mime.types）
+	   Web服务器可以用文件的扩展名来说明MIME类型。Web服务器会为每个资源扫描一个包含了所有扩展名的MIME类型的文件，以确定其MIME类型。这种基于扩展名的类型相关是最常见的！
+
+	2、魔法分类（Magic typing）
+	   Apache Web服务器可以扫描每个资源的内容，并将其与一个已知模式表（被称为魔法文件）进行匹配，以决定每个文
+	   件的MIME类型。这样做可能比较慢，但很方便，尤其是文件没有标准扩展名的时候。
+
+	3、显示分类（Explicit typing）
+	   可以对Web服务器进行配置，使其不考虑文件的扩展名或内容，强制特定文件或目录内容拥有某个MIME类型
+
+	4、类型协商
+	   有些Web服务器经过配置，可以以多种文档格式来存储资源。在这种情况下，可以配置Web服务器，使其可以通过与用户的协商来是决定使用哪种格式（及相关的MIME类型）“最好”。
+
+```
+
+
+##### 重定向
+
+* 有时服务器需要返回重定向报文来构建响应，重定向响应由返回码3XX说明。Location响应首部包含了内容的新地址或优选地址的URL。重定向可用于下列情况。
+
+ - - 永久删除的资源，状态码为301
+
+ - - 临时删除的资源，状态码为303或307
+
+ - - URL增强，状态码为303或307
+
+ - - 负载均衡，主要是减少服务器的压力，让请求跑到一个负载不大的服务器上去，状态码为303或307
+
+ - - 服务器关联，去保存有用户本地信息的服务器上获取用户信息，状态码为303或307
+
+ - - 规范目录名称，客户端请求的URI是一个不带尾部斜线的目录名时，大多数Web服务器都会将客户端重定向到一个加了斜线的URI上，这样相对链接就可以正常工作了！
+
+
+#### 第六步————发送响应
+
+* 略
+
+#### 第七步————记录事务日志
+
+* 在web服务器日志文件中添加一个条目，以描述当前事务处理情况！
+
+
+
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/06 \344\273\243\347\220\206.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/06 \344\273\243\347\220\206.md"
similarity index 97%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/06 \344\273\243\347\220\206.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/06 \344\273\243\347\220\206.md"
index 9fb50d20..85a0e94c 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/06 \344\273\243\347\220\206.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/06 \344\273\243\347\220\206.md"	
@@ -1,119 +1,119 @@
-### 内容提要
-
-* 本章主要介绍了http代理方面的概念，包括代理的配置、分类、作用等！
-
-#### web的中间实体
-
-* web上的代理服务器是代表客户端对事务请求处理的中间人！分为私有代理（只代理一个客户端）和公共代理（代理多个客户端）。
-
-* 代理和网关的对比：代理的两端使用相同的协议，而网关的两端使用不同的协议，网关负责协议转换！
-
-#### 为什么使用代理
-
-* 主要使用代理作以下功能使用：
-
-1、儿童过滤器：如服务器响应的成人内容进行过滤
-
-2、文档访问控制：验证客户端访问某个的文件需要的证书
-
-3、安全防火墙：提供一个防火墙保护客户端或服务器
-
-4、web缓存（缓存资源的副本）：对客户端响应资源的副本，节省带宽、减少网络拥堵
-
-5、反向代理（原始服务的替代物，能访问其他服务器，作服务器加速器使用）：反向代理伪装成原始服务器，不过与服务器不同的是反向代理还可以向其他服务器发送请求，以便实现按需定位所请求的内容！
-
-6、内容路由器：比如网络中实现为了一些付费用户提供更好、更快的网络速度，让请求发往缓存服务器，而没有付费的用户请求则发往更远或原始服务器！
-
-7、转码器（比如改变图片格式，以便更轻巧利于传输）
-
-8、匿名者：保护客户端隐私
-
-
-#### 代理去往何处
-
-* 按部署代理的位置代理可以分为一下几种：
-
-1、出口代理：部署在本地网络端，用于保护本地网络或者限制公司带宽
-
-2、访问（入口）代理：用于实现提供缓存响应
-
-3、反向代理：部署在服务器端本地网络上，用于实现更精确的请求和提供性能
-
-4、网络交换代理：部署在网络上，用于检测流浪等
-
-* 代理层次结构描述的代理的部署层级结构，比如一级代理，二级代理等，这是一种静态层级结构，有父代理和子代理的概念，离原始服务器进的的代理是离服务器远的代理的父代理！但是代理层级不应该静态的，而应该可以是动态的，以保证代理可以根据实际网络负载情况而下发报文到不同的代理！从而产生的动态层级代理概念有**负载均衡**、**地理位置附近的路由**等！
-
-* http请求报文是怎么进入代理的，描述的怎么把http请求报文流量导入代理！主要有一下几种方式：
-
-1、*修改客户端*：比如现在的客户端都支持收手动和自动配置代理！
-
-2、*修改网络*：网络通过一些技术在客户端不知情的情况揽入流量进入代理！
-
-3、*修改dns命名空间*：把主机名映射为代理的ip地址，比如修改系统的dns映射文件，让代理伪装成原始服务器，从而把web请求导入代理！
-
-4、*修改服务器*：让服务器返回一个重定向有关的代码，把http请求报文导入到代理！
-
-
-#### 客户端代理设置
-
-* 主要介绍客户端配置代理的几种常见方式，如下：
-
-- - 手工配置 : 显示地设置要使用的代理
-
-- - 预先配置浏览器 : 浏览器厂商或发行商会在将浏览器发送给其客户之前预先对浏览器（或所有其他的Web客户端）的代理设置进行手工配置
-
-- - 代理的自动配置（Proxy Auto-Configuration,PAC）：一个代理配置的js文件，客户端在请求之前会取回这个js文件，从而判断如何决定使用代理
-
-- - WPAD的代理发现 : 略
-
-#### 与代理有关的一些棘手问题
-
-1、发送给服务其的url可以是相对路径，而发送给代理的是包含方法、主机名等完整路径！
-
-2、与虚拟主机目录同样存在的问题，可以通过在请求报文的host首部发送确定的主机信息！
-
-3、拦截代理会受到部分url！
-
-4、代理既可以处理代理请求，也可以处理服务器请求！
-
-5、转发过程中对URI的修改
-
-6、URI的客户端自动扩展和主机名解析
-
-7、没有代理URI的解析
-
-8、有显示代理的URI的解析
-
-9、有拦截代理的URI的解析
-
-
-#### 追踪报文
-
-
-* 现在代理请求逐步流行的情况下，需要一种机制来追踪我们的报文经过了那些节点。此时报文中via字段就是一个描述报文在代理中逐级传输的过程中所经过代理的方式！如下：
-
-```
-	GET /index.html HTTP/1.0
-	Accept: text/html
-	Host: www.joes-hardware.com
-	Via: 1.1 proxy-62.irenes-isp.net,1.0 cache.joes-hardware.com
-
-```
-via字符告诉我们报文流经了两个代理。这个字符串说明第一个代理名为proxy-62.irenes-isp.net,它实现了HTTP/1.1协议，第二个代理被称为cache.joes-hardware.com,实现了HTTP/1.0。
-
-* Server响应首部字段对原始服务器使用的软件进行了描述，如下有几个例子：
-- -  Server: Apache/1.3.14 (Unix) PHP/4.0.4
-
-- -  Server: Netscape-Knterprise/4.1
-
-- -  Server: Microsoft-IIS/5.0
-
-注：如果响应报文是通过代理转发的，一定要确保代理没有修改Server首部。Server首部是用于原始服务器的。代理应该添加的是Via首部。
-
-#### 代理认证
-
-略
-
-#### 代理的互操作性
-
+### 内容提要
+
+* 本章主要介绍了http代理方面的概念，包括代理的配置、分类、作用等！
+
+#### web的中间实体
+
+* web上的代理服务器是代表客户端对事务请求处理的中间人！分为私有代理（只代理一个客户端）和公共代理（代理多个客户端）。
+
+* 代理和网关的对比：代理的两端使用相同的协议，而网关的两端使用不同的协议，网关负责协议转换！
+
+#### 为什么使用代理
+
+* 主要使用代理作以下功能使用：
+
+1、儿童过滤器：如服务器响应的成人内容进行过滤
+
+2、文档访问控制：验证客户端访问某个的文件需要的证书
+
+3、安全防火墙：提供一个防火墙保护客户端或服务器
+
+4、web缓存（缓存资源的副本）：对客户端响应资源的副本，节省带宽、减少网络拥堵
+
+5、反向代理（原始服务的替代物，能访问其他服务器，作服务器加速器使用）：反向代理伪装成原始服务器，不过与服务器不同的是反向代理还可以向其他服务器发送请求，以便实现按需定位所请求的内容！
+
+6、内容路由器：比如网络中实现为了一些付费用户提供更好、更快的网络速度，让请求发往缓存服务器，而没有付费的用户请求则发往更远或原始服务器！
+
+7、转码器（比如改变图片格式，以便更轻巧利于传输）
+
+8、匿名者：保护客户端隐私
+
+
+#### 代理去往何处
+
+* 按部署代理的位置代理可以分为一下几种：
+
+1、出口代理：部署在本地网络端，用于保护本地网络或者限制公司带宽
+
+2、访问（入口）代理：用于实现提供缓存响应
+
+3、反向代理：部署在服务器端本地网络上，用于实现更精确的请求和提供性能
+
+4、网络交换代理：部署在网络上，用于检测流浪等
+
+* 代理层次结构描述的代理的部署层级结构，比如一级代理，二级代理等，这是一种静态层级结构，有父代理和子代理的概念，离原始服务器进的的代理是离服务器远的代理的父代理！但是代理层级不应该静态的，而应该可以是动态的，以保证代理可以根据实际网络负载情况而下发报文到不同的代理！从而产生的动态层级代理概念有**负载均衡**、**地理位置附近的路由**等！
+
+* http请求报文是怎么进入代理的，描述的怎么把http请求报文流量导入代理！主要有一下几种方式：
+
+1、*修改客户端*：比如现在的客户端都支持收手动和自动配置代理！
+
+2、*修改网络*：网络通过一些技术在客户端不知情的情况揽入流量进入代理！
+
+3、*修改dns命名空间*：把主机名映射为代理的ip地址，比如修改系统的dns映射文件，让代理伪装成原始服务器，从而把web请求导入代理！
+
+4、*修改服务器*：让服务器返回一个重定向有关的代码，把http请求报文导入到代理！
+
+
+#### 客户端代理设置
+
+* 主要介绍客户端配置代理的几种常见方式，如下：
+
+- - 手工配置 : 显示地设置要使用的代理
+
+- - 预先配置浏览器 : 浏览器厂商或发行商会在将浏览器发送给其客户之前预先对浏览器（或所有其他的Web客户端）的代理设置进行手工配置
+
+- - 代理的自动配置（Proxy Auto-Configuration,PAC）：一个代理配置的js文件，客户端在请求之前会取回这个js文件，从而判断如何决定使用代理
+
+- - WPAD的代理发现 : 略
+
+#### 与代理有关的一些棘手问题
+
+1、发送给服务其的url可以是相对路径，而发送给代理的是包含方法、主机名等完整路径！
+
+2、与虚拟主机目录同样存在的问题，可以通过在请求报文的host首部发送确定的主机信息！
+
+3、拦截代理会受到部分url！
+
+4、代理既可以处理代理请求，也可以处理服务器请求！
+
+5、转发过程中对URI的修改
+
+6、URI的客户端自动扩展和主机名解析
+
+7、没有代理URI的解析
+
+8、有显示代理的URI的解析
+
+9、有拦截代理的URI的解析
+
+
+#### 追踪报文
+
+
+* 现在代理请求逐步流行的情况下，需要一种机制来追踪我们的报文经过了那些节点。此时报文中via字段就是一个描述报文在代理中逐级传输的过程中所经过代理的方式！如下：
+
+```
+	GET /index.html HTTP/1.0
+	Accept: text/html
+	Host: www.joes-hardware.com
+	Via: 1.1 proxy-62.irenes-isp.net,1.0 cache.joes-hardware.com
+
+```
+via字符告诉我们报文流经了两个代理。这个字符串说明第一个代理名为proxy-62.irenes-isp.net,它实现了HTTP/1.1协议，第二个代理被称为cache.joes-hardware.com,实现了HTTP/1.0。
+
+* Server响应首部字段对原始服务器使用的软件进行了描述，如下有几个例子：
+- -  Server: Apache/1.3.14 (Unix) PHP/4.0.4
+
+- -  Server: Netscape-Knterprise/4.1
+
+- -  Server: Microsoft-IIS/5.0
+
+注：如果响应报文是通过代理转发的，一定要确保代理没有修改Server首部。Server首部是用于原始服务器的。代理应该添加的是Via首部。
+
+#### 代理认证
+
+略
+
+#### 代理的互操作性
+
 略
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/07 \347\274\223\345\255\230.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/07 \347\274\223\345\255\230.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/07 \347\274\223\345\255\230.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/07 \347\274\223\345\255\230.md"
index 78ec3540..d299962b 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/07 \347\274\223\345\255\230.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/07 \347\274\223\345\255\230.md"	
@@ -1,175 +1,175 @@
-### 内容提要
-
-* 本章主要从缓存的架构、优势、节省带宽流量、提升响应及处理步骤等方面阐述了web缓存！
-
-#### 使用缓存的优点
-
-* 缓存减少了冗余的数据传输，因为毕竟每次http事务请求的东西都是一样的时候，多次发送同样的数据是不必要和冗余的！
-
-* 缓存缓解了网络瓶颈的问题，不需要更多的带宽就能够更快地加载页面！
-
-* 缓存降低了对原始服务器的要求，因为想象一下，从一个性能很差劲的原始服务器和从一个性能和牛逼的缓存服务器请求事务，肯定会弥补服务器的缺点的，同时也会减少服务器过载情况，因为大部分请求都由缓存代劳处理了！
-
-* 缓存降低了距离时延，因为从较远的地方加载页面会更慢一些！
-
-####　冗余的数据传输
-
-* 每次都从原始服务器拿数据，那么带来的后果就是：多次发送重复的数据浪费流量、耗费昂贵的网络带宽从而降低传输速率、加大服务器的负载。而有了缓存之后这些问题都可以迎刃而解！
-
-#### 带宽瓶颈
-
-* 带宽瓶颈说明的问题：很多网络为本地客户端配置的带宽要比远程服务器配置的带宽要宽，如果在这种状况下客户端去请求远程服务器，那么客户端将会以一种的较低的速度去请求服务端，从而没有发挥出客户端带宽宽的长处！如果在客户端方向配置一个高速缓存服务器，那么就可以很快的得到响应，由此也看出带宽对报文传输速率的影响！
-
-
-####　瞬间拥塞
-
-* 瞬间拥塞描述的是这样一种情况：一个爆炸性的新闻和热点事件，如果再没有配置缓存的情况下，那么在短时间之内，服务器将会收到突变的请求增长，负荷会爆炸性增长，肯定会吃不消的！但是有了缓存，可以大大分担服务器的负载数量！
-
-
-#### 距离时延
-
-* 距离时延说明的一个问题就是传输数据过程这个过程是需要时间的，而且路程越长，那么需要的时间也会越多，即时延越长。所以在距离客户端较近的地方部署缓存服务器，减小了传输路程，那么就减小了传输时延！
-
-#### 命中与未命中的
-
-* *缓存命中与缓存未命中：*一次http事务请求如果是从得到的响应是从缓存得到的原始响应副本，那么这样的过程就称之为缓存命中。反之，如果缓存没有响应的副本，而要去请求原始服务，那么就把这个过程称之为缓存未命中！
-
-* *http再验证:*原始响应内容是在变化的，所以缓存应该在文档“过期时间”之后去验证缓存的副本是不是新鲜的，这个过程就叫做http再验证！如果再验证之后得知缓存副本是新鲜的，那么原始服务器返回304 not modified。此时，称之为*再验证命中*或*缓存慢命中*！如果得知缓存不是新鲜的，那么服务器返回200 ok。此时，称之为*再验证未命中*！如果原始对象已经被删除了，返回404 not found响应。相应地缓存副本要删除。（注：虽然再验证命中需要跟原始服务器沟通一次，但是它与直接请求服务器相比，还是要快一点，因为再验证命中只是返回了一些新的过期时间有关的新首部而已，并没有发送主体对象。）
-
-
-* *命中率*指由缓存返回副本事务在全部事务中所占的比例，称为缓存命中率。这个数据实际中意义不是很大！而*字节命中率*从资源大小总量的角度说明缓存命中所占的比例。因为他从数据流量的角度出发，所以实际中这个数据的意义挺大的！
-
-* *区分命中和未命中*，简单来说，http没有相应的机制来告知客户端响应是从缓存得到的还是从原始服务器得到的！但我们可以从http响应报文首部中的date字段得知这一情况：如果这个字段的时间比当前时间更早得多，说明这是从缓存得到的，因为date描述的服务器第一次响应的时间，而缓存是不会对这个字段进行修改的！
-
-
-#### 缓存的拓扑结构
-
-* 缓存分为私有缓存（只为一个客户端服务，比如我们给浏览器配置的代理）和共有缓存（为多个客户端服务，现实中是以代理缓存服务器的形式踹出现）。
-
-* 代理缓存的层级结构：此种结构描述的以父、子层级出现的层次结构，同时离客户端越近的子缓存的命中率较低（较廉价），他们可以把请求上升到父缓存（较昂贵），从而在父缓存那里实现事务处理！
-
-* *代理缓存的网状结构*描述的缓存结构并不是很明显呈现父子关系的结构，而是呈无规则的网状！这种结构的思想就是子缓存可以动态选择上一级缓存，从而实现更灵活的缓存控制！
-
-#### 缓存的处理步骤
-
-* 简单概括，即：
-
-``` bash
-	接收————解析————查询————新鲜度检测————创建响应————发送————记入日志
-
-```
-
-* 第一步接收：读取网络连接http请求报文
-
-* 第二部解析：把报文解析为片段，并把首部放入到缓存易操作的数据结构中
-
-* 第三步查询：查找存下来缓存副本
-
-* 第四步新鲜度检测：说白了检查缓存副本是不是还有效的
-
-* 第五步创建响应：缓存服务器用原始服务器的缓存副本实现响应的起点，同时再在此基础上做一些修改，比如协议转换等
-
-* 第六步发送：发送报文
-
-* 第七步日志：事务完成之后，在日志文件插入一个条目，用以记录缓存处理情况，以及记录一些与缓存命中率的数据
-
-
-#### 保持副本的新鲜
-
-* *文档过期*通过特殊的http首部cache-control和expires,http让原始服务器为每个文档设置一个“过期时间”！如：
-
-``` bash
-	
-	Cache-Control: Max-Age=484200
-	Expires: Fri, 28 Oct 2016 03:03:47 GMT
-	
-```
-
-上面的Max-Age是相对时间，以秒为单位，理解为使用期，expires为绝对时间，为到期时间。
-
-* 服务器在验证，描述的过期的文档并不是就是原始服务器的原始文档不一样了，而是需要向服务器发起新鲜度验证请求。
-
-* 用条件方法进行再验证：涉及到的两个首部为If-Modified-Since和If-None-Match。格式为：
-
-``` bash
-
-	If-Modified-Since: <date>
-
-```
-实际上上面那个date为服务器响应报文里面Last-Modified的时间。
-
-* If-None-Match:实体标签再验证！此种机制主要跟If-Modified-Since不同在于：If-Modified-Since是根据修改时间来判断文档新鲜度的，但有些情况这样做是不适用的，因为比如我们只是加了注释什么的，其中实际内容是没有变化的，此时我们也应该认为文档是新鲜的！
-
-* 强弱验证器：描述的是一种对内容的更改“严不严重，影不影响主要含义”的实体标签验证！
-
-#### 缓存控制的能力
-
-* 缓存控制能力描述的是服务器可以通过设置相关首部来控制文档的缓存过期时间的能力！相关首部如：
-
-``` 
-	Cache-Control: no-store //不能缓存
-	
-	Cache-Control: no-cache //在没有对服务器验证之前不能提供内容
-	
-	Cache-Control: must-revalidate //严格遵守新鲜验证规则
-	
-	Cache-Control: max-age //设置多长时间的过期时间（相对时间）
-	
-	Expires: <date> //设置多长的过期时间（绝对时间）
-	
-	（试探性过期）不设置首部，让缓存来决定，这个方式涉及到一种算法，比如缓存服务器通过查看最后修改时间，从而得到该文档的修改频繁度，从而为其设置缓存过期时间
-
-```
-
-上面的优先级从上到下依次降低。
-
-
-* 客户端的新鲜度限制：Web浏览器都有Refresh（刷新）或Reload(重载)按钮，可以强制对浏览器或代理缓存中可能过期的内容进行刷新。Refresh按钮会发布一个附加了Cache-Control请求首部的GET请求，这个请求会强制进行再验证，或者无条件地从服务器获取文档。Refresh的确切行为取决于特定的浏览器、文档以及拦截缓存的配置。客户端可以用Cache-Control请求首部来强化或放松对过期时间的限制，先关首部介绍如下：
-
-```
-	Cache-Control请求指令
-
-	指令 							 					目的
-
-	Cache-Control: max-stale  				缓存可以随意提供过期的文件。如果指定了参数<s>，在这段
-	Cache-Control: max-stale = <s> 			时间内，文档就不能过期，这条指令放松了缓存的规则
-	
-	Cache-Control: min-fresh=<s>   			至少在未来<s>秒内文档要保持新鲜。这就使缓存规则更加严格了
-	
-	Cache-Control: max-age = <s> 			缓存无法返回缓存时间长于<s>秒的文档。这条指令会使得缓存规则更加
-											严格，除非同时还发送了max-stale指令，在这种情况下，使用期可能会
-											超过其过期时间
-
-	Cache-Control: no-cache 				除非资源进行了再验证，否则这个客户端不会接受已缓存的
-	Pragma: no-cache 						资源
-
-	Cache-Control: no-store 				缓存应该尽快从存储器中删除文档的所有痕迹，因为其中可能会包含敏感信息
-
-	Cache-Control: only-if-cached 			只有当缓存中有副本存在时，客户端才会获取一份副本
-```
-
-#### 设置缓存控制
-
-* 控制Apache的HTTP首部：默认没有开启，需要用到相关模块。如：
-
-- - mod_headers:加载之后就能对相关首部进行配置了，如：
-
-```
-	<Files *.html>
-		Header set Cache-control no-cache
-	</Files>
-```
-
-- - mod_expires:mod_expires模块提供的程序逻辑可以自动生成带有正确过期日期的Expires首部
-
-- - mod_cern_meta:略
-
-* 此外，客户端通过HTTP-EQUIV控制HTML缓存，但是值对html文件有用，这种方法并不是很好！
-
-#### 详细算法
-
-* 描述的与响应报文有关一些过期时间或使用时间的计算，详情请参看原书！
-
-#### 缓存广告
-
+### 内容提要
+
+* 本章主要从缓存的架构、优势、节省带宽流量、提升响应及处理步骤等方面阐述了web缓存！
+
+#### 使用缓存的优点
+
+* 缓存减少了冗余的数据传输，因为毕竟每次http事务请求的东西都是一样的时候，多次发送同样的数据是不必要和冗余的！
+
+* 缓存缓解了网络瓶颈的问题，不需要更多的带宽就能够更快地加载页面！
+
+* 缓存降低了对原始服务器的要求，因为想象一下，从一个性能很差劲的原始服务器和从一个性能和牛逼的缓存服务器请求事务，肯定会弥补服务器的缺点的，同时也会减少服务器过载情况，因为大部分请求都由缓存代劳处理了！
+
+* 缓存降低了距离时延，因为从较远的地方加载页面会更慢一些！
+
+####　冗余的数据传输
+
+* 每次都从原始服务器拿数据，那么带来的后果就是：多次发送重复的数据浪费流量、耗费昂贵的网络带宽从而降低传输速率、加大服务器的负载。而有了缓存之后这些问题都可以迎刃而解！
+
+#### 带宽瓶颈
+
+* 带宽瓶颈说明的问题：很多网络为本地客户端配置的带宽要比远程服务器配置的带宽要宽，如果在这种状况下客户端去请求远程服务器，那么客户端将会以一种的较低的速度去请求服务端，从而没有发挥出客户端带宽宽的长处！如果在客户端方向配置一个高速缓存服务器，那么就可以很快的得到响应，由此也看出带宽对报文传输速率的影响！
+
+
+####　瞬间拥塞
+
+* 瞬间拥塞描述的是这样一种情况：一个爆炸性的新闻和热点事件，如果再没有配置缓存的情况下，那么在短时间之内，服务器将会收到突变的请求增长，负荷会爆炸性增长，肯定会吃不消的！但是有了缓存，可以大大分担服务器的负载数量！
+
+
+#### 距离时延
+
+* 距离时延说明的一个问题就是传输数据过程这个过程是需要时间的，而且路程越长，那么需要的时间也会越多，即时延越长。所以在距离客户端较近的地方部署缓存服务器，减小了传输路程，那么就减小了传输时延！
+
+#### 命中与未命中的
+
+* *缓存命中与缓存未命中：*一次http事务请求如果是从得到的响应是从缓存得到的原始响应副本，那么这样的过程就称之为缓存命中。反之，如果缓存没有响应的副本，而要去请求原始服务，那么就把这个过程称之为缓存未命中！
+
+* *http再验证:*原始响应内容是在变化的，所以缓存应该在文档“过期时间”之后去验证缓存的副本是不是新鲜的，这个过程就叫做http再验证！如果再验证之后得知缓存副本是新鲜的，那么原始服务器返回304 not modified。此时，称之为*再验证命中*或*缓存慢命中*！如果得知缓存不是新鲜的，那么服务器返回200 ok。此时，称之为*再验证未命中*！如果原始对象已经被删除了，返回404 not found响应。相应地缓存副本要删除。（注：虽然再验证命中需要跟原始服务器沟通一次，但是它与直接请求服务器相比，还是要快一点，因为再验证命中只是返回了一些新的过期时间有关的新首部而已，并没有发送主体对象。）
+
+
+* *命中率*指由缓存返回副本事务在全部事务中所占的比例，称为缓存命中率。这个数据实际中意义不是很大！而*字节命中率*从资源大小总量的角度说明缓存命中所占的比例。因为他从数据流量的角度出发，所以实际中这个数据的意义挺大的！
+
+* *区分命中和未命中*，简单来说，http没有相应的机制来告知客户端响应是从缓存得到的还是从原始服务器得到的！但我们可以从http响应报文首部中的date字段得知这一情况：如果这个字段的时间比当前时间更早得多，说明这是从缓存得到的，因为date描述的服务器第一次响应的时间，而缓存是不会对这个字段进行修改的！
+
+
+#### 缓存的拓扑结构
+
+* 缓存分为私有缓存（只为一个客户端服务，比如我们给浏览器配置的代理）和共有缓存（为多个客户端服务，现实中是以代理缓存服务器的形式踹出现）。
+
+* 代理缓存的层级结构：此种结构描述的以父、子层级出现的层次结构，同时离客户端越近的子缓存的命中率较低（较廉价），他们可以把请求上升到父缓存（较昂贵），从而在父缓存那里实现事务处理！
+
+* *代理缓存的网状结构*描述的缓存结构并不是很明显呈现父子关系的结构，而是呈无规则的网状！这种结构的思想就是子缓存可以动态选择上一级缓存，从而实现更灵活的缓存控制！
+
+#### 缓存的处理步骤
+
+* 简单概括，即：
+
+``` bash
+	接收————解析————查询————新鲜度检测————创建响应————发送————记入日志
+
+```
+
+* 第一步接收：读取网络连接http请求报文
+
+* 第二部解析：把报文解析为片段，并把首部放入到缓存易操作的数据结构中
+
+* 第三步查询：查找存下来缓存副本
+
+* 第四步新鲜度检测：说白了检查缓存副本是不是还有效的
+
+* 第五步创建响应：缓存服务器用原始服务器的缓存副本实现响应的起点，同时再在此基础上做一些修改，比如协议转换等
+
+* 第六步发送：发送报文
+
+* 第七步日志：事务完成之后，在日志文件插入一个条目，用以记录缓存处理情况，以及记录一些与缓存命中率的数据
+
+
+#### 保持副本的新鲜
+
+* *文档过期*通过特殊的http首部cache-control和expires,http让原始服务器为每个文档设置一个“过期时间”！如：
+
+``` bash
+	
+	Cache-Control: Max-Age=484200
+	Expires: Fri, 28 Oct 2016 03:03:47 GMT
+	
+```
+
+上面的Max-Age是相对时间，以秒为单位，理解为使用期，expires为绝对时间，为到期时间。
+
+* 服务器在验证，描述的过期的文档并不是就是原始服务器的原始文档不一样了，而是需要向服务器发起新鲜度验证请求。
+
+* 用条件方法进行再验证：涉及到的两个首部为If-Modified-Since和If-None-Match。格式为：
+
+``` bash
+
+	If-Modified-Since: <date>
+
+```
+实际上上面那个date为服务器响应报文里面Last-Modified的时间。
+
+* If-None-Match:实体标签再验证！此种机制主要跟If-Modified-Since不同在于：If-Modified-Since是根据修改时间来判断文档新鲜度的，但有些情况这样做是不适用的，因为比如我们只是加了注释什么的，其中实际内容是没有变化的，此时我们也应该认为文档是新鲜的！
+
+* 强弱验证器：描述的是一种对内容的更改“严不严重，影不影响主要含义”的实体标签验证！
+
+#### 缓存控制的能力
+
+* 缓存控制能力描述的是服务器可以通过设置相关首部来控制文档的缓存过期时间的能力！相关首部如：
+
+``` 
+	Cache-Control: no-store //不能缓存
+	
+	Cache-Control: no-cache //在没有对服务器验证之前不能提供内容
+	
+	Cache-Control: must-revalidate //严格遵守新鲜验证规则
+	
+	Cache-Control: max-age //设置多长时间的过期时间（相对时间）
+	
+	Expires: <date> //设置多长的过期时间（绝对时间）
+	
+	（试探性过期）不设置首部，让缓存来决定，这个方式涉及到一种算法，比如缓存服务器通过查看最后修改时间，从而得到该文档的修改频繁度，从而为其设置缓存过期时间
+
+```
+
+上面的优先级从上到下依次降低。
+
+
+* 客户端的新鲜度限制：Web浏览器都有Refresh（刷新）或Reload(重载)按钮，可以强制对浏览器或代理缓存中可能过期的内容进行刷新。Refresh按钮会发布一个附加了Cache-Control请求首部的GET请求，这个请求会强制进行再验证，或者无条件地从服务器获取文档。Refresh的确切行为取决于特定的浏览器、文档以及拦截缓存的配置。客户端可以用Cache-Control请求首部来强化或放松对过期时间的限制，先关首部介绍如下：
+
+```
+	Cache-Control请求指令
+
+	指令 							 					目的
+
+	Cache-Control: max-stale  				缓存可以随意提供过期的文件。如果指定了参数<s>，在这段
+	Cache-Control: max-stale = <s> 			时间内，文档就不能过期，这条指令放松了缓存的规则
+	
+	Cache-Control: min-fresh=<s>   			至少在未来<s>秒内文档要保持新鲜。这就使缓存规则更加严格了
+	
+	Cache-Control: max-age = <s> 			缓存无法返回缓存时间长于<s>秒的文档。这条指令会使得缓存规则更加
+											严格，除非同时还发送了max-stale指令，在这种情况下，使用期可能会
+											超过其过期时间
+
+	Cache-Control: no-cache 				除非资源进行了再验证，否则这个客户端不会接受已缓存的
+	Pragma: no-cache 						资源
+
+	Cache-Control: no-store 				缓存应该尽快从存储器中删除文档的所有痕迹，因为其中可能会包含敏感信息
+
+	Cache-Control: only-if-cached 			只有当缓存中有副本存在时，客户端才会获取一份副本
+```
+
+#### 设置缓存控制
+
+* 控制Apache的HTTP首部：默认没有开启，需要用到相关模块。如：
+
+- - mod_headers:加载之后就能对相关首部进行配置了，如：
+
+```
+	<Files *.html>
+		Header set Cache-control no-cache
+	</Files>
+```
+
+- - mod_expires:mod_expires模块提供的程序逻辑可以自动生成带有正确过期日期的Expires首部
+
+- - mod_cern_meta:略
+
+* 此外，客户端通过HTTP-EQUIV控制HTML缓存，但是值对html文件有用，这种方法并不是很好！
+
+#### 详细算法
+
+* 描述的与响应报文有关一些过期时间或使用时间的计算，详情请参看原书！
+
+#### 缓存广告
+
 * 因为缓存的存在，导致某些靠用户点击次数收费的广告的请求未达到原始服务，从而服务器很难对用户进行了多少次点击进行计数！一种解决方案就是配置缓存，每次访问时都与原始服务器进行再验证。这样，每次访问时都会将命中推向原始服务器，但通常不会传送任何主体数据。当然，这样会降低事务处理的速度。
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/08 \351\233\206\346\210\220\347\202\271\357\274\232\347\275\221\345\205\263\343\200\201\351\232\247\351\201\223\345\217\212\344\270\255\347\273\247.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/08 \351\233\206\346\210\220\347\202\271\357\274\232\347\275\221\345\205\263\343\200\201\351\232\247\351\201\223\345\217\212\344\270\255\347\273\247.md"
similarity index 97%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/08 \351\233\206\346\210\220\347\202\271\357\274\232\347\275\221\345\205\263\343\200\201\351\232\247\351\201\223\345\217\212\344\270\255\347\273\247.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/08 \351\233\206\346\210\220\347\202\271\357\274\232\347\275\221\345\205\263\343\200\201\351\232\247\351\201\223\345\217\212\344\270\255\347\273\247.md"
index e3f9d6ae..186f5e4b 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/08 \351\233\206\346\210\220\347\202\271\357\274\232\347\275\221\345\205\263\343\200\201\351\232\247\351\201\223\345\217\212\344\270\255\347\273\247.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/08 \351\233\206\346\210\220\347\202\271\357\274\232\347\275\221\345\205\263\343\200\201\351\232\247\351\201\223\345\217\212\344\270\255\347\273\247.md"	
@@ -1,76 +1,76 @@
-### 内容提要
-
-* 本章主要讲解了：
-
->> http和其他协议及应用程序之间起到接口作用的网关；
-
->> 允许不同类型的web应用程序互相通信的应用程序接口；
-
->> 允许用户在http连接上发送非http流量的隧道；
-
->> 作为一种简化的http代理，一次将数据转发一跳的中继。
-
-#### 网关
-
-* 网络上的资源种类越来越复杂，单一的应用程序是无法处理这些能想到的资源的，所以才有了网关的概念，网关抽象出了一种能达到资源的方法，从而实现这样一种机制：客户端发送http请求，请求到达服务器端应用程序，应用程序向网关转发请求，网关处理请求并返回响应。其中网关充当了一种“翻译器”的功能，使得http能请求其他非http协议的资源！
-
-##### 客户端和服务器端网关
-
-* web网关描述了客户端和服务器端使用了不同的协议，使用下面的表示方法来表示：
-
-``` javascript
-	<客户端协议>/<服务器端协议>
-```
-
-
-* *客户端网关*和*服务器端网关*描述的是说明对话是在那一侧进行的。*客户端网关*是用其他协议来和客户端对话，用http协议来和服务器端通信；*服务器端网关*是用其他协议来和服务器端对话，用http协议来和客户端通信。
-
-
-####　协议网关
-
-* 协议网关主要描述了几种架构在客户端和服务器端之间的网关，它们两侧使用了不同的协议来达到通信的目的，主要有：HTTP/*（服务器端web网关）、HTTP/HTTPS（服务器端安全网关）、HTTPS/HTTP（客户端安全网关加速器）。这里主要以HTTP/FTP为例讲解一次http请求在经过FTP网关时网关会去做什么事：
-
->> 1、发送USER和PASS命令登录到服务器上去；
-
->> 2、发布CWD命令，转移到服务器上合适的目录中去；
-
->> 3、将下载类型设置ASCII;
-
->> 4、用MDTM获取文档的最后修改时间；
-
->> 5、用PASV告诉服务器将有被动数据获取请求到达；
-
->> 6、用RETR请求进行对象获取；
-
->> 7、打开到FTP服务器的数据连接，服务器端口由控制信道返回；一旦数据信道打开了，就将对象内容回送给网关。
-
-
-#### 资源网关
-
-* 协议网关描述的是通过网络连接客户端和服务器的网关，而最常见的网关，应用程序服务器，会将目标服务器与网关结合在一个服务器中实现。应用程序服务器是服务器端网关，与客户端通过HTTP进行通信，并与服务器端的应用程序相连。相关概念CGI(Common Programming Interface)和API(Application Programming Interface)
-
-#### 应用程序接口和web服务
-
-* 略
-
-#### 隧道
-
-* Web隧道允许用户通过HTTP连接发送非HTTP流量，这样就可以在HTTP上捎带其他协议数据了。使用Web隧道最常见的原因就是要在HTTP连接中嵌入HTTP流量，这样，这类流量就可以穿过只允许Web流量通过的防火墙了。
-
-* Web隧道使用HTTP的CONNECT方法建立起来的。 CONNECT方法并不是HTTP/1.1核心规范的一部分，但却是一种得到广泛应用的扩展。
-
-* CONNECT连接：除了起始行之外，CONNECT的语法与其他HTTP方法类似。一个后面跟着冒号和端口号的主机名取代了请求URL.主机和端口都比如指定：
-
-```
-	请求
-	CONNECT home.netscape.com:443 HTTP/1.0
-	User-Agent:Mozilla/4.0
-
-	响应
-	HTTP/1.0 200 Connection Established
-	Proxy-agent:Netscape-Proxy/1.1
-```
-
-#### 中继
-
+### 内容提要
+
+* 本章主要讲解了：
+
+>> http和其他协议及应用程序之间起到接口作用的网关；
+
+>> 允许不同类型的web应用程序互相通信的应用程序接口；
+
+>> 允许用户在http连接上发送非http流量的隧道；
+
+>> 作为一种简化的http代理，一次将数据转发一跳的中继。
+
+#### 网关
+
+* 网络上的资源种类越来越复杂，单一的应用程序是无法处理这些能想到的资源的，所以才有了网关的概念，网关抽象出了一种能达到资源的方法，从而实现这样一种机制：客户端发送http请求，请求到达服务器端应用程序，应用程序向网关转发请求，网关处理请求并返回响应。其中网关充当了一种“翻译器”的功能，使得http能请求其他非http协议的资源！
+
+##### 客户端和服务器端网关
+
+* web网关描述了客户端和服务器端使用了不同的协议，使用下面的表示方法来表示：
+
+``` javascript
+	<客户端协议>/<服务器端协议>
+```
+
+
+* *客户端网关*和*服务器端网关*描述的是说明对话是在那一侧进行的。*客户端网关*是用其他协议来和客户端对话，用http协议来和服务器端通信；*服务器端网关*是用其他协议来和服务器端对话，用http协议来和客户端通信。
+
+
+####　协议网关
+
+* 协议网关主要描述了几种架构在客户端和服务器端之间的网关，它们两侧使用了不同的协议来达到通信的目的，主要有：HTTP/*（服务器端web网关）、HTTP/HTTPS（服务器端安全网关）、HTTPS/HTTP（客户端安全网关加速器）。这里主要以HTTP/FTP为例讲解一次http请求在经过FTP网关时网关会去做什么事：
+
+>> 1、发送USER和PASS命令登录到服务器上去；
+
+>> 2、发布CWD命令，转移到服务器上合适的目录中去；
+
+>> 3、将下载类型设置ASCII;
+
+>> 4、用MDTM获取文档的最后修改时间；
+
+>> 5、用PASV告诉服务器将有被动数据获取请求到达；
+
+>> 6、用RETR请求进行对象获取；
+
+>> 7、打开到FTP服务器的数据连接，服务器端口由控制信道返回；一旦数据信道打开了，就将对象内容回送给网关。
+
+
+#### 资源网关
+
+* 协议网关描述的是通过网络连接客户端和服务器的网关，而最常见的网关，应用程序服务器，会将目标服务器与网关结合在一个服务器中实现。应用程序服务器是服务器端网关，与客户端通过HTTP进行通信，并与服务器端的应用程序相连。相关概念CGI(Common Programming Interface)和API(Application Programming Interface)
+
+#### 应用程序接口和web服务
+
+* 略
+
+#### 隧道
+
+* Web隧道允许用户通过HTTP连接发送非HTTP流量，这样就可以在HTTP上捎带其他协议数据了。使用Web隧道最常见的原因就是要在HTTP连接中嵌入HTTP流量，这样，这类流量就可以穿过只允许Web流量通过的防火墙了。
+
+* Web隧道使用HTTP的CONNECT方法建立起来的。 CONNECT方法并不是HTTP/1.1核心规范的一部分，但却是一种得到广泛应用的扩展。
+
+* CONNECT连接：除了起始行之外，CONNECT的语法与其他HTTP方法类似。一个后面跟着冒号和端口号的主机名取代了请求URL.主机和端口都比如指定：
+
+```
+	请求
+	CONNECT home.netscape.com:443 HTTP/1.0
+	User-Agent:Mozilla/4.0
+
+	响应
+	HTTP/1.0 200 Connection Established
+	Proxy-agent:Netscape-Proxy/1.1
+```
+
+#### 中继
+
 * HTTP中继是没有完全遵循HTTP规范的简单HTTP代理。中继负责处理HTTP中建立连接的部分，然后对字节进行盲转发！
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/09 Web\346\234\272\345\231\250\344\272\272.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/09 Web\346\234\272\345\231\250\344\272\272.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/09 Web\346\234\272\345\231\250\344\272\272.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/09 Web\346\234\272\345\231\250\344\272\272.md"
index 2e11bbfd..bedf4e71 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/09 Web\346\234\272\345\231\250\344\272\272.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/09 Web\346\234\272\345\231\250\344\272\272.md"	
@@ -1,121 +1,121 @@
-### 内容提要
-
-* 本章主要讲解了web机器人一些原理和介绍，以及怎样控制机器人的访问和业界的一些关于跟踪机器人的规范，最后需要理解的一点就是机器人跟我们客户端一样遵守http规范，它是某种形式上的客户端。
-
-#### 概念
-
-* Web机器人是能够在无需人类干预的情况下自动进行一系列Web事务处理的软件程序。人们根据这些机器人探查web站点的方式，形象的给它们取了一个饱含特色的名字，比如“爬虫”、“蜘蛛”、“蠕虫”以及“机器人”等！
-
-#### 爬虫及爬行方式
-
-* “爬虫”主要采取的爬行方式是获取第一个web页面，然后递归地对各种信息性web站点进行遍历，从而获取相关页面。搜索引擎的爬虫是一些复杂的爬虫，因为他们不仅会爬行web页面，而且会把相关数据拉取回来建立数据库，方便用户搜索！
-
-1. 爬虫会从根集开始爬行
-
-2. 爬虫会解析页面所有的url，并把它们转换绝对形式
-
-3. 要避免环路的出现，因为这些环路会暂停或减缓机器人的爬行过程
-
-* 环路对爬虫有害的三个原因：
-
-1. 爬虫会陷入循环之中，从而兜圈子，浪费带宽，无法获取新页面！
-
-2. 爬虫无限的请求服务器，从而阻塞了真正的用户去请求服务器，这是可以作为法律诉讼理由的！
-
-3. 爬虫服务器会被重复的数据充斥
-
-* 网络中两个url表面上看起来不一样，但是指向的是同一资源，那么这两个url就互相称为“别名”，由于别名问题的存在，所以爬虫会爬行重复的数据，所以爬虫有必要把url的进行规范化！从而解决相关数据重复问题。相关规范方法如：没有端口默认为80，把字符转义为等价字符，删除#标签等。
-
-#### 如何避免环路与重复
-
-* 规范化URL：将URL转换为标准形式以避免语法上的别名
-
-* 广度优先的爬行：每次爬虫都有大量潜在的URL要去爬行，如果实行广度URL优先爬行，那么即时碰到环路，机器人也可以回到环路中获取的下一个页面之前，如果采用深度优先方式，那么机器人很容易陷入环路，越陷越深。
-
-* 节流：限制一段时间内机器人可以从一个web站点获取的页面数量。通过节流来限制重复的页面总数和对服务器的访问总数。
-
-* 限制URL的大小：机器人可能会拒绝爬行超出特定长度（通常是1KB）的URL。如果环路使URL的长度增加，长度限制就会最终终止这个环路。但要小心，用此种技术肯定会让你错过一些内容，因为现在很多url都绑定了很多状态信息，所以一般情况下，它们长度都会很长。
-
-* URL/站点黑名单：维护一个与机器人环路和陷阱相对应的已知站点及URL列表，然后像躲避瘟疫一样避开它们。发现新问题时，就将其加入黑名单。
-
-* 模式检测：文件系统的符号连接和类似的错误配置所造成的环路会遵循某种模式，比如，URL会随着组件的复制逐渐增加。有些机器人会将具有重复组件的URL当作潜在的环路，拒绝爬行带有多于两或三个重复组件的URL。如形如“/dir/dir/dir...”格式的URL，那么机器人就怀疑它是潜在的环路，从而拒绝爬行。
-
-* 内容指纹：说白了就是机器人对曾经爬行过的内容进行计算从而算出一个校验和，那么继续爬行其他页面时候，如果发现其它页面的“校验和”和前面算的相等，那么机器人就认为此内容已经获取过了，不需要进行重新获取。
-
-* 人工监视：如题，人工检测，因为设计再好的机器人总是会陷入环路不能出来的时候，那么就需要人工进行干预，比如收集日志什么的。
-
-
-#### 机器人的HTTP
-
-* 相关首部
-
->> User-Agent ：机器人名字
-
->> From ：提供机器人管理者的E-mail地址
-
->> Accept : 告知服务器可以发送那些媒体类型
-
->> Referer ：提供包含了当前请求的URL的文档的URL
-
-* 虚拟主机需要爬虫带Host首部，要不然会返回错误主机的数据
-
-* 让爬虫使用条件请求是有意义的，因为有的数据内容没有改变，所以重复抓取是浪费空间的，只有在内容实际改变的时候才重新发起请求，即条件请求。
-
-#### 行为不当的机器人
-
-* 失控的机器人，比正常用户的请求速度快很多，当这类爬虫设计出现错误的时候，很容易短时间之内增加服务器的负载，阻止真正用户的访问，原因诸如：编程逻辑错误、陷入环路之中
-
-* 失效的url，url可能已经失效了，但是爬虫依然取请求它 ，这样会让服务器的日志文档里面增加了很多请求出错的记录。
-
-* 很长的错误url,同样请求这样一个url，会让服务器日志文档增加一个很杂论的出错记录
-
-* 爱打听的机器人，访问了一些管理者不允许访问的内容，涉及侵犯隐私
-
-* 动态网关访问
-
-
-#### 拒绝机器人访问
-
-* 通过一个叫robots.txt的文件来约束机器人的访问。它的思想就是指定那些部分机器人可以访问，那些部分机器人不能访问
-。如果机器人遵循这个自愿约束标准，那么在请求所有资源之前，它需要获取robots.txt并解析它。
-
-* 请求robots.txt时针对服务器返回的状态码，爬虫所作的动作：
-
->> 如果返回2xx代码，机器人就必须对内容进行解析，并使用排斥规则从那个站点上获取内容
-
->> 如果返回404，机器人认为服务器没有激活排斥规则，所以它不受限制
-
-
->> 如果返回401或403(访问限制)，表示机器人是完全受限的
-
->> 如果返回503（服务器临时故障），那么机器人暂时停止访问，知道正常之后继续请求robots.txt
-
->> 如果返回重定向代码，那么机器人也应该重定向到相关页面
-
-* robots.txt文件的格式：包括三种内容注释行、空行、规则行。如：
-
-``` javascript
-
-	# this robots.txt file allows Slurp & Webcrawler to crawl
-	# the public parts of our site,but no other robots...
-
-	User-Agent: slurp
-	User-Agent: webcraler
-	Disallow: /private
-
-	User-Agent: *
-	Disallow:
-
-```
-
-
-#### 简单聊一下搜索引擎
-
-* 搜索引擎是web机器人用得最多的领域
-
-* 最初开始的搜索引擎就是一个简单的数据，哪里维护者一个用户可能搜索的信息列表。但如今的搜索引擎确实一个相当复杂的数据库，存储有大量信息，用了很多爬虫去爬取数据。所以对用户来说，搜索引擎的检索信息的速度以及爬虫获取数据的速度是搜索引擎需要必须考虑的问题。
-
-* 全文检索就是一个数据库，给它一个单词，它可以立即提供包含那个单词的所有文档。创建了索引之后，就不需要对文档自身进行扫描了。
-
-* 搜索引擎都有自己的排序算法，如相关性排名算法，如某个单词在很多内容都出现了，那么它的相关度就很高，所有与此单词有关的内容都应该排在考前。当然了这样的索引差不多在爬虫去获取内容的时候就已经建立起这种索引了！
-
+### 内容提要
+
+* 本章主要讲解了web机器人一些原理和介绍，以及怎样控制机器人的访问和业界的一些关于跟踪机器人的规范，最后需要理解的一点就是机器人跟我们客户端一样遵守http规范，它是某种形式上的客户端。
+
+#### 概念
+
+* Web机器人是能够在无需人类干预的情况下自动进行一系列Web事务处理的软件程序。人们根据这些机器人探查web站点的方式，形象的给它们取了一个饱含特色的名字，比如“爬虫”、“蜘蛛”、“蠕虫”以及“机器人”等！
+
+#### 爬虫及爬行方式
+
+* “爬虫”主要采取的爬行方式是获取第一个web页面，然后递归地对各种信息性web站点进行遍历，从而获取相关页面。搜索引擎的爬虫是一些复杂的爬虫，因为他们不仅会爬行web页面，而且会把相关数据拉取回来建立数据库，方便用户搜索！
+
+1. 爬虫会从根集开始爬行
+
+2. 爬虫会解析页面所有的url，并把它们转换绝对形式
+
+3. 要避免环路的出现，因为这些环路会暂停或减缓机器人的爬行过程
+
+* 环路对爬虫有害的三个原因：
+
+1. 爬虫会陷入循环之中，从而兜圈子，浪费带宽，无法获取新页面！
+
+2. 爬虫无限的请求服务器，从而阻塞了真正的用户去请求服务器，这是可以作为法律诉讼理由的！
+
+3. 爬虫服务器会被重复的数据充斥
+
+* 网络中两个url表面上看起来不一样，但是指向的是同一资源，那么这两个url就互相称为“别名”，由于别名问题的存在，所以爬虫会爬行重复的数据，所以爬虫有必要把url的进行规范化！从而解决相关数据重复问题。相关规范方法如：没有端口默认为80，把字符转义为等价字符，删除#标签等。
+
+#### 如何避免环路与重复
+
+* 规范化URL：将URL转换为标准形式以避免语法上的别名
+
+* 广度优先的爬行：每次爬虫都有大量潜在的URL要去爬行，如果实行广度URL优先爬行，那么即时碰到环路，机器人也可以回到环路中获取的下一个页面之前，如果采用深度优先方式，那么机器人很容易陷入环路，越陷越深。
+
+* 节流：限制一段时间内机器人可以从一个web站点获取的页面数量。通过节流来限制重复的页面总数和对服务器的访问总数。
+
+* 限制URL的大小：机器人可能会拒绝爬行超出特定长度（通常是1KB）的URL。如果环路使URL的长度增加，长度限制就会最终终止这个环路。但要小心，用此种技术肯定会让你错过一些内容，因为现在很多url都绑定了很多状态信息，所以一般情况下，它们长度都会很长。
+
+* URL/站点黑名单：维护一个与机器人环路和陷阱相对应的已知站点及URL列表，然后像躲避瘟疫一样避开它们。发现新问题时，就将其加入黑名单。
+
+* 模式检测：文件系统的符号连接和类似的错误配置所造成的环路会遵循某种模式，比如，URL会随着组件的复制逐渐增加。有些机器人会将具有重复组件的URL当作潜在的环路，拒绝爬行带有多于两或三个重复组件的URL。如形如“/dir/dir/dir...”格式的URL，那么机器人就怀疑它是潜在的环路，从而拒绝爬行。
+
+* 内容指纹：说白了就是机器人对曾经爬行过的内容进行计算从而算出一个校验和，那么继续爬行其他页面时候，如果发现其它页面的“校验和”和前面算的相等，那么机器人就认为此内容已经获取过了，不需要进行重新获取。
+
+* 人工监视：如题，人工检测，因为设计再好的机器人总是会陷入环路不能出来的时候，那么就需要人工进行干预，比如收集日志什么的。
+
+
+#### 机器人的HTTP
+
+* 相关首部
+
+>> User-Agent ：机器人名字
+
+>> From ：提供机器人管理者的E-mail地址
+
+>> Accept : 告知服务器可以发送那些媒体类型
+
+>> Referer ：提供包含了当前请求的URL的文档的URL
+
+* 虚拟主机需要爬虫带Host首部，要不然会返回错误主机的数据
+
+* 让爬虫使用条件请求是有意义的，因为有的数据内容没有改变，所以重复抓取是浪费空间的，只有在内容实际改变的时候才重新发起请求，即条件请求。
+
+#### 行为不当的机器人
+
+* 失控的机器人，比正常用户的请求速度快很多，当这类爬虫设计出现错误的时候，很容易短时间之内增加服务器的负载，阻止真正用户的访问，原因诸如：编程逻辑错误、陷入环路之中
+
+* 失效的url，url可能已经失效了，但是爬虫依然取请求它 ，这样会让服务器的日志文档里面增加了很多请求出错的记录。
+
+* 很长的错误url,同样请求这样一个url，会让服务器日志文档增加一个很杂论的出错记录
+
+* 爱打听的机器人，访问了一些管理者不允许访问的内容，涉及侵犯隐私
+
+* 动态网关访问
+
+
+#### 拒绝机器人访问
+
+* 通过一个叫robots.txt的文件来约束机器人的访问。它的思想就是指定那些部分机器人可以访问，那些部分机器人不能访问
+。如果机器人遵循这个自愿约束标准，那么在请求所有资源之前，它需要获取robots.txt并解析它。
+
+* 请求robots.txt时针对服务器返回的状态码，爬虫所作的动作：
+
+>> 如果返回2xx代码，机器人就必须对内容进行解析，并使用排斥规则从那个站点上获取内容
+
+>> 如果返回404，机器人认为服务器没有激活排斥规则，所以它不受限制
+
+
+>> 如果返回401或403(访问限制)，表示机器人是完全受限的
+
+>> 如果返回503（服务器临时故障），那么机器人暂时停止访问，知道正常之后继续请求robots.txt
+
+>> 如果返回重定向代码，那么机器人也应该重定向到相关页面
+
+* robots.txt文件的格式：包括三种内容注释行、空行、规则行。如：
+
+``` javascript
+
+	# this robots.txt file allows Slurp & Webcrawler to crawl
+	# the public parts of our site,but no other robots...
+
+	User-Agent: slurp
+	User-Agent: webcraler
+	Disallow: /private
+
+	User-Agent: *
+	Disallow:
+
+```
+
+
+#### 简单聊一下搜索引擎
+
+* 搜索引擎是web机器人用得最多的领域
+
+* 最初开始的搜索引擎就是一个简单的数据，哪里维护者一个用户可能搜索的信息列表。但如今的搜索引擎确实一个相当复杂的数据库，存储有大量信息，用了很多爬虫去爬取数据。所以对用户来说，搜索引擎的检索信息的速度以及爬虫获取数据的速度是搜索引擎需要必须考虑的问题。
+
+* 全文检索就是一个数据库，给它一个单词，它可以立即提供包含那个单词的所有文档。创建了索引之后，就不需要对文档自身进行扫描了。
+
+* 搜索引擎都有自己的排序算法，如相关性排名算法，如某个单词在很多内容都出现了，那么它的相关度就很高，所有与此单词有关的内容都应该排在考前。当然了这样的索引差不多在爬虫去获取内容的时候就已经建立起这种索引了！
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/10 HTTP-NG.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/10 HTTP-NG.md"
similarity index 95%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/10 HTTP-NG.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/10 HTTP-NG.md"
index 65069446..6cb8a8fc 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/10 HTTP-NG.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/10 HTTP-NG.md"	
@@ -1,50 +1,50 @@
-### 内容提要
-
-* 本章简要介绍了当前http协议的一些局限和不足的地方，并由此引出了正在研讨和优化的版本http-ng协议！
-
-#### http发展中存在的问题
-
-1、http相当复杂，由此实现http软件是相当复杂的
-
-2、扩展性不好
-
-3、性能不好，有些造成时延较大
-
-4、传输依赖性，http是依赖于tcp/ip协议的
-
-#### HTTP-NG的活动
-
-* http-ng的出现正式为了修正http存在的复杂性高、可扩展性差、性能不好、传输依赖性等问题！虽然这个版本尚未被广泛使用（也有可能永远不使用）。
-
-* http-ng主要有一下几个特点：
-
->> 模块化及功能增强
-
->> 相关报文模块采用分层设计，更利于扩展（主要有三层：Web应用功能、远程操作调用、报文传输）
-
-#### 分布式对象
-
-* 略
-
-#### 第一层————报文传输
-
-* 该层关心报文的安全传输
-
-#### 第二层————远程调用
-
-* 实现远程调用服务器的接口
-
-#### 第三层————Web应用
-
-* 该层是执行语义和应用程序特定逻辑的地方
-
-#### WebMUX
-
-* 略
-
-####　当前的状态
-
-* 指出http-ng替换http还为时尚早
-
-
-
+### 内容提要
+
+* 本章简要介绍了当前http协议的一些局限和不足的地方，并由此引出了正在研讨和优化的版本http-ng协议！
+
+#### http发展中存在的问题
+
+1、http相当复杂，由此实现http软件是相当复杂的
+
+2、扩展性不好
+
+3、性能不好，有些造成时延较大
+
+4、传输依赖性，http是依赖于tcp/ip协议的
+
+#### HTTP-NG的活动
+
+* http-ng的出现正式为了修正http存在的复杂性高、可扩展性差、性能不好、传输依赖性等问题！虽然这个版本尚未被广泛使用（也有可能永远不使用）。
+
+* http-ng主要有一下几个特点：
+
+>> 模块化及功能增强
+
+>> 相关报文模块采用分层设计，更利于扩展（主要有三层：Web应用功能、远程操作调用、报文传输）
+
+#### 分布式对象
+
+* 略
+
+#### 第一层————报文传输
+
+* 该层关心报文的安全传输
+
+#### 第二层————远程调用
+
+* 实现远程调用服务器的接口
+
+#### 第三层————Web应用
+
+* 该层是执行语义和应用程序特定逻辑的地方
+
+#### WebMUX
+
+* 略
+
+####　当前的状态
+
+* 指出http-ng替换http还为时尚早
+
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/11 \345\256\242\346\210\267\347\253\257\350\257\206\345\210\253\344\270\216Cookie\346\234\272\345\210\266.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/11 \345\256\242\346\210\267\347\253\257\350\257\206\345\210\253\344\270\216Cookie\346\234\272\345\210\266.md"
similarity index 97%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/11 \345\256\242\346\210\267\347\253\257\350\257\206\345\210\253\344\270\216Cookie\346\234\272\345\210\266.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/11 \345\256\242\346\210\267\347\253\257\350\257\206\345\210\253\344\270\216Cookie\346\234\272\345\210\266.md"
index 6e8800aa..de5c5362 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/11 \345\256\242\346\210\267\347\253\257\350\257\206\345\210\253\344\270\216Cookie\346\234\272\345\210\266.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/11 \345\256\242\346\210\267\347\253\257\350\257\206\345\210\253\344\270\216Cookie\346\234\272\345\210\266.md"	
@@ -1,138 +1,138 @@
-## 内容提要
-
-* 本章介绍了http验证用户的一种机制————cookie,以及cookie的一些概念细节！
-
-### 外在原因
-
-* http最初是一个匿名、无状态的请求/响应协议。服务器处理来自客户端的请求，然后向客户端回送一条响应。web服务器几乎没有什么信息可以用来判定是哪个用户发送的请求，也无法记录来访用户的请求序列。
-
-### 能解决的问题
-
-* 以在线商店为例讲解有了http有了验证身份的机制之后可以实现那些功能，（当然没有这个机制的情况下也可以实现，但是可能会传很多参数来保证身份信息）：
-
-1、个性化的问候
-
-2、有的放矢的推荐
-
-3、管理信息的存档
-
-4、记录会话
-
-#### http报文中承载用户信息的首部
-
-1、From:用户的E-mail地址
-
-2、User-Agent:用户代理或爬虫标记
-
-3、Referer:当前页面是从那个页面跳过来的
-
-4、Authoriztion:用户的用户名和密码
-
-5、Client-IP : 扩展（请求）
-
-6、X-Forwarded-For : 扩展（请求）
-
-7、Cookie:扩展（请求）
-
-
-#### 客户端IP地址
-
-* 早起的web曾以客户端的ip地址信息来作为验证用户的身份机制，但存在很多缺点，如：
-
-1、首先ip标记是客户端机器，而不是用户，也就是说多个用户公用一台机器，是无法识别的！
-
-2、很多ip地址是动态的，所以不能在一次会话之间用ip地址来验证一个用户信息
-
-3、使用代理的时候，此时发送的ip地址是代理的ip地址，而不是用户的ip地址，虽然代理可以加一个首部来保证最初的ip地址信息，但是不兼容
-
-4、ip地址很容伪造，所以不安全
-
-
-#### 用户登录
-
-* 这种方法的主要原理就是：在初始访问的时候，服务器返回报文并添加WWW-Authorization首部，用以弹出一个窗口要求用户填写用户名和密码等信息！客户端在下次访问的时候就可以传送带有Authorization的首部，并把相关身份信息传输过去以此验证用户信息，以后的每次请求都会带上这个首部！
-
-#### 胖URL
-
-* 把用户信息添加进url的url称为胖url，以此来验证用户身份，但这种机制有以下缺点：
-
-1、丑陋的url
-
-2、无法共享url,因为用户信息在url里面，共享url同时也会把用户信息共享出去了
-
-3、破坏缓存
-
-4、额外的服务器负荷
-
-5、逃逸口，很容易造成用户不小心跳到另一个网站，返回过来的收用户的信息全部没了，比如购物车里面的东西全部没了
-
-6、会话是非持久的
-
-#### Cookie
-
-* 分类：会话Cookie（非持久Cookie）和持久Cookie
-
-* 原理：用户第一次请求服务器时，服务器返回一个带Set-Cookie（Set-Cookie1）首部的报文，值为键值对，描述了cookie的名字、值、域、路径等信息，然后客户端接下来每次访问服务器的时候都会带上一个Cookie首部的报文，它的值刚好是前面响应报文返回的名字键值对，从而达到验证用户身份的信息。
-
-#### Cookie的属性
-
-* domain : cookie的域
-
-* allh : 那些主机可以使用此cookie
-
-* path ：那些路径能使用cookie
-
-* secure : 是否在发送https报文的时候使用cookie
-
-* expires ： 过期时间
-
-* name ： cookie的名字
-
-* value : cookie的值
-
-#### 不同站点使用不同的cookie
-
- 
- * cookie不能任意使用，只能在它自己设定的域、主机、路径里面使用
-
-#### cookie版本
-
- * cookie机制有个两个版本，一个是网景公司主导的“版本0”，主要是服务器返回“Set-Cookie”首部，而客户端请求发送“Cookie”首部，客户端发送请求时，会将所有与域、路径和安全过滤器相匹配的未过期cookie都发送给这个站点。所有cookie都被组合到一个Cookie首部中，如：
-
- ``` 
- 		Cookie: session-id=002-1145265-8016938; session-id-time=1311313313131
- ```
-
- cookie机制还有一个版本就是RFC 2965定义的一个cookie的扩展版本。这个版本1标准引入了Set-Cookie2首部和Cookie2首部，但它也能与“版本0”系统进行互操作。“版本1”跟“版本0”的区别就是，提供了更多的属性来描述一个cookie,同时服务器端发送的是“Set-Cookie”首部，而客户端发送的是“Cookie”首部，如：
-
- ```
- 		服务器端
- 	 	Set-Cookie2: ID="29046"; Domain=".joes-hardware.com"
- 	 	Set-Cookie2: color=blue
- 	 	Set-Cookie2: support-pref="L2"; Domain="customer-care.joes-hardware.com"
- 	 	Set-Cookie2: Coupon="hammer027"; Version="1"; Path="/tools"
- 	 	Set-Cookie2: Coupon="handvac103"; Version="1";Path="/tools/cordless"
-
- 	 	客户端
- 	 	Cookie: $Version="1";
- 	 			ID="29046"; $Domain=".joes-hardware.com";
- 	 			color="blue";
- 	 			Coupon="hammer027"; $Path="/tools";
- 	 			Coupon="handvac103"; $Path="/tools/cordless"
- ```
-
-另外Cookie2首部是用来沟通支持版本0和版本1的服务器的，它会发送当前客户端支持的最新版本cookie版本，如：
-
-```
-		Cookie2: $Version="1"
-```
-
-
-
-
-
-
-
-
-
-
+## 内容提要
+
+* 本章介绍了http验证用户的一种机制————cookie,以及cookie的一些概念细节！
+
+### 外在原因
+
+* http最初是一个匿名、无状态的请求/响应协议。服务器处理来自客户端的请求，然后向客户端回送一条响应。web服务器几乎没有什么信息可以用来判定是哪个用户发送的请求，也无法记录来访用户的请求序列。
+
+### 能解决的问题
+
+* 以在线商店为例讲解有了http有了验证身份的机制之后可以实现那些功能，（当然没有这个机制的情况下也可以实现，但是可能会传很多参数来保证身份信息）：
+
+1、个性化的问候
+
+2、有的放矢的推荐
+
+3、管理信息的存档
+
+4、记录会话
+
+#### http报文中承载用户信息的首部
+
+1、From:用户的E-mail地址
+
+2、User-Agent:用户代理或爬虫标记
+
+3、Referer:当前页面是从那个页面跳过来的
+
+4、Authoriztion:用户的用户名和密码
+
+5、Client-IP : 扩展（请求）
+
+6、X-Forwarded-For : 扩展（请求）
+
+7、Cookie:扩展（请求）
+
+
+#### 客户端IP地址
+
+* 早起的web曾以客户端的ip地址信息来作为验证用户的身份机制，但存在很多缺点，如：
+
+1、首先ip标记是客户端机器，而不是用户，也就是说多个用户公用一台机器，是无法识别的！
+
+2、很多ip地址是动态的，所以不能在一次会话之间用ip地址来验证一个用户信息
+
+3、使用代理的时候，此时发送的ip地址是代理的ip地址，而不是用户的ip地址，虽然代理可以加一个首部来保证最初的ip地址信息，但是不兼容
+
+4、ip地址很容伪造，所以不安全
+
+
+#### 用户登录
+
+* 这种方法的主要原理就是：在初始访问的时候，服务器返回报文并添加WWW-Authorization首部，用以弹出一个窗口要求用户填写用户名和密码等信息！客户端在下次访问的时候就可以传送带有Authorization的首部，并把相关身份信息传输过去以此验证用户信息，以后的每次请求都会带上这个首部！
+
+#### 胖URL
+
+* 把用户信息添加进url的url称为胖url，以此来验证用户身份，但这种机制有以下缺点：
+
+1、丑陋的url
+
+2、无法共享url,因为用户信息在url里面，共享url同时也会把用户信息共享出去了
+
+3、破坏缓存
+
+4、额外的服务器负荷
+
+5、逃逸口，很容易造成用户不小心跳到另一个网站，返回过来的收用户的信息全部没了，比如购物车里面的东西全部没了
+
+6、会话是非持久的
+
+#### Cookie
+
+* 分类：会话Cookie（非持久Cookie）和持久Cookie
+
+* 原理：用户第一次请求服务器时，服务器返回一个带Set-Cookie（Set-Cookie1）首部的报文，值为键值对，描述了cookie的名字、值、域、路径等信息，然后客户端接下来每次访问服务器的时候都会带上一个Cookie首部的报文，它的值刚好是前面响应报文返回的名字键值对，从而达到验证用户身份的信息。
+
+#### Cookie的属性
+
+* domain : cookie的域
+
+* allh : 那些主机可以使用此cookie
+
+* path ：那些路径能使用cookie
+
+* secure : 是否在发送https报文的时候使用cookie
+
+* expires ： 过期时间
+
+* name ： cookie的名字
+
+* value : cookie的值
+
+#### 不同站点使用不同的cookie
+
+ 
+ * cookie不能任意使用，只能在它自己设定的域、主机、路径里面使用
+
+#### cookie版本
+
+ * cookie机制有个两个版本，一个是网景公司主导的“版本0”，主要是服务器返回“Set-Cookie”首部，而客户端请求发送“Cookie”首部，客户端发送请求时，会将所有与域、路径和安全过滤器相匹配的未过期cookie都发送给这个站点。所有cookie都被组合到一个Cookie首部中，如：
+
+ ``` 
+ 		Cookie: session-id=002-1145265-8016938; session-id-time=1311313313131
+ ```
+
+ cookie机制还有一个版本就是RFC 2965定义的一个cookie的扩展版本。这个版本1标准引入了Set-Cookie2首部和Cookie2首部，但它也能与“版本0”系统进行互操作。“版本1”跟“版本0”的区别就是，提供了更多的属性来描述一个cookie,同时服务器端发送的是“Set-Cookie”首部，而客户端发送的是“Cookie”首部，如：
+
+ ```
+ 		服务器端
+ 	 	Set-Cookie2: ID="29046"; Domain=".joes-hardware.com"
+ 	 	Set-Cookie2: color=blue
+ 	 	Set-Cookie2: support-pref="L2"; Domain="customer-care.joes-hardware.com"
+ 	 	Set-Cookie2: Coupon="hammer027"; Version="1"; Path="/tools"
+ 	 	Set-Cookie2: Coupon="handvac103"; Version="1";Path="/tools/cordless"
+
+ 	 	客户端
+ 	 	Cookie: $Version="1";
+ 	 			ID="29046"; $Domain=".joes-hardware.com";
+ 	 			color="blue";
+ 	 			Coupon="hammer027"; $Path="/tools";
+ 	 			Coupon="handvac103"; $Path="/tools/cordless"
+ ```
+
+另外Cookie2首部是用来沟通支持版本0和版本1的服务器的，它会发送当前客户端支持的最新版本cookie版本，如：
+
+```
+		Cookie2: $Version="1"
+```
+
+
+
+
+
+
+
+
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/12 \345\237\272\346\234\254\350\256\244\350\257\201\346\234\272\345\210\266.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/12 \345\237\272\346\234\254\350\256\244\350\257\201\346\234\272\345\210\266.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/12 \345\237\272\346\234\254\350\256\244\350\257\201\346\234\272\345\210\266.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/12 \345\237\272\346\234\254\350\256\244\350\257\201\346\234\272\345\210\266.md"
index 640d709c..4156994e 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/12 \345\237\272\346\234\254\350\256\244\350\257\201\346\234\272\345\210\266.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/12 \345\237\272\346\234\254\350\256\244\350\257\201\346\234\272\345\210\266.md"	
@@ -1,51 +1,51 @@
-### 内容提要
-
-* 本章以及接下来的十三章都是介绍了http验证用户身份的一些机制！本章介绍一下基本认证，首先得这是一种简单的认证，并不能用于复杂、保密的业务逻辑环境中，它只能做到一般的保护，比如防止某个好心人查看你的个人信息！
-
-#### 基本认证概述
-
-* 基本认证描述的就是用户第一次访问服务器的时候，服务器返回401状态码和WWW-Authenticate响应首部，并在首部中描述了密码编码算法和对应要使用密码的安全域，然后客户端弹框，在输入用户名和密码提交后。客户端发送含有Authorization首部的get请求申请验证身份，其中首部中携带了用户名和密码糅合在一起的编码后的验证码给服务器端，如果验证通过，那么服务器返回200的响应，并以Authentication-Info首部携带相关信息，以后用户就可以不用密码访问相关文件了！
-
-#### 认证
-
-* 认证就是给出一种身份证明
-
-* HTTP的质询/响应认证框架：简单来说就是客户端和服务器端之间通信需要通过不断验证身份的过程来完成一个会话。web第一次发起一条http请求报文时，服务器返回一个“认证质询”响应，要求客户端提供用户信息，用户再次发起请求时，就会附上身份信息证书，如果验证通过，那么就完成会话，否则继续发起质询/认证！
-
-* 认证协议与首部：http官方定义了两个官方的认证协议：基本认证和摘要认证。与此有关的报文首部如下：
-
->> WWW-Authenticate————发生在服务器向客户端发起质询时，此时服务端返回401状态码,同时此首部定义了服务器端那个域需要验证质询认证
-
->> Authorization————发生在客户端发起认证时，携带用户名和密码等信息！
-
->> Authentication-Info————发生在认证成功时，服务器返回200 ok,并以此首部携带一些信息
-
-
-* 安全域：安全域说明了不同的资源需要使用不同的访问权限！说白了你访问服务器不同的路径需要不同的验证方式，也就是说你可能需要重新验证！
-
-
-#### 基本认证
-
-* 基本认证实现服务器端可以拒绝一个事务，并要求验证客户端信息，返回401状态码，发起质询/认证！
-
-* Base-64用户名/密码编码：是一种编码机制
-
-* 代理认证：就是代替服务器向客户端发起质询/认证，与服务器端发起的质询/认证主要有几点不同：质询的时候返回的是407状态码，服务器端质询返回的首部是Proxy-Authenticate，客户端认证时发送的是Proxy-Authorizatio首部，认证成功之后返回的是Proxy-Authentication-Info首部。
-
-#### 基本认证的安全缺陷
-
-* 基本认证简单快捷，但并不安全，存在以下缺陷：
-
-1、基本认证是采用网络以明文的方式发送用户名和密码，容易被别人捕获。
-
-2、即使是密文发送 ，也很容易被别人解码
-
-3、适用于很简单的会话服务
-
-4、没有中间节点的保护措施
-
-5、容易假冒服务器骗过基本认证
-
-#### 注
-
+### 内容提要
+
+* 本章以及接下来的十三章都是介绍了http验证用户身份的一些机制！本章介绍一下基本认证，首先得这是一种简单的认证，并不能用于复杂、保密的业务逻辑环境中，它只能做到一般的保护，比如防止某个好心人查看你的个人信息！
+
+#### 基本认证概述
+
+* 基本认证描述的就是用户第一次访问服务器的时候，服务器返回401状态码和WWW-Authenticate响应首部，并在首部中描述了密码编码算法和对应要使用密码的安全域，然后客户端弹框，在输入用户名和密码提交后。客户端发送含有Authorization首部的get请求申请验证身份，其中首部中携带了用户名和密码糅合在一起的编码后的验证码给服务器端，如果验证通过，那么服务器返回200的响应，并以Authentication-Info首部携带相关信息，以后用户就可以不用密码访问相关文件了！
+
+#### 认证
+
+* 认证就是给出一种身份证明
+
+* HTTP的质询/响应认证框架：简单来说就是客户端和服务器端之间通信需要通过不断验证身份的过程来完成一个会话。web第一次发起一条http请求报文时，服务器返回一个“认证质询”响应，要求客户端提供用户信息，用户再次发起请求时，就会附上身份信息证书，如果验证通过，那么就完成会话，否则继续发起质询/认证！
+
+* 认证协议与首部：http官方定义了两个官方的认证协议：基本认证和摘要认证。与此有关的报文首部如下：
+
+>> WWW-Authenticate————发生在服务器向客户端发起质询时，此时服务端返回401状态码,同时此首部定义了服务器端那个域需要验证质询认证
+
+>> Authorization————发生在客户端发起认证时，携带用户名和密码等信息！
+
+>> Authentication-Info————发生在认证成功时，服务器返回200 ok,并以此首部携带一些信息
+
+
+* 安全域：安全域说明了不同的资源需要使用不同的访问权限！说白了你访问服务器不同的路径需要不同的验证方式，也就是说你可能需要重新验证！
+
+
+#### 基本认证
+
+* 基本认证实现服务器端可以拒绝一个事务，并要求验证客户端信息，返回401状态码，发起质询/认证！
+
+* Base-64用户名/密码编码：是一种编码机制
+
+* 代理认证：就是代替服务器向客户端发起质询/认证，与服务器端发起的质询/认证主要有几点不同：质询的时候返回的是407状态码，服务器端质询返回的首部是Proxy-Authenticate，客户端认证时发送的是Proxy-Authorizatio首部，认证成功之后返回的是Proxy-Authentication-Info首部。
+
+#### 基本认证的安全缺陷
+
+* 基本认证简单快捷，但并不安全，存在以下缺陷：
+
+1、基本认证是采用网络以明文的方式发送用户名和密码，容易被别人捕获。
+
+2、即使是密文发送 ，也很容易被别人解码
+
+3、适用于很简单的会话服务
+
+4、没有中间节点的保护措施
+
+5、容易假冒服务器骗过基本认证
+
+#### 注
+
 * 安全使用基本认证的唯一方式就是将其与SSL配合使用
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/13 \346\221\230\350\246\201\350\256\244\350\257\201.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/13 \346\221\230\350\246\201\350\256\244\350\257\201.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/13 \346\221\230\350\246\201\350\256\244\350\257\201.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/13 \346\221\230\350\246\201\350\256\244\350\257\201.md"
index 341900a3..009b75b7 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/13 \346\221\230\350\246\201\350\256\244\350\257\201.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/13 \346\221\230\350\246\201\350\256\244\350\257\201.md"	
@@ -1,27 +1,27 @@
-### 内容提要
-
-* 本章提供HTTP官方定义的另外一种认证协议————摘要认证。
-
-* 摘要认证跟基本认证兼容，但更安全，虽然没有得到广泛应用，但对安全事务来说，这些概念是很重要的。
-
-#### 摘要认证的改进
-
-* 与基本认证相比，摘要认证虽不是最安全的认证方式，但却在以下几点上做了一些改进，以此来降低安全事务风险。
-
-1、永远不会以明文方式在网络上发送密码
-
-2、可以防止恶意用户捕获并重新认证的握手过程
-
-3、可以有选择地防止对报文内容的篡改
-
-4、防范其他几种常见的攻击方式
-
-* 用摘要保护密码：永远不在网络上发送密码，而是发送密码的摘要，客户端和服务器端是知道密码的，然后服务端计算从客户端传送过来的摘要看是否和本地的密码摘要相匹配，从而验证用户身份。
-
-* 单向摘要：摘要是一种单向函数，常见的摘要很是是MD5，会将任意长度的字节序列转换为一个128位的摘要，通常被写成一个32位16进制的字符。
-
-* 用随机数防止重放攻击：就是服务器发送一个随机数，用于和密码摘要组成新的摘要，这样就能避免重放攻击了。
-
-#### 后面的内容
-
+### 内容提要
+
+* 本章提供HTTP官方定义的另外一种认证协议————摘要认证。
+
+* 摘要认证跟基本认证兼容，但更安全，虽然没有得到广泛应用，但对安全事务来说，这些概念是很重要的。
+
+#### 摘要认证的改进
+
+* 与基本认证相比，摘要认证虽不是最安全的认证方式，但却在以下几点上做了一些改进，以此来降低安全事务风险。
+
+1、永远不会以明文方式在网络上发送密码
+
+2、可以防止恶意用户捕获并重新认证的握手过程
+
+3、可以有选择地防止对报文内容的篡改
+
+4、防范其他几种常见的攻击方式
+
+* 用摘要保护密码：永远不在网络上发送密码，而是发送密码的摘要，客户端和服务器端是知道密码的，然后服务端计算从客户端传送过来的摘要看是否和本地的密码摘要相匹配，从而验证用户身份。
+
+* 单向摘要：摘要是一种单向函数，常见的摘要很是是MD5，会将任意长度的字节序列转换为一个128位的摘要，通常被写成一个32位16进制的字符。
+
+* 用随机数防止重放攻击：就是服务器发送一个随机数，用于和密码摘要组成新的摘要，这样就能避免重放攻击了。
+
+#### 后面的内容
+
 * 略
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/14 \345\256\211\345\205\250HTTP.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/14 \345\256\211\345\205\250HTTP.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/14 \345\256\211\345\205\250HTTP.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/14 \345\256\211\345\205\250HTTP.md"
index 06895c2b..d6150b76 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/14 \345\256\211\345\205\250HTTP.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/14 \345\256\211\345\205\250HTTP.md"	
@@ -1,85 +1,85 @@
-### 内容提要
-
-* 本章主要讲解了一下http的安全版本https,以及对一下编码、解码的原理介绍！
-
-#### 保护HTTP的安全
-
-* http的安全版本应该具有：高效、可移植且易于管理，不但能够适应不断变化的情况而且还应该能满足社会和政府的各项要求。总结如下：
-
-1、服务器认证：（客户端知道它们是在与真正的而不是伪造的服务器通话）
-
-2、客户端认证：（服务器知道它们是在与真正的而不是伪造的客户端通话）
-
-3、完整性：（客户端与服务器的数据不会被修改）
-
-4、加密：（客户端和服务器的对话是私密的，无需担心被窃听）
-
-5、效率：（一个运行的足够快的算法，以便低端的客户端和服务器使用）
-
-6、普适性：（基本上所有的客户端和服务器都支持这些协议）
-
-7、管理的可扩展性：（在任何地方的任何人都可以立即进行安全通信）
-
-8、适应性：（能够支持当前最知名的安全方法）
-
-9、在社会上的可行性：（满足社会的政治文化需要）
-
-* HTTPS：https是http的安全版本协议，所有现代浏览器和服务器都支持这个协议。用户可以在地址栏那里的看url的方法是https还是http来区分。所有https要求所有数据在进行网络传输前进行加密处理，https是在http和tcp/ip之间加了一个安全传输层SSL（或者TLS，跟SSL区别不大，不作特别声明的情况下，它们可以互指）。大部分困难和复杂的编码和解码算法都在SSL中完成的，所以客户端和服务器在使用https不用做过多的协议处理逻辑！
-
-#### 数字加密
-
-* 首先需要知道以下概念：
-
-1、密码：对文本进行编码，是偷窥者无法识别的算法（注意是“算法”）
-
-2、秘钥：改变密码行文的数字化参数
-
-3、对称秘钥加密系统：编/解码使用相同密钥的算法
-
-4、公开秘钥加密系统：一种能够使数百万计算机便捷地发送机密报文的系统
-
-5、数字签名：用来验证报文未被伪造或篡改的检验和
-
-6、数字证书：由一个可信的组织验证和签发的识别信息
-
-* 密码：一种（方法）特殊的报文编码方式和一种稍后使用的相应解码方式的结合体。被编码的报文称为密文，被解码的报文称为明文。在一次请求（响应）中过程中，报文的状态为：明文————密文————明文。如果只使用密码的话，其实有很大的安全缺陷的，因为对方只要知道的你的密码算法，就能够解码处明文。
-
-* 秘钥：正因为密码算法有缺陷，所有才有了秘钥。说的直白一点，你只有密码的话，别人知道了算法，照样能解码，但是除了密码还有秘钥，别人知道密码就不一定能解码出来了，至少有些困难，那么秘钥是什么呢！它就是一个数字参数，有了它就可以实现，每次解码的算法不一样。就好像一个函数，每次传的参数不一样。秘钥就是那个“参数”！
-
-* 对称秘钥加密技术：发送端和接受端使用同样的秘钥进行加密的密码算法技术。
-
-* 枚举攻击：输完所有的可能值来达到解码的一种攻击方案。也就是说如果秘钥的可能方案越多，那么解码所花的代价越大。而秘钥的数量取决于秘钥的位数以及有效位数。所以可以从这些方面来增加密码的安全级别。
-
-* 公开秘钥加密技术：由于对称秘钥加密技术会有秘钥数目的N*N的问题，所有公开秘钥加密技术要求发送端使用公用的秘钥，在接收端使用私有秘钥的解码。
-
-* 数字签名：签名就是一种证明身份的机制，是一种校验机制。
-
-* 数字证书：一种由某官方机构颁发的证书
-
-#### HTTPS————细节介绍
-
-* 建立安全传输：https与http的不同就是，中间了增加了一次SSL握手的步骤。具体情况就是，https在建立tcp/ip连接之后还需要进行一次SSL层的传输连接工作连接，同时在关闭tcp/ip连接之前需要增加一次关闭SSL层的通知工作。
-
-* SSL握手过程中确定了以下工作细节：
-
-1、交换协议版本号；
-
-2、选择一个两端都了解的密码；
-
-3、对两端的身份进行认证；
-
-4、生成临时的会话秘钥，以便加密信道。
-
-* SSL握手步骤为：
-
-1、客户端发送可供选择的密码并请求证书
-
-2、服务器发送选中的密码和证书
-
-3、客户端发送保密信息；客户端和服务端生成秘钥
-
-4、客户端和服务器相互告知，开始加密过程
-
-#### 后续内容 
-
-* 略
+### 内容提要
+
+* 本章主要讲解了一下http的安全版本https,以及对一下编码、解码的原理介绍！
+
+#### 保护HTTP的安全
+
+* http的安全版本应该具有：高效、可移植且易于管理，不但能够适应不断变化的情况而且还应该能满足社会和政府的各项要求。总结如下：
+
+1、服务器认证：（客户端知道它们是在与真正的而不是伪造的服务器通话）
+
+2、客户端认证：（服务器知道它们是在与真正的而不是伪造的客户端通话）
+
+3、完整性：（客户端与服务器的数据不会被修改）
+
+4、加密：（客户端和服务器的对话是私密的，无需担心被窃听）
+
+5、效率：（一个运行的足够快的算法，以便低端的客户端和服务器使用）
+
+6、普适性：（基本上所有的客户端和服务器都支持这些协议）
+
+7、管理的可扩展性：（在任何地方的任何人都可以立即进行安全通信）
+
+8、适应性：（能够支持当前最知名的安全方法）
+
+9、在社会上的可行性：（满足社会的政治文化需要）
+
+* HTTPS：https是http的安全版本协议，所有现代浏览器和服务器都支持这个协议。用户可以在地址栏那里的看url的方法是https还是http来区分。所有https要求所有数据在进行网络传输前进行加密处理，https是在http和tcp/ip之间加了一个安全传输层SSL（或者TLS，跟SSL区别不大，不作特别声明的情况下，它们可以互指）。大部分困难和复杂的编码和解码算法都在SSL中完成的，所以客户端和服务器在使用https不用做过多的协议处理逻辑！
+
+#### 数字加密
+
+* 首先需要知道以下概念：
+
+1、密码：对文本进行编码，是偷窥者无法识别的算法（注意是“算法”）
+
+2、秘钥：改变密码行文的数字化参数
+
+3、对称秘钥加密系统：编/解码使用相同密钥的算法
+
+4、公开秘钥加密系统：一种能够使数百万计算机便捷地发送机密报文的系统
+
+5、数字签名：用来验证报文未被伪造或篡改的检验和
+
+6、数字证书：由一个可信的组织验证和签发的识别信息
+
+* 密码：一种（方法）特殊的报文编码方式和一种稍后使用的相应解码方式的结合体。被编码的报文称为密文，被解码的报文称为明文。在一次请求（响应）中过程中，报文的状态为：明文————密文————明文。如果只使用密码的话，其实有很大的安全缺陷的，因为对方只要知道的你的密码算法，就能够解码处明文。
+
+* 秘钥：正因为密码算法有缺陷，所有才有了秘钥。说的直白一点，你只有密码的话，别人知道了算法，照样能解码，但是除了密码还有秘钥，别人知道密码就不一定能解码出来了，至少有些困难，那么秘钥是什么呢！它就是一个数字参数，有了它就可以实现，每次解码的算法不一样。就好像一个函数，每次传的参数不一样。秘钥就是那个“参数”！
+
+* 对称秘钥加密技术：发送端和接受端使用同样的秘钥进行加密的密码算法技术。
+
+* 枚举攻击：输完所有的可能值来达到解码的一种攻击方案。也就是说如果秘钥的可能方案越多，那么解码所花的代价越大。而秘钥的数量取决于秘钥的位数以及有效位数。所以可以从这些方面来增加密码的安全级别。
+
+* 公开秘钥加密技术：由于对称秘钥加密技术会有秘钥数目的N*N的问题，所有公开秘钥加密技术要求发送端使用公用的秘钥，在接收端使用私有秘钥的解码。
+
+* 数字签名：签名就是一种证明身份的机制，是一种校验机制。
+
+* 数字证书：一种由某官方机构颁发的证书
+
+#### HTTPS————细节介绍
+
+* 建立安全传输：https与http的不同就是，中间了增加了一次SSL握手的步骤。具体情况就是，https在建立tcp/ip连接之后还需要进行一次SSL层的传输连接工作连接，同时在关闭tcp/ip连接之前需要增加一次关闭SSL层的通知工作。
+
+* SSL握手过程中确定了以下工作细节：
+
+1、交换协议版本号；
+
+2、选择一个两端都了解的密码；
+
+3、对两端的身份进行认证；
+
+4、生成临时的会话秘钥，以便加密信道。
+
+* SSL握手步骤为：
+
+1、客户端发送可供选择的密码并请求证书
+
+2、服务器发送选中的密码和证书
+
+3、客户端发送保密信息；客户端和服务端生成秘钥
+
+4、客户端和服务器相互告知，开始加密过程
+
+#### 后续内容 
+
+* 略
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/15 \345\256\236\344\275\223\345\222\214\347\274\226\347\240\201.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/15 \345\256\236\344\275\223\345\222\214\347\274\226\347\240\201.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/15 \345\256\236\344\275\223\345\222\214\347\274\226\347\240\201.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/15 \345\256\236\344\275\223\345\222\214\347\274\226\347\240\201.md"
index 6890770c..60fb19a4 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/15 \345\256\236\344\275\223\345\222\214\347\274\226\347\240\201.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/15 \345\256\236\344\275\223\345\222\214\347\274\226\347\240\201.md"	
@@ -1,166 +1,166 @@
-### 内容提要
-
-* 本章主要介绍了http实际传输的货物————实体。以及与实体有关的一些实体首部及原理，当然了还介绍了为了减小带宽所作的一些编码措施和原理（内容编码和传输编码）！
-
-#### HTTP报文应该具备的功能
-
-* 为了更好的描述http所传输数据的类型、大小、有效性等，http协议应该为主体提供以下描述信息：
-
-1、可以被正确的识别（通过Content-Type首部说明媒体格式），以便接收端能够识别并正确处理内容
-
-2、是最新的（通过实体验证码和缓存过期控制）
-
-3、符合用户的需要（基于Accept系列的内容协商首部）
-
-4、在网络上可以快速有效地传输（通过范围请求、差异编码以及其他数据压缩方法）
-
-5、完整到达、未被篡改（通过传输编码首部和Content-MD5校验和首部）
-
-#### 报文是箱子，实体是货物
-
-* 实体由实体首部和实体主体组成，实体首部是描述货物信息的，实体主体是原始货物。
-
-* 相关首部如下：
-
-1、Content-Type:实体中所承载对象的类型
-
-2、Content-Length:所传送实体主体的长度或大小，（注意：如果主体采取了内容编码进行压缩，那么它所指的是压缩后的长度或大小，此首部是描述报文主体结束的关键，尤其在持久连接时对多个报文进行正确分段）
-
-3、Content-Language:与所传送对象最相配的人类语言
-
-4、Content-Encoding:对象数据所做的任意变换（比如，压缩）
-
-5、Content-Location:一个备用位置，请求时可通过它来获得对象
-
-6、Content-Range:如果这是部分实体，这个首部说明它是整体的那个部分
-
-7、Content-MD5:实体主体内容的校验和
-
-8、Last-Modified:所传输内容在服务器上创建或最后修改的日期时间
-
-9、Expires:实体主句将要失效的日期时间
-
-10、Allow:改资源所允许的各种请求方法，例如，GET和HEAD
-
-11、ETag:这份文档特定实例的唯一验证码，ETag首部没有正式定义为实体首部，但它对许多涉及实体的操作来说，都是一个重要的首部
-
-12、Cache-Control:指出应该如何缓存该文档。和ETag首部类似，Cache-Control首部没有正式定义为实体首部
-
-
-#### Content-Length:实体的大小
-
-* http的早期版本采用关闭连接的办法来划定报文的结束，但是，没有Content-Length的话，客户端就无法判别到底是报文结束时正常的连接关闭，还是报文传输中由于服务器崩溃而导致的连接关闭。客户端需要通过Content-Length来检测报文截尾。注意这个后果对于缓存是很严重的，可能造成缓存长时间用不完整的内容来响应客户端。
-
-* Content-Length与持久连接：拥有Content-Length就能对报文进行正确的分段
-
-* 内容编码：有时候服务器采用内容编码来压缩实体主体以节省空间，Content-Length描述的是压缩过后的长度或大小
-
-* 确定实体主体长度的规则，以下规则，谁先匹配到就用谁：
-
-1、如果特定的HTTP报文类型中不允许带有主体，那么就忽略Content-Length首部。常见情况有：1XX、204以及304响应，还有HEAD方法的响应。
-
-2、如果报文中含有描述传输编码的Transfer-Encoding首部，那么实体就应由一个称为“零字节块”的特殊模式结束。
-
-3、如果报文中，有Content-Length首部而无Transfer-Encoding首部，那么Content-Length就是描述首部的长度。如果有Content-Length首部，同时也有Transfer-Encoding首部，那么就必须忽略Content-Length,因为传输编码会改变实体主体的表示和传输方式（因此可能就会改变传输的字节数）。
-
-4、如果报文使用了multipart/byteranges(多部分/字节范围)媒体类型，且无Content-Length首部，那么报文长度有报文去自定界。
-
-5、如果以上规则都不匹配，实体的长度就是关闭连接时所得到的的主体的长度。这个值实际上由服务器关闭连接得到。客户端关闭连接将使服务器无法响应。
-
-#### 实体摘要
-
-* 虽然http建立在tcp/ip这样的可靠传输协议之上，但是还是有很多原因导致报文在传输过程被修改。发送方可以在生成初始的主体时，生成一个数据的校验和。遮掩接收方就可以通过检查这个校验和来捕获所有意外的实体修改了。
-
-#### 媒体类型和字符集
-
-* 记住一点：Content-Type首部字段说明了实体主体的MIME类型，其值是标准化的MIME类型，都在互联网号码分配机构中注册。
-
-
-#### 内容编码
-
-* 编码过程：
-
-1、生成原始响应报文，有Content-Type和Content-Length首部。
-
-2、编码服务器对报文进行编码，编码之后同样拥有Content-Type和Content-Length首部,但是Content-Length可能不同（比如主体被压缩了），同时增加了Content-Encoding首部，这样接收端就知道怎样去解码了。
-
-3、接收端解码，得到原始报文
-
-* Accept-Encoding首部：该首部描述了接收端能处理的编码方式
-
-#### 传输编码和分块编码
-
-* 相关首部：Transfer-Encoding首部告诉接收方自己使用了何种编码。TE首部告诉发送端自己希望收到何种编码。
-
-* 分块编码：首先分块编码是一种传输编码，其格式大致为：http响应首部块开始，随后就是一系列分块，每个分块包含一个长度值和该分块的数据。长度值是16进制形式并将CRLF与数据分隔开。最后一个块有点特别，它的长度值为0，表示“主体结束”。
-
-* 分块报文中的拖挂（可选），拖挂中可以包含附带的首部字段，它们的值在报文开始的时候可能是无法确定的（例如，必须要先生成主体的内容）。Content-MD5首部就是一个可以在拖挂中发送的首部。
-
-#### 验证码和新鲜度
-
-* 相关语法：
-
-1、Expires: <absolute time> 要求客户端和服务器时钟同步。
-
-2、Cache-Control: <options> 其相关参数如下（括号中的值表示用在请求报文还是响应报文）：
-
->> no-cache(请求)，在重新向服务器验证之前，不要返回文档的缓存版本
-
->> no-store(请求)，不要返回文档的缓存版本，不要保存服务器的响应
-
->> max-age(请求)，缓存中的文档不能超过指定的试用期
-
->> max-stale(请求)，文档允许过期，但不能超过指令中的指定的过期值
-
->> min-fresh(请求)，文档的试用期不能小于这个指定的时间与它的当前存活时间之和，换句话说，响应必须至少在指定的这段时间之内保持新鲜
-
->> no-transform（请求），文档在发送之前不允许被转换
-
->> only-if-cached(请求)，只要当文档在缓存中才发送，不要联系原始服务器
-
->> public(响应)，响应可以被任何服务器缓存
-
->> private(响应)，响应可以被缓存，但只能被单个客户端访问，换句话说，就是本地缓存。
-
->> no-cache(响应)，如果该指令伴随一个首部列表的话，那么内容可以被缓存并提供给客户端，但必须先删除所列出的首部，如果没有指定首部，缓存中的副本在没有重新向服务器验证之前不能提供给客户端。
-
->> no-store(响应)，不允许被缓存
-
->> no-transform(响应)，响应在提供给客户端之前不能做任何形式的修改
-
->> must-revalidate(响应)，响应在提供给客户端之前必须重新向服务器验证
-
->> proxy-revalidate(响应)， 共享的缓存在提供给客户端之前必须重新向原始服务器验证，私有的缓存可以忽略这条执行
-
->> max-age(响应)，指定文档可以被缓存的时间以及新鲜度的最长时间
-
->> s-max-age(响应)，指定文档作为共享缓存时的最长使用时间，私有的缓存可以忽略本指令
-
-* 有条件的请求与验证码，概念如下：
-
-1、有条件的请求，仅当资源改变时才请求副本，这种特殊请求称为有条件的请求。
-
-2、验证码，说白一点客户端发送什么条件过去可以获知当前文档不新鲜了，所以常用的验证码就是文档最后修改时间以及实例标记。比如有条件的首部If-Modified-Since测试的是文档实例最后被修改的日期时间，因此我们最后被修改的日期时间就是验证码。
-
-* 相关首部(括号里面的就是其验证码)：
-
-1、If-Modified-Since（Last-Modified）:如果在前一条响应的Last-Modified首部中说明的时间之后，资源的版本发生变化，就发送其副本。
-
-2、If-Unmodified-Since(Last-Modified):仅在前一条响应的Last-Modified首部中说明的时间之后，资源的版本没有变化，才发送其副本
-
-3、If-Match(ETag):如果实体的标记与前一次响应首部的ETag相同，就发送该资源的副本
-
-4、If-None-Match（ETag）:如果实体的标记与前一次响应首部中的ETag不同，就发送该资源的副本
-
-* 弱验证码和强验证码：弱验证码不一定能唯一标志资源的一个实例，而强验证码能唯一标志一个文档的实例。例如用文档字节数来验证一个文档是否有改变，可能会出现的情况就是，虽然字节数大小没有变，但是内容确实变了，所以字节数验证码是弱验证码，而资源内容的加密校验和（比如MD5）就是强验证码，因为当文档改变时它总是会改变。注：在ETag首部的值前面加上W/，把其标记为弱验证码，此时只是主体发生显著变化时，才会从服务器取资源。
-
-
-#### 范围请求
-
-* 概念：Range允许客户端实际只请求文档的一部分，或者说某个范围。
-
-#### 差异编码
-
-概念：差异编码是HTTP协议的一个扩展，它通过交换对象改变的部分而不是完整的对象来优化传输性能。
-
+### 内容提要
+
+* 本章主要介绍了http实际传输的货物————实体。以及与实体有关的一些实体首部及原理，当然了还介绍了为了减小带宽所作的一些编码措施和原理（内容编码和传输编码）！
+
+#### HTTP报文应该具备的功能
+
+* 为了更好的描述http所传输数据的类型、大小、有效性等，http协议应该为主体提供以下描述信息：
+
+1、可以被正确的识别（通过Content-Type首部说明媒体格式），以便接收端能够识别并正确处理内容
+
+2、是最新的（通过实体验证码和缓存过期控制）
+
+3、符合用户的需要（基于Accept系列的内容协商首部）
+
+4、在网络上可以快速有效地传输（通过范围请求、差异编码以及其他数据压缩方法）
+
+5、完整到达、未被篡改（通过传输编码首部和Content-MD5校验和首部）
+
+#### 报文是箱子，实体是货物
+
+* 实体由实体首部和实体主体组成，实体首部是描述货物信息的，实体主体是原始货物。
+
+* 相关首部如下：
+
+1、Content-Type:实体中所承载对象的类型
+
+2、Content-Length:所传送实体主体的长度或大小，（注意：如果主体采取了内容编码进行压缩，那么它所指的是压缩后的长度或大小，此首部是描述报文主体结束的关键，尤其在持久连接时对多个报文进行正确分段）
+
+3、Content-Language:与所传送对象最相配的人类语言
+
+4、Content-Encoding:对象数据所做的任意变换（比如，压缩）
+
+5、Content-Location:一个备用位置，请求时可通过它来获得对象
+
+6、Content-Range:如果这是部分实体，这个首部说明它是整体的那个部分
+
+7、Content-MD5:实体主体内容的校验和
+
+8、Last-Modified:所传输内容在服务器上创建或最后修改的日期时间
+
+9、Expires:实体主句将要失效的日期时间
+
+10、Allow:改资源所允许的各种请求方法，例如，GET和HEAD
+
+11、ETag:这份文档特定实例的唯一验证码，ETag首部没有正式定义为实体首部，但它对许多涉及实体的操作来说，都是一个重要的首部
+
+12、Cache-Control:指出应该如何缓存该文档。和ETag首部类似，Cache-Control首部没有正式定义为实体首部
+
+
+#### Content-Length:实体的大小
+
+* http的早期版本采用关闭连接的办法来划定报文的结束，但是，没有Content-Length的话，客户端就无法判别到底是报文结束时正常的连接关闭，还是报文传输中由于服务器崩溃而导致的连接关闭。客户端需要通过Content-Length来检测报文截尾。注意这个后果对于缓存是很严重的，可能造成缓存长时间用不完整的内容来响应客户端。
+
+* Content-Length与持久连接：拥有Content-Length就能对报文进行正确的分段
+
+* 内容编码：有时候服务器采用内容编码来压缩实体主体以节省空间，Content-Length描述的是压缩过后的长度或大小
+
+* 确定实体主体长度的规则，以下规则，谁先匹配到就用谁：
+
+1、如果特定的HTTP报文类型中不允许带有主体，那么就忽略Content-Length首部。常见情况有：1XX、204以及304响应，还有HEAD方法的响应。
+
+2、如果报文中含有描述传输编码的Transfer-Encoding首部，那么实体就应由一个称为“零字节块”的特殊模式结束。
+
+3、如果报文中，有Content-Length首部而无Transfer-Encoding首部，那么Content-Length就是描述首部的长度。如果有Content-Length首部，同时也有Transfer-Encoding首部，那么就必须忽略Content-Length,因为传输编码会改变实体主体的表示和传输方式（因此可能就会改变传输的字节数）。
+
+4、如果报文使用了multipart/byteranges(多部分/字节范围)媒体类型，且无Content-Length首部，那么报文长度有报文去自定界。
+
+5、如果以上规则都不匹配，实体的长度就是关闭连接时所得到的的主体的长度。这个值实际上由服务器关闭连接得到。客户端关闭连接将使服务器无法响应。
+
+#### 实体摘要
+
+* 虽然http建立在tcp/ip这样的可靠传输协议之上，但是还是有很多原因导致报文在传输过程被修改。发送方可以在生成初始的主体时，生成一个数据的校验和。遮掩接收方就可以通过检查这个校验和来捕获所有意外的实体修改了。
+
+#### 媒体类型和字符集
+
+* 记住一点：Content-Type首部字段说明了实体主体的MIME类型，其值是标准化的MIME类型，都在互联网号码分配机构中注册。
+
+
+#### 内容编码
+
+* 编码过程：
+
+1、生成原始响应报文，有Content-Type和Content-Length首部。
+
+2、编码服务器对报文进行编码，编码之后同样拥有Content-Type和Content-Length首部,但是Content-Length可能不同（比如主体被压缩了），同时增加了Content-Encoding首部，这样接收端就知道怎样去解码了。
+
+3、接收端解码，得到原始报文
+
+* Accept-Encoding首部：该首部描述了接收端能处理的编码方式
+
+#### 传输编码和分块编码
+
+* 相关首部：Transfer-Encoding首部告诉接收方自己使用了何种编码。TE首部告诉发送端自己希望收到何种编码。
+
+* 分块编码：首先分块编码是一种传输编码，其格式大致为：http响应首部块开始，随后就是一系列分块，每个分块包含一个长度值和该分块的数据。长度值是16进制形式并将CRLF与数据分隔开。最后一个块有点特别，它的长度值为0，表示“主体结束”。
+
+* 分块报文中的拖挂（可选），拖挂中可以包含附带的首部字段，它们的值在报文开始的时候可能是无法确定的（例如，必须要先生成主体的内容）。Content-MD5首部就是一个可以在拖挂中发送的首部。
+
+#### 验证码和新鲜度
+
+* 相关语法：
+
+1、Expires: <absolute time> 要求客户端和服务器时钟同步。
+
+2、Cache-Control: <options> 其相关参数如下（括号中的值表示用在请求报文还是响应报文）：
+
+>> no-cache(请求)，在重新向服务器验证之前，不要返回文档的缓存版本
+
+>> no-store(请求)，不要返回文档的缓存版本，不要保存服务器的响应
+
+>> max-age(请求)，缓存中的文档不能超过指定的试用期
+
+>> max-stale(请求)，文档允许过期，但不能超过指令中的指定的过期值
+
+>> min-fresh(请求)，文档的试用期不能小于这个指定的时间与它的当前存活时间之和，换句话说，响应必须至少在指定的这段时间之内保持新鲜
+
+>> no-transform（请求），文档在发送之前不允许被转换
+
+>> only-if-cached(请求)，只要当文档在缓存中才发送，不要联系原始服务器
+
+>> public(响应)，响应可以被任何服务器缓存
+
+>> private(响应)，响应可以被缓存，但只能被单个客户端访问，换句话说，就是本地缓存。
+
+>> no-cache(响应)，如果该指令伴随一个首部列表的话，那么内容可以被缓存并提供给客户端，但必须先删除所列出的首部，如果没有指定首部，缓存中的副本在没有重新向服务器验证之前不能提供给客户端。
+
+>> no-store(响应)，不允许被缓存
+
+>> no-transform(响应)，响应在提供给客户端之前不能做任何形式的修改
+
+>> must-revalidate(响应)，响应在提供给客户端之前必须重新向服务器验证
+
+>> proxy-revalidate(响应)， 共享的缓存在提供给客户端之前必须重新向原始服务器验证，私有的缓存可以忽略这条执行
+
+>> max-age(响应)，指定文档可以被缓存的时间以及新鲜度的最长时间
+
+>> s-max-age(响应)，指定文档作为共享缓存时的最长使用时间，私有的缓存可以忽略本指令
+
+* 有条件的请求与验证码，概念如下：
+
+1、有条件的请求，仅当资源改变时才请求副本，这种特殊请求称为有条件的请求。
+
+2、验证码，说白一点客户端发送什么条件过去可以获知当前文档不新鲜了，所以常用的验证码就是文档最后修改时间以及实例标记。比如有条件的首部If-Modified-Since测试的是文档实例最后被修改的日期时间，因此我们最后被修改的日期时间就是验证码。
+
+* 相关首部(括号里面的就是其验证码)：
+
+1、If-Modified-Since（Last-Modified）:如果在前一条响应的Last-Modified首部中说明的时间之后，资源的版本发生变化，就发送其副本。
+
+2、If-Unmodified-Since(Last-Modified):仅在前一条响应的Last-Modified首部中说明的时间之后，资源的版本没有变化，才发送其副本
+
+3、If-Match(ETag):如果实体的标记与前一次响应首部的ETag相同，就发送该资源的副本
+
+4、If-None-Match（ETag）:如果实体的标记与前一次响应首部中的ETag不同，就发送该资源的副本
+
+* 弱验证码和强验证码：弱验证码不一定能唯一标志资源的一个实例，而强验证码能唯一标志一个文档的实例。例如用文档字节数来验证一个文档是否有改变，可能会出现的情况就是，虽然字节数大小没有变，但是内容确实变了，所以字节数验证码是弱验证码，而资源内容的加密校验和（比如MD5）就是强验证码，因为当文档改变时它总是会改变。注：在ETag首部的值前面加上W/，把其标记为弱验证码，此时只是主体发生显著变化时，才会从服务器取资源。
+
+
+#### 范围请求
+
+* 概念：Range允许客户端实际只请求文档的一部分，或者说某个范围。
+
+#### 差异编码
+
+概念：差异编码是HTTP协议的一个扩展，它通过交换对象改变的部分而不是完整的对象来优化传输性能。
+
 相关首部：A-IM(请求)指出接受何种差异编码，IM(响应)指出使用了何种差异编码。
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/16 \345\233\275\351\231\205\345\214\226.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/16 \345\233\275\351\231\205\345\214\226.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/16 \345\233\275\351\231\205\345\214\226.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/16 \345\233\275\351\231\205\345\214\226.md"
index 24ca9533..84d94c87 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/16 \345\233\275\351\231\205\345\214\226.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/16 \345\233\275\351\231\205\345\214\226.md"	
@@ -1,70 +1,70 @@
-### 内容提要
-
-* 本章主要讲解了http协议在传输的过程中，如何彼此理解对方发送的内容是采用什么字符集编写的，从而彼此能够进行正确的显示内容！由此介绍了相关的报文首部。
-
-#### HTTP对国际性内容的支持
-
-* 服务器通过HTTP协议的Content-Type首部中的charset参数和Content-Language首部告知客户端文档的字母表和语言。
-
-#### 字符集和HTTP
-
-* 字符集是把字符转换为二进制码的编码，字符集标记在由IANA维护的MIME字符集注册机构进行了标准化。下面的Content-Type首部告知接收者，传输的内容是一份HTML文件，用charset参数告知接收者使用iso-8859-6阿拉伯字符集的解码算法把内容中的二进制码转换为字符：
-
-``` bash
-	Content-Type: text/html; charset=iso-8859-6
-
-```
-
-* 把二进制码转换为字符要经过两个步骤：
-
-1、文档中的二进制码被转换成字符代码，它表示了特定编码字符集中某个特定编号的字符。
-
-2、字符代码用于从编码的字符集中选取特定的元素。如在iso-8859-6中，值255对应阿拉伯字母“FEH”。
-
-* 不同的字符集相同的字符代码其字符不一定相同：如获得字符代码是225，那么字符集iso-8859-1和字符集iso-8859-2所代表的字符就不一样。
-
-#### Content-Type首部和Charset首部以及META标志
-
-* 如果在Content-Type首部中没有指定charset字符集，那么浏览器就会重文档内容的meta标签查找对应的字符集。
-
-
-#### 多语言字符编码入门
-
-* 字符集术语：
-
-1、字符是指字母、数字、标点、表意文字、符号，或其它文本形式的书写‘原子’
-
-2、字形描述字符的笔画图案或唯一的图形化形状
-
-3、编码后的字符分配给字符的唯一数字编号，这样我们就可以操作它了
-
-4、代码空间：计划用于字符代码值的整数范围
-
-5、代码宽度：每个（固定大小的）字符代码所用的位数
-
-6、字符库：特定的工作字符集（全体字符的一个子集）
-
-7、编码后的字符集：组成字符库（从全球的字符中选出若干字符）的已编码字符集，并为每个字符分配代码空间中的一个代码
-
-8、字符编码方案：把数字化的字符代码编码成一系列二进制码的算法
-
-* MIME中的charset值所命名的是把数据位映射为唯一的字符的一整套算法。它是字符编码方案和编码后的字符集这两种概念的组合。
-
-* 字符是书写的最基本的构建单元。不要把字符和字形混淆，字符是唯一的、抽象的语言“原子”。字形是画出每个字符时使用的特定方式。根据艺术形式和手法的不同，每个字符可以有很多不同的字形。如果用一种字形替代另一种的时候，文本的意思变了，那这些字形就是不同的字符。否则，它们就是同一个字符的不同风格的表示形式而已。
-
-* 字符编码方案：
-
-1、固定宽度：固定宽度方式的编码用固定数量的比特表示每个编码后的字符。它们能被快速处理，但可能会浪费空间
-
-2、可变宽度（无模态）：可变宽度方式的编码对不同的字符代码数字采用不同数量的比特。对于常用字符，这样可以减少需要的位数，而且还能减少需要的位数，而且还能在允许使用多字节来表示国际性字符的同时，保持对传统8位字符集的兼容性。
-
-3、可变宽度（有模态）：有模态的编码使用特殊的“转义”模式在不同的模态之间切换。例如，可以用有模态的编码在文本中使用多个互相有重叠的字符集。有模态的编码处理起来比较复杂，但它们可以有效地支持复杂的书写系统。
-
-
-#### 语言标记与HTTP
-
-* Content-Lenguage首部字段描述实体的目标受众语言。Accept-Language首部描述的是客户端能或优先接收的语言。两个首部都接收多个语言标记。
-
-#### 更多内容
-
+### 内容提要
+
+* 本章主要讲解了http协议在传输的过程中，如何彼此理解对方发送的内容是采用什么字符集编写的，从而彼此能够进行正确的显示内容！由此介绍了相关的报文首部。
+
+#### HTTP对国际性内容的支持
+
+* 服务器通过HTTP协议的Content-Type首部中的charset参数和Content-Language首部告知客户端文档的字母表和语言。
+
+#### 字符集和HTTP
+
+* 字符集是把字符转换为二进制码的编码，字符集标记在由IANA维护的MIME字符集注册机构进行了标准化。下面的Content-Type首部告知接收者，传输的内容是一份HTML文件，用charset参数告知接收者使用iso-8859-6阿拉伯字符集的解码算法把内容中的二进制码转换为字符：
+
+``` bash
+	Content-Type: text/html; charset=iso-8859-6
+
+```
+
+* 把二进制码转换为字符要经过两个步骤：
+
+1、文档中的二进制码被转换成字符代码，它表示了特定编码字符集中某个特定编号的字符。
+
+2、字符代码用于从编码的字符集中选取特定的元素。如在iso-8859-6中，值255对应阿拉伯字母“FEH”。
+
+* 不同的字符集相同的字符代码其字符不一定相同：如获得字符代码是225，那么字符集iso-8859-1和字符集iso-8859-2所代表的字符就不一样。
+
+#### Content-Type首部和Charset首部以及META标志
+
+* 如果在Content-Type首部中没有指定charset字符集，那么浏览器就会重文档内容的meta标签查找对应的字符集。
+
+
+#### 多语言字符编码入门
+
+* 字符集术语：
+
+1、字符是指字母、数字、标点、表意文字、符号，或其它文本形式的书写‘原子’
+
+2、字形描述字符的笔画图案或唯一的图形化形状
+
+3、编码后的字符分配给字符的唯一数字编号，这样我们就可以操作它了
+
+4、代码空间：计划用于字符代码值的整数范围
+
+5、代码宽度：每个（固定大小的）字符代码所用的位数
+
+6、字符库：特定的工作字符集（全体字符的一个子集）
+
+7、编码后的字符集：组成字符库（从全球的字符中选出若干字符）的已编码字符集，并为每个字符分配代码空间中的一个代码
+
+8、字符编码方案：把数字化的字符代码编码成一系列二进制码的算法
+
+* MIME中的charset值所命名的是把数据位映射为唯一的字符的一整套算法。它是字符编码方案和编码后的字符集这两种概念的组合。
+
+* 字符是书写的最基本的构建单元。不要把字符和字形混淆，字符是唯一的、抽象的语言“原子”。字形是画出每个字符时使用的特定方式。根据艺术形式和手法的不同，每个字符可以有很多不同的字形。如果用一种字形替代另一种的时候，文本的意思变了，那这些字形就是不同的字符。否则，它们就是同一个字符的不同风格的表示形式而已。
+
+* 字符编码方案：
+
+1、固定宽度：固定宽度方式的编码用固定数量的比特表示每个编码后的字符。它们能被快速处理，但可能会浪费空间
+
+2、可变宽度（无模态）：可变宽度方式的编码对不同的字符代码数字采用不同数量的比特。对于常用字符，这样可以减少需要的位数，而且还能减少需要的位数，而且还能在允许使用多字节来表示国际性字符的同时，保持对传统8位字符集的兼容性。
+
+3、可变宽度（有模态）：有模态的编码使用特殊的“转义”模式在不同的模态之间切换。例如，可以用有模态的编码在文本中使用多个互相有重叠的字符集。有模态的编码处理起来比较复杂，但它们可以有效地支持复杂的书写系统。
+
+
+#### 语言标记与HTTP
+
+* Content-Lenguage首部字段描述实体的目标受众语言。Accept-Language首部描述的是客户端能或优先接收的语言。两个首部都接收多个语言标记。
+
+#### 更多内容
+
 * 略
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/17 \345\206\205\345\256\271\345\215\217\345\225\206\344\270\216\350\275\254\347\240\201.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/17 \345\206\205\345\256\271\345\215\217\345\225\206\344\270\216\350\275\254\347\240\201.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/17 \345\206\205\345\256\271\345\215\217\345\225\206\344\270\216\350\275\254\347\240\201.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/17 \345\206\205\345\256\271\345\215\217\345\225\206\344\270\216\350\275\254\347\240\201.md"
index f5ee7228..fc27cfc4 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/17 \345\206\205\345\256\271\345\215\217\345\225\206\344\270\216\350\275\254\347\240\201.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/17 \345\206\205\345\256\271\345\215\217\345\225\206\344\270\216\350\275\254\347\240\201.md"	
@@ -1,100 +1,100 @@
-### 内容提要
-
-* 本章主要讲解了一种机制————同样的url，客户端和服务器之间如何根据客户端的需要发送适当的版本文档给客户端，比如同样在浏览器输入www.baidu.com，那么如果是英国的用户很可能希望收到的收到的是英语版本的网页，而在中国的用户很可能希望收到中文版本的网页，那么服务器是怎么实现根据需要发送不同的版本的呢！于是有了内容协商和转码！所谓内容协商指的是客户端和服务器通过在http报文设置相关首部来告诉对方自己需要什么、可以发送什么等，而转码则是把文档装成其他格式的文档，注意：转码和内容编码及传输编码不一样，后两者是更高层次上的编码！
-
-
-
-#### 相关术语
-
-* 变体：单一的一个url，根据用户的不同需要，服务器发送不同版本的响应给用户，我们把这种服务器发送的不同版本的响应称为变体。例如一个网页有英语和中文版本，通过内容协商的方法实现精确发送那个版本的给客户端，这两个版本的网页就是变体。
-
-* 转码：有时根据客户端设备的不同，需要将资源转换成响应的格式的文件以让客户端设备更好的处理资源，这种类似的操作就称作转码。
-
-
-#### 内容协商技术
-
-* 内容协商技术从实现方式来说有三种：
-
-1、客户端驱动实现方式：客户端发起请求，服务器返回资源可用版本的列表，这种方式实现起来简单，但同时有个问题就是至少需要发送两次请求才能得到自己喜欢的响应（第一次获取列表，第二次才是得到资源），显然会造成时延、浪费带宽。
-
-2、服务器驱动实现方式：这种方式由服务器通过检测客户端发送过来的内容协商首部来主动决定发送相应版本的资源，涉及到著名q值检测技术。这种方式的问题就是，如果客户端的发送过来的相关首部不明确的话，那么就得服务器自己去判断了。
-
-3、透明方式（代理缓存处理）：让代理代替客户端与服务器端进行协商，从而减轻了服务器端的请求压力。
-
-#### 客户端驱动的协商
-
-* 这种方式实际上有两种方法为客户端提供选项：一是发送回一个html文档，里面有到该页面的各种版本的链接和每个版本的描述信息；另一种是发送回HTTP/1.1响应式，使用300 Multiple Choices响应代码。不管怎么样，决定权在客户端。这种方式除了增加时延并且对每个页面都要进行繁琐的多次请求之外，还有个缺点就是需要多个url,比如有个资源www.xxxx.com有英语版本好中文版本，那么在把页面分享给朋友的时候就是这种情况：www.xxx.com/en和www.xxx.com/ch。
-
-#### 服务器驱动的协商
-
-* 我们知道客户端驱动的协商会增加额外的通信量，那么避免这种情况就是让服务器端主动决定发送什么给客户端。但是为了做到这一点，客户端必须发送有关客户偏好的足够信息。以便能够左春准确的决策。服务器通过客户端请求的首部集来获得这方面的信息。相关客户端可以发送给服务器做判断的首部如下：
-
-1、Accept首部集
-
-2、User-Agent
-
-#### 内容协商首部集
-
-* 客户端通过下列首部来描述自己的偏好信息：
-
-``` code
-	
-	Accept            告知服务器发送何种媒体类型
-
-	Accept-Language   告知服务器发送何种语言
-
-	Accept-Charset    告知服务器发送何种字符集
-
-	Accept-Encoding   告知服务器采用何种编码
-
-
-```
-
-* Accept首部集和匹配的文档首部集
-
-```
-				——————————————————————————————————————————
-				*Accept首部*  				*实体首部* 
-				——————————————————————————————————————————
-				Accept  					Content-Type 
-				Accept-Language 			Content-Language 
-				Accept-Charset  			Content-Type 
-				Accept-Encoding  			Content-Encoding 
-
-```  
-
-* 质量值：HTTP提供了一种机制，可以让使得客户端足以描述自己的偏好信息，这种机制就是质量值（简称q值）。
-
-#### 内容协商首部中的质量值
-
-* http协议中定义了质量值，允许客户端为每种偏好类别列出多种选项，并为每种偏好选项关联了一个优先次序。例如，客户端可以发送下列形式的Accept-Language首部：
-
-```
-	Accept-Language: en;q=0.5, fr;q=0.0, nl;q=1.0, tr;q=0.0
-
-```
-其中q值的范围从0.0~1.0（0.0是优先级最低的，而1.0是优先级最高的）。上面列出的那个首部，说明该客户端最愿意接收荷兰语（缩写为nl）文档，但英语（缩写为en）文档也行；无论如何，这个客户端都不愿意收到法语（缩写为fr）或土耳其语（缩写为tr）的版本。注意，偏好的排列顺序并不重要，只有与偏好相关的q值才是重要的。如果上面的列表中，服务器没有找到自己匹配的文档，那么服务器将会采取转码等修改文档方式来实现响应。
-
-#### 随其它首部集而变化
-
-* 如User-Agent(此方式没有q值机制)实现发送不支持javascript版本的资源给客户端。
-
-* Vary首部：这个首部告知缓存（还有客户端的和所有下游的代理）服务器根据哪些首部来决定发送响应的最佳版本。
-
-#### 透明协商
-
-* 透明协商机制试图从服务器上去除服务器驱动协商所需的负载，并用中间代理来代表客户端以使与客户端的报文交换最小化。假定代理了解客户端的预期，这样就可以代表客户端与服务器协商（在客户端请求内容的时候，代理已经收到了客户端的预期）。为了支持透明内容协商，服务器必须有能力告知代理，服务器需要检查哪些请求首部，以便对客户端的请求进行最佳匹配。HTTP/1.1规范中没有定义任何透明协商机制，但定义了Vary首部。服务器在响应中发送了Vary首部，以告知中间节点需要使用哪些请求首部进行协商。涉及到的首部有Vary。
-
-#### 转码
-
-* 如果服务器没有能满足客户端需求的文档会怎么样呢？服务器可以给出一个错误响应。但理论上，服务器可以把现存的文档转换成某种客户端可用的文档。这种选项称为转码。有三种类别的转码：格式转换、信息综合以及内容注入。
-
-1、格式转换是指将数据从一种格式转换成另一种格式，使之可以被客户端查看。
-
-2、信息综合是从文档中提取关键的信息片段称为信息综合。
-
-3、前面描述的两类转码通常会减少Web文档的内容，但还有另一类转换会增加文档的内容，即内容注入转码。
-
-此外，转码的替代做法是在web服务器上建立Web页面的不同副本，例如一个是HTML；一个是WML。但这种方式操作起来工程量大，一个小小的改动，所有的相关的页面都要更改，加大了存储空间等。
-
-
+### 内容提要
+
+* 本章主要讲解了一种机制————同样的url，客户端和服务器之间如何根据客户端的需要发送适当的版本文档给客户端，比如同样在浏览器输入www.baidu.com，那么如果是英国的用户很可能希望收到的收到的是英语版本的网页，而在中国的用户很可能希望收到中文版本的网页，那么服务器是怎么实现根据需要发送不同的版本的呢！于是有了内容协商和转码！所谓内容协商指的是客户端和服务器通过在http报文设置相关首部来告诉对方自己需要什么、可以发送什么等，而转码则是把文档装成其他格式的文档，注意：转码和内容编码及传输编码不一样，后两者是更高层次上的编码！
+
+
+
+#### 相关术语
+
+* 变体：单一的一个url，根据用户的不同需要，服务器发送不同版本的响应给用户，我们把这种服务器发送的不同版本的响应称为变体。例如一个网页有英语和中文版本，通过内容协商的方法实现精确发送那个版本的给客户端，这两个版本的网页就是变体。
+
+* 转码：有时根据客户端设备的不同，需要将资源转换成响应的格式的文件以让客户端设备更好的处理资源，这种类似的操作就称作转码。
+
+
+#### 内容协商技术
+
+* 内容协商技术从实现方式来说有三种：
+
+1、客户端驱动实现方式：客户端发起请求，服务器返回资源可用版本的列表，这种方式实现起来简单，但同时有个问题就是至少需要发送两次请求才能得到自己喜欢的响应（第一次获取列表，第二次才是得到资源），显然会造成时延、浪费带宽。
+
+2、服务器驱动实现方式：这种方式由服务器通过检测客户端发送过来的内容协商首部来主动决定发送相应版本的资源，涉及到著名q值检测技术。这种方式的问题就是，如果客户端的发送过来的相关首部不明确的话，那么就得服务器自己去判断了。
+
+3、透明方式（代理缓存处理）：让代理代替客户端与服务器端进行协商，从而减轻了服务器端的请求压力。
+
+#### 客户端驱动的协商
+
+* 这种方式实际上有两种方法为客户端提供选项：一是发送回一个html文档，里面有到该页面的各种版本的链接和每个版本的描述信息；另一种是发送回HTTP/1.1响应式，使用300 Multiple Choices响应代码。不管怎么样，决定权在客户端。这种方式除了增加时延并且对每个页面都要进行繁琐的多次请求之外，还有个缺点就是需要多个url,比如有个资源www.xxxx.com有英语版本好中文版本，那么在把页面分享给朋友的时候就是这种情况：www.xxx.com/en和www.xxx.com/ch。
+
+#### 服务器驱动的协商
+
+* 我们知道客户端驱动的协商会增加额外的通信量，那么避免这种情况就是让服务器端主动决定发送什么给客户端。但是为了做到这一点，客户端必须发送有关客户偏好的足够信息。以便能够左春准确的决策。服务器通过客户端请求的首部集来获得这方面的信息。相关客户端可以发送给服务器做判断的首部如下：
+
+1、Accept首部集
+
+2、User-Agent
+
+#### 内容协商首部集
+
+* 客户端通过下列首部来描述自己的偏好信息：
+
+``` code
+	
+	Accept            告知服务器发送何种媒体类型
+
+	Accept-Language   告知服务器发送何种语言
+
+	Accept-Charset    告知服务器发送何种字符集
+
+	Accept-Encoding   告知服务器采用何种编码
+
+
+```
+
+* Accept首部集和匹配的文档首部集
+
+```
+				——————————————————————————————————————————
+				*Accept首部*  				*实体首部* 
+				——————————————————————————————————————————
+				Accept  					Content-Type 
+				Accept-Language 			Content-Language 
+				Accept-Charset  			Content-Type 
+				Accept-Encoding  			Content-Encoding 
+
+```  
+
+* 质量值：HTTP提供了一种机制，可以让使得客户端足以描述自己的偏好信息，这种机制就是质量值（简称q值）。
+
+#### 内容协商首部中的质量值
+
+* http协议中定义了质量值，允许客户端为每种偏好类别列出多种选项，并为每种偏好选项关联了一个优先次序。例如，客户端可以发送下列形式的Accept-Language首部：
+
+```
+	Accept-Language: en;q=0.5, fr;q=0.0, nl;q=1.0, tr;q=0.0
+
+```
+其中q值的范围从0.0~1.0（0.0是优先级最低的，而1.0是优先级最高的）。上面列出的那个首部，说明该客户端最愿意接收荷兰语（缩写为nl）文档，但英语（缩写为en）文档也行；无论如何，这个客户端都不愿意收到法语（缩写为fr）或土耳其语（缩写为tr）的版本。注意，偏好的排列顺序并不重要，只有与偏好相关的q值才是重要的。如果上面的列表中，服务器没有找到自己匹配的文档，那么服务器将会采取转码等修改文档方式来实现响应。
+
+#### 随其它首部集而变化
+
+* 如User-Agent(此方式没有q值机制)实现发送不支持javascript版本的资源给客户端。
+
+* Vary首部：这个首部告知缓存（还有客户端的和所有下游的代理）服务器根据哪些首部来决定发送响应的最佳版本。
+
+#### 透明协商
+
+* 透明协商机制试图从服务器上去除服务器驱动协商所需的负载，并用中间代理来代表客户端以使与客户端的报文交换最小化。假定代理了解客户端的预期，这样就可以代表客户端与服务器协商（在客户端请求内容的时候，代理已经收到了客户端的预期）。为了支持透明内容协商，服务器必须有能力告知代理，服务器需要检查哪些请求首部，以便对客户端的请求进行最佳匹配。HTTP/1.1规范中没有定义任何透明协商机制，但定义了Vary首部。服务器在响应中发送了Vary首部，以告知中间节点需要使用哪些请求首部进行协商。涉及到的首部有Vary。
+
+#### 转码
+
+* 如果服务器没有能满足客户端需求的文档会怎么样呢？服务器可以给出一个错误响应。但理论上，服务器可以把现存的文档转换成某种客户端可用的文档。这种选项称为转码。有三种类别的转码：格式转换、信息综合以及内容注入。
+
+1、格式转换是指将数据从一种格式转换成另一种格式，使之可以被客户端查看。
+
+2、信息综合是从文档中提取关键的信息片段称为信息综合。
+
+3、前面描述的两类转码通常会减少Web文档的内容，但还有另一类转换会增加文档的内容，即内容注入转码。
+
+此外，转码的替代做法是在web服务器上建立Web页面的不同副本，例如一个是HTML；一个是WML。但这种方式操作起来工程量大，一个小小的改动，所有的相关的页面都要更改，加大了存储空间等。
+
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/18 Web\344\270\273\346\234\272\346\211\230\347\256\241.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/18 Web\344\270\273\346\234\272\346\211\230\347\256\241.md"
similarity index 98%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/18 Web\344\270\273\346\234\272\346\211\230\347\256\241.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/18 Web\344\270\273\346\234\272\346\211\230\347\256\241.md"
index 38463af3..f0c9bdd3 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/18 Web\344\270\273\346\234\272\346\211\230\347\256\241.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/18 Web\344\270\273\346\234\272\346\211\230\347\256\241.md"	
@@ -1,73 +1,73 @@
-## 内容提要
-
-* 本章主要介绍了关于在一台物理服务器上托管了很多的主机（也就是说一个电脑里面部署了两个或者更多网站），此时，客户端怎么样和服务器端沟通，才能无差错地访问对应资源的主机（用户1访问a网站的资源，那么就不能跑到b网站上获取资源）。以及介绍了一些服务器集群的概念！
-
-### 相关概念
-
-* Web主机托管：对内容资源的存储、协调以及管理的职责统称为Web主机托管。主机托管是服务器的主要功能之一。
-
-* 托管者：如果某个公司想建立一个网站，但不想自行管理服务器所需的软硬件，就需要主机托管服务，即托管者。
-
-### 主机托管服务
-
-* 专用托管：一台物理服务器对应一个主机
-
-* 虚拟主机托管：许多Web托管者通过让一些顾客共享一台计算机来提供便宜的Web主机托管服务，这称为共享主机托管或虚拟主机托管。每个网站看起来是托管在不同的服务器上，但实际上是托管在同一个物理服务器上。————但这并不意味着上千个网站是用一台PC机来提供服务的。托管者可以创建成排同样的服务器，称为服务器集群。
-
-### 虚拟服务器请求缺乏主机信息
-
-* 背景：不幸的是，HTTP/1.0中的一个设计缺陷会使虚拟主机托管者抓狂。HTTP/1.0规范中没有为共享的Web服务器提供任何方法来设别要访问的是哪一个托管的网站。
-
-* 造成的后果：如果在一台物理服务器上托管了两个网站www.site1.com和www.site2.com。用户1想去获取www.site1.com的主页，于是在它发送了的请求报文为请求行GET /index.html HTTP/1.0，这里并没有发送主机信息，所以很可能服务器返回的是www.site2.com的主页。
-
-### 设法让虚拟主机托管正常工作
-
-* 为了解决HTTP/1.0无法提供主机设别的缺陷，Web托管者需要开发变通的方案和约定来支持共享的虚拟主机托管。主要有四种技术：
-
-
-1、通过URL路径进行虚拟主机托管：可以通过分配不同的URL路径，用这种笨方法把共享服务器上的虚拟站点隔离开。例如，可以给每个逻辑网站一个专门的路径前缀。
-
-``` 
-     Joe的五金商店可以是：http://www.joes-hardware.com/joe/index.html
-
-     Mary的古董拍卖店可以是：http://www.marys-antiques.com/mary/index.html
-
-```
-
-当请求到达服务器时，其中并没有主机名信息，但服务器可以通过路径来区分它们。
-
-```
-     请求Joe的五金商店的网址是 GET /joe/index.html
-
-     请求Mary的古董拍卖店的网址是 GET /mary/index.html
-
-```
-
-显然这不是一个好方法，/joe和/mary这样的前缀是多余的，并且那种常规输入主机地址显示主页的约定不存在了！
-
-
-2、通过端口号进行虚拟主机进行托管：托管者为每个主机提供一个单独的端口号，用来区分每个网站。这个方法也有同样的显著问题，因为终端用户很少去输入端口号的。
-
-3、通过IP地址进行虚拟主机托管：一个更常用的、更好的方法是通过IP地址进行虚拟化。每个虚拟网站都分配一个或多个唯一的IP地址。所有虚拟网站的IP地址都绑定到同一个共享的服务器上。服务器可以查询HTTP连接的目的IP地址，并以此来判断客户端的目标网扎。这种方法对大的托管者来说，虚拟IP的主机托管能够工作，但它会带来一些麻烦。1）ip地址是有限制的，服务器上托管成百上千的虚拟站点的服务商不一定能实现愿望。2）IP地址是稀缺资源。3）服务器通过赋值服务器来增加容量时，ip地址短缺的问题就更严重了。
-
-4、通过Host首部进行虚拟主机托管：这个方法主要是在请求首部增加Host首部，用来发送目的主机信息和端口。
-
-#### 解释Host首部
-
-* 1）如果HTTP请求报文中的URL是绝对的（也就是说，包含方案和主机部分），就忽略Host首部的值。2）如果HTTP请求报文中的URL没有主机部分，而该请求带有Host首部，则主机/端口的值就从Host首部中取。3）如果通过1）和2）步都无法获得有效的主机，就向客户端返回400 Bad Request响应。
-
-### 使网站更可靠
-
-* 出现下列情况，网站是服务运作的。
-
-1、服务器宕机
-
-2、交通拥塞：服务器过载，甚至使它彻底停机
-
-3、网络中断或掉线
-
-* 常见解决办法：
-
-1、镜像的服务器集群，涉及的技术：HTTP重定向：该内容的URL会解析到主服务器的ip地址，然后它会发送重定向到复制服务器。DNS重定向：该内容的URL会解析到四个IP地址，DNS服务器可以选择发送给客户端的IP地址。
-
+## 内容提要
+
+* 本章主要介绍了关于在一台物理服务器上托管了很多的主机（也就是说一个电脑里面部署了两个或者更多网站），此时，客户端怎么样和服务器端沟通，才能无差错地访问对应资源的主机（用户1访问a网站的资源，那么就不能跑到b网站上获取资源）。以及介绍了一些服务器集群的概念！
+
+### 相关概念
+
+* Web主机托管：对内容资源的存储、协调以及管理的职责统称为Web主机托管。主机托管是服务器的主要功能之一。
+
+* 托管者：如果某个公司想建立一个网站，但不想自行管理服务器所需的软硬件，就需要主机托管服务，即托管者。
+
+### 主机托管服务
+
+* 专用托管：一台物理服务器对应一个主机
+
+* 虚拟主机托管：许多Web托管者通过让一些顾客共享一台计算机来提供便宜的Web主机托管服务，这称为共享主机托管或虚拟主机托管。每个网站看起来是托管在不同的服务器上，但实际上是托管在同一个物理服务器上。————但这并不意味着上千个网站是用一台PC机来提供服务的。托管者可以创建成排同样的服务器，称为服务器集群。
+
+### 虚拟服务器请求缺乏主机信息
+
+* 背景：不幸的是，HTTP/1.0中的一个设计缺陷会使虚拟主机托管者抓狂。HTTP/1.0规范中没有为共享的Web服务器提供任何方法来设别要访问的是哪一个托管的网站。
+
+* 造成的后果：如果在一台物理服务器上托管了两个网站www.site1.com和www.site2.com。用户1想去获取www.site1.com的主页，于是在它发送了的请求报文为请求行GET /index.html HTTP/1.0，这里并没有发送主机信息，所以很可能服务器返回的是www.site2.com的主页。
+
+### 设法让虚拟主机托管正常工作
+
+* 为了解决HTTP/1.0无法提供主机设别的缺陷，Web托管者需要开发变通的方案和约定来支持共享的虚拟主机托管。主要有四种技术：
+
+
+1、通过URL路径进行虚拟主机托管：可以通过分配不同的URL路径，用这种笨方法把共享服务器上的虚拟站点隔离开。例如，可以给每个逻辑网站一个专门的路径前缀。
+
+``` 
+     Joe的五金商店可以是：http://www.joes-hardware.com/joe/index.html
+
+     Mary的古董拍卖店可以是：http://www.marys-antiques.com/mary/index.html
+
+```
+
+当请求到达服务器时，其中并没有主机名信息，但服务器可以通过路径来区分它们。
+
+```
+     请求Joe的五金商店的网址是 GET /joe/index.html
+
+     请求Mary的古董拍卖店的网址是 GET /mary/index.html
+
+```
+
+显然这不是一个好方法，/joe和/mary这样的前缀是多余的，并且那种常规输入主机地址显示主页的约定不存在了！
+
+
+2、通过端口号进行虚拟主机进行托管：托管者为每个主机提供一个单独的端口号，用来区分每个网站。这个方法也有同样的显著问题，因为终端用户很少去输入端口号的。
+
+3、通过IP地址进行虚拟主机托管：一个更常用的、更好的方法是通过IP地址进行虚拟化。每个虚拟网站都分配一个或多个唯一的IP地址。所有虚拟网站的IP地址都绑定到同一个共享的服务器上。服务器可以查询HTTP连接的目的IP地址，并以此来判断客户端的目标网扎。这种方法对大的托管者来说，虚拟IP的主机托管能够工作，但它会带来一些麻烦。1）ip地址是有限制的，服务器上托管成百上千的虚拟站点的服务商不一定能实现愿望。2）IP地址是稀缺资源。3）服务器通过赋值服务器来增加容量时，ip地址短缺的问题就更严重了。
+
+4、通过Host首部进行虚拟主机托管：这个方法主要是在请求首部增加Host首部，用来发送目的主机信息和端口。
+
+#### 解释Host首部
+
+* 1）如果HTTP请求报文中的URL是绝对的（也就是说，包含方案和主机部分），就忽略Host首部的值。2）如果HTTP请求报文中的URL没有主机部分，而该请求带有Host首部，则主机/端口的值就从Host首部中取。3）如果通过1）和2）步都无法获得有效的主机，就向客户端返回400 Bad Request响应。
+
+### 使网站更可靠
+
+* 出现下列情况，网站是服务运作的。
+
+1、服务器宕机
+
+2、交通拥塞：服务器过载，甚至使它彻底停机
+
+3、网络中断或掉线
+
+* 常见解决办法：
+
+1、镜像的服务器集群，涉及的技术：HTTP重定向：该内容的URL会解析到主服务器的ip地址，然后它会发送重定向到复制服务器。DNS重定向：该内容的URL会解析到四个IP地址，DNS服务器可以选择发送给客户端的IP地址。
+
 2、内容分发网络
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/19 \345\217\221\345\270\203\347\263\273\347\273\237.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/19 \345\217\221\345\270\203\347\263\273\347\273\237.md"
similarity index 91%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/19 \345\217\221\345\270\203\347\263\273\347\273\237.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/19 \345\217\221\345\270\203\347\263\273\347\273\237.md"
index 403ffc93..8cdc047c 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/19 \345\217\221\345\270\203\347\263\273\347\273\237.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/19 \345\217\221\345\270\203\347\263\273\347\273\237.md"	
@@ -1,3 +1,3 @@
-## 内容提要
-
+## 内容提要
+
 * 略
\ No newline at end of file
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/20 \351\207\215\345\256\232\345\220\221\344\270\216\350\264\237\350\275\275\345\235\207\350\241\241.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/20 \351\207\215\345\256\232\345\220\221\344\270\216\350\264\237\350\275\275\345\235\207\350\241\241.md"
similarity index 96%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/20 \351\207\215\345\256\232\345\220\221\344\270\216\350\264\237\350\275\275\345\235\207\350\241\241.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/20 \351\207\215\345\256\232\345\220\221\344\270\216\350\264\237\350\275\275\345\235\207\350\241\241.md"
index 10e08838..2fd0bdd1 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/20 \351\207\215\345\256\232\345\220\221\344\270\216\350\264\237\350\275\275\345\235\207\350\241\241.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/20 \351\207\215\345\256\232\345\220\221\344\270\216\350\264\237\350\275\275\345\235\207\350\241\241.md"	
@@ -1,56 +1,56 @@
-## 内容提要
-
-* 本章主要介绍了网站重定向和负载均衡的一些技术，术语网站架构方面的知识！
-
-### 技术概览
-
-* 重定向技术通常可以用来确定报文是否终结于某个代理、缓存或服务器集群中某台特定的服务器。重定向技术可以将报文发送到客户端没有显示请求的地方去。与此需要涉及到的技术：
-
-1、HTTP重定向
-
-2、DNS重定向
-
-3、任播路由
-
-4、策略路由
-
-5、IP MAC转发
-
-6、IP地址转发
-
-7、WCCP（Web缓存协调协议）
-
-8、ICP（缓存间通信协议）
-
-9、HTCP（超文本缓存协议）
-
-10、NECP（网元控制协议）
-
-11、CARP（缓存阵列路由协议）
-
-12、WRAD（Web代理自动发现协议）
-
-### 为什么要重定向
-
-* 原因如下：
-
-1、 可靠地执行HTTP事务
-
-2、最小化时延
-
-3、节约网络带宽
-
-
-### 重定向到何地
-
-* 重定向把URL的每条请求都发送到最佳的Web服务器上去（最靠近客户端的、或负载最轻的或采用其他优化策略选择的服务器）
-
-### 通用的重定向方法
-
-1、HTTP重定向：原始服务器通过发送重定向响应报文，让客户端去其它可用的资源地点请求资源。常见发送状态码为302的响应报文，有以下缺点：1）原始服务器处理负载较大；2）增加了用户时延，因为需要多一次访问原始服务器；3）如果重定向服务器出现故障，站点就会瘫痪。
-
-2、DNS重定向：其实tcp/ip视同ip地址来确定一个连接的，所以DNS重定向的原理就是通过DNS解析器确定合适的ip地址路劲来建立连接的。相关技术有DNS轮转。
-
-
-### 待续......
-
+## 内容提要
+
+* 本章主要介绍了网站重定向和负载均衡的一些技术，术语网站架构方面的知识！
+
+### 技术概览
+
+* 重定向技术通常可以用来确定报文是否终结于某个代理、缓存或服务器集群中某台特定的服务器。重定向技术可以将报文发送到客户端没有显示请求的地方去。与此需要涉及到的技术：
+
+1、HTTP重定向
+
+2、DNS重定向
+
+3、任播路由
+
+4、策略路由
+
+5、IP MAC转发
+
+6、IP地址转发
+
+7、WCCP（Web缓存协调协议）
+
+8、ICP（缓存间通信协议）
+
+9、HTCP（超文本缓存协议）
+
+10、NECP（网元控制协议）
+
+11、CARP（缓存阵列路由协议）
+
+12、WRAD（Web代理自动发现协议）
+
+### 为什么要重定向
+
+* 原因如下：
+
+1、 可靠地执行HTTP事务
+
+2、最小化时延
+
+3、节约网络带宽
+
+
+### 重定向到何地
+
+* 重定向把URL的每条请求都发送到最佳的Web服务器上去（最靠近客户端的、或负载最轻的或采用其他优化策略选择的服务器）
+
+### 通用的重定向方法
+
+1、HTTP重定向：原始服务器通过发送重定向响应报文，让客户端去其它可用的资源地点请求资源。常见发送状态码为302的响应报文，有以下缺点：1）原始服务器处理负载较大；2）增加了用户时延，因为需要多一次访问原始服务器；3）如果重定向服务器出现故障，站点就会瘫痪。
+
+2、DNS重定向：其实tcp/ip视同ip地址来确定一个连接的，所以DNS重定向的原理就是通过DNS解析器确定合适的ip地址路劲来建立连接的。相关技术有DNS轮转。
+
+
+### 待续......
+
diff --git "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/21 \346\227\245\345\277\227\350\256\260\345\275\225\344\270\216\344\275\277\347\224\250\346\203\205\345\206\265\350\267\237\350\270\252.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/21 \346\227\245\345\277\227\350\256\260\345\275\225\344\270\216\344\275\277\347\224\250\346\203\205\345\206\265\350\267\237\350\270\252.md"
similarity index 97%
rename from "10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/21 \346\227\245\345\277\227\350\256\260\345\275\225\344\270\216\344\275\277\347\224\250\346\203\205\345\206\265\350\267\237\350\270\252.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/21 \346\227\245\345\277\227\350\256\260\345\275\225\344\270\216\344\275\277\347\224\250\346\203\205\345\206\265\350\267\237\350\270\252.md"
index f23f5c4e..47219102 100644
--- "a/10 - Reading Notes/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/21 \346\227\245\345\277\227\350\256\260\345\275\225\344\270\216\344\275\277\347\224\250\346\203\205\345\206\265\350\267\237\350\270\252.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/HTTP\346\235\203\345\250\201\346\214\207\345\215\227/21 \346\227\245\345\277\227\350\256\260\345\275\225\344\270\216\344\275\277\347\224\250\346\203\205\345\206\265\350\267\237\350\270\252.md"	
@@ -1,154 +1,154 @@
-## 内容提要
-
-* 本章主要介绍了代理缓存和服务器日志记录的一些情况，以及怎么解决代理缓存问题造成日志记录出现遗漏的问题！
-
-### 为什么需要日志记录
-
-* 几乎所有的服务器和代理都会记录下它们所处理的HTTP事务摘要。这么做出于一系列的原因：跟踪使用情况、安全性、计费、错误检验，等等。
-
-### 那些内容该记录
-
-* 如果把访问的点点滴滴都一五一十的记录下来，是一个很没有意义的过程，暂且不说有的网站的事务量超大到难以计数的问题，把全部信息记录下来，这个日志文件可想而知得有多大。就日志记录对我们统计需求的作用而言，因为有的数据对我们来说意义不大，甚至可能看都不会看一眼，所以有选择性的记录一些内容变得很重要。通常，只记录事务的基本信息就行了。通常会记录下来的几个字段示例为：
-
-- - HTTP方法：主要记录事务用了什么方法
-
-- - 客户端和服务器的HTTP版本：给出客户端和服务器有关的提示，比如兼容性提示什么的
-
-- - 所请求资源的URL：记录Web站点某个资源的访问频率和受欢迎程度
-
-- - 响应的HTTP状态码：主要说明请求的执行情况成功与否
-
-- - 请求和响应报文的尺寸（包含所有的实体主体部分）：记录大小
-
-- - 事务开始时的时间戳：记录发生时间
-
-- - Referer首部和User-Agent首部的值：主要记录从那个页面跳过来以及用户代理
-
-### 日志格式
-
-* 大部分http程序都支持管理者配置日志格式，以便于更好地利用已有工具对日志进行处理，从而方便汇总。
-
-#### 常用日志格式
-
-* 以下是常用格式字段
-
-```
-	remotehost       请求端机器的主机名或IP地址（如果没有配置服务器去执行反
-					 向DNS或无法查找请求段的主机名，就使用IP地址）
-
-	username         如果执行了ident查找，就是请求端已认证的用户名
-
-	auth-username    如果进行了认证，就是请求端已认证的用户名
-
-	timestamp        请求的日期和时间
-
-	request-line     精确的HTTP请求行文本，GET /index.html HTTP/1.1
-
-	response-code    响应中返回的HTTP状态码
-
-	response-size    响应主体中的Content-Length,如果响应中没有返回主体，就记录0
-
-
-```
-
-
-#### 组合日志格式
-
-* 组合日志格式与常用日志格式很类似。实际上，它就是常用日志格式的精确镜像，只是添加了两个字段。User-Agent字段用于说明是哪个HTTP客户端应用程序在发起已被记录的请求，而Referer字段则提供了更多与请求端在何处找到这个URL的有关信息。
-
-* 新加的组合日志格式字段
-
-```
-	Referer            Referer首部的内容
-
-	User-Agent         User-Agent首部的内容
-
-```
-
-#### 网景扩展日志格式
-
-* 网景的格式是基于NCSA的常用日志格式的，但它扩展了该格式，以支持与代理和Web缓存这样的HTTP应用程序相关的字段。网景扩展日志格式的前7个字段与常用日志格式中的那些字段完全相同。
-
-* 网景扩展日志格式新加的字段
-
-```
-	proxy-response-code            如果事务处理经历了某个代理，就是从服务器传往代理的HTTP响应码
-
-	proxy-response-size            如果事务处理经历过了某个代理，就是发送给代理的服务器响应实体
-								   的Content-Length
-
-	client-request-size 		   发给代理的客户端请求的所有主体或实体的Content-Length
-
-	proxy-request-size			   如果事务处理经历过了某个代理，就是代理发往服务器的
-								   请求的所有主体或者实体的Content-Length
-
-	client-request-hdr-size		   以字节为单位的客户端请求首部的长度
-
-	proxy-response-hdr-size		   如果事务处理经过了某个代理，就是以字节为单位的，发送给请求
-								   端的代理响应首部的长度
-
-	proxy-request-hdr-size         如果事务处理经历过了某个代理，就是以字节为单位的，发送
-								   给服务器的代理请求首部的长度
-
-	server-response-hdr-size       以字节为单位的，服务器响应首部的长度
-
-	proxy-timetamp				   如果事务处理经历过了某个代理，就是请求和响应经过代理
-								   传输所经过的时间（单位为秒）
-
-```
-
-#### 网景扩展2日志格式
-
-* 另一种网景日志格式，网景扩展2日志格式采用了扩展日志格式，并添加了一些与HTTP代理和Web缓存应用程序有关的附加信息。这些附加字段有助于更好地描绘HTTP客户端和HTTP代理应用程序间的交互图景。
-
-* 附加的网景扩展2日志格式字段
-
-```
-	route                           代理用来向客户端发送请求的路径
-
-	client-finish-status-code       客户端完成状态码。说明了发送给代理的客户端请求
-									是成功完成（FIN）了，还是被打断了（INTR）
-
-	proxy-finish-status-code		代理完成状态码，说明代理发送给服务器的请求是成功完成（FIN）
-									了，还是被打断了（INTR）
-
-	cache-result-code				缓存结果代码；说明缓存是如何响应请求的
-
-```
-
-#### Squid代理日志格式
-
-* Squid日志格式字段
-
-```
-	timestamp            请求到达时的时间戳，是从格林尼治标准时间1970年
-						 1月1日开始的秒数
-
-	time-elapsed		 请求和响应通过代理传输所经历的时间（以毫秒为单位）
-
-	host-ip				 客户端（请求端）主机的IP地址
-
-	result-code/status   result字段是Squid类型的，用来说明在此请求过程中代理
-						 采取了什么动作，code字段是代理发送客户端的HTTP响应代码
-
-	size 				 代理响应客户端的字节长度，包括HTTP响应首部和主体
-
-	method               客户端请求的HTTP方法
-
-	url                  客户端请求中的URL
-
-	rfc931-ident         客户端经过认证的用户名
-
-	hierarchy/from       与网景格式中的route字段一样，hierarchy字段说明了代理向客户端
-						 发送请求时经由的路径。from字段说明了代理发起请求时的服务器名称
-
-	content-type 		 代理响应实体的Content-Type
-
-
-```
-
-### 命中率测量 
-
-* 缓存服务器位于客户端和服务器之间，用于防止服务器同时处理大量访问请求（这正是缓存的目的）。缓存要处理很多HTTP请求，并在不访问原始服务器的情况下满足它们的请求，服务器中没有客户端访问其内容的记录，导致日志文件中出现遗漏。由于日志数据会遗失，所以，内容提供者会对其最重要的页面进行缓存清除（cachebust）。缓存清除是指内容提供者有意将某些内容设置为无法缓存，这样，所有对此内容的请求都会被导向原始服务器。于是，原始服务器就可以记录下访问情况了。不使用缓存可能会生成更好的日志，但会减缓原始服务器和网络的请求速度，并增其负荷。
-
+## 内容提要
+
+* 本章主要介绍了代理缓存和服务器日志记录的一些情况，以及怎么解决代理缓存问题造成日志记录出现遗漏的问题！
+
+### 为什么需要日志记录
+
+* 几乎所有的服务器和代理都会记录下它们所处理的HTTP事务摘要。这么做出于一系列的原因：跟踪使用情况、安全性、计费、错误检验，等等。
+
+### 那些内容该记录
+
+* 如果把访问的点点滴滴都一五一十的记录下来，是一个很没有意义的过程，暂且不说有的网站的事务量超大到难以计数的问题，把全部信息记录下来，这个日志文件可想而知得有多大。就日志记录对我们统计需求的作用而言，因为有的数据对我们来说意义不大，甚至可能看都不会看一眼，所以有选择性的记录一些内容变得很重要。通常，只记录事务的基本信息就行了。通常会记录下来的几个字段示例为：
+
+- - HTTP方法：主要记录事务用了什么方法
+
+- - 客户端和服务器的HTTP版本：给出客户端和服务器有关的提示，比如兼容性提示什么的
+
+- - 所请求资源的URL：记录Web站点某个资源的访问频率和受欢迎程度
+
+- - 响应的HTTP状态码：主要说明请求的执行情况成功与否
+
+- - 请求和响应报文的尺寸（包含所有的实体主体部分）：记录大小
+
+- - 事务开始时的时间戳：记录发生时间
+
+- - Referer首部和User-Agent首部的值：主要记录从那个页面跳过来以及用户代理
+
+### 日志格式
+
+* 大部分http程序都支持管理者配置日志格式，以便于更好地利用已有工具对日志进行处理，从而方便汇总。
+
+#### 常用日志格式
+
+* 以下是常用格式字段
+
+```
+	remotehost       请求端机器的主机名或IP地址（如果没有配置服务器去执行反
+					 向DNS或无法查找请求段的主机名，就使用IP地址）
+
+	username         如果执行了ident查找，就是请求端已认证的用户名
+
+	auth-username    如果进行了认证，就是请求端已认证的用户名
+
+	timestamp        请求的日期和时间
+
+	request-line     精确的HTTP请求行文本，GET /index.html HTTP/1.1
+
+	response-code    响应中返回的HTTP状态码
+
+	response-size    响应主体中的Content-Length,如果响应中没有返回主体，就记录0
+
+
+```
+
+
+#### 组合日志格式
+
+* 组合日志格式与常用日志格式很类似。实际上，它就是常用日志格式的精确镜像，只是添加了两个字段。User-Agent字段用于说明是哪个HTTP客户端应用程序在发起已被记录的请求，而Referer字段则提供了更多与请求端在何处找到这个URL的有关信息。
+
+* 新加的组合日志格式字段
+
+```
+	Referer            Referer首部的内容
+
+	User-Agent         User-Agent首部的内容
+
+```
+
+#### 网景扩展日志格式
+
+* 网景的格式是基于NCSA的常用日志格式的，但它扩展了该格式，以支持与代理和Web缓存这样的HTTP应用程序相关的字段。网景扩展日志格式的前7个字段与常用日志格式中的那些字段完全相同。
+
+* 网景扩展日志格式新加的字段
+
+```
+	proxy-response-code            如果事务处理经历了某个代理，就是从服务器传往代理的HTTP响应码
+
+	proxy-response-size            如果事务处理经历过了某个代理，就是发送给代理的服务器响应实体
+								   的Content-Length
+
+	client-request-size 		   发给代理的客户端请求的所有主体或实体的Content-Length
+
+	proxy-request-size			   如果事务处理经历过了某个代理，就是代理发往服务器的
+								   请求的所有主体或者实体的Content-Length
+
+	client-request-hdr-size		   以字节为单位的客户端请求首部的长度
+
+	proxy-response-hdr-size		   如果事务处理经过了某个代理，就是以字节为单位的，发送给请求
+								   端的代理响应首部的长度
+
+	proxy-request-hdr-size         如果事务处理经历过了某个代理，就是以字节为单位的，发送
+								   给服务器的代理请求首部的长度
+
+	server-response-hdr-size       以字节为单位的，服务器响应首部的长度
+
+	proxy-timetamp				   如果事务处理经历过了某个代理，就是请求和响应经过代理
+								   传输所经过的时间（单位为秒）
+
+```
+
+#### 网景扩展2日志格式
+
+* 另一种网景日志格式，网景扩展2日志格式采用了扩展日志格式，并添加了一些与HTTP代理和Web缓存应用程序有关的附加信息。这些附加字段有助于更好地描绘HTTP客户端和HTTP代理应用程序间的交互图景。
+
+* 附加的网景扩展2日志格式字段
+
+```
+	route                           代理用来向客户端发送请求的路径
+
+	client-finish-status-code       客户端完成状态码。说明了发送给代理的客户端请求
+									是成功完成（FIN）了，还是被打断了（INTR）
+
+	proxy-finish-status-code		代理完成状态码，说明代理发送给服务器的请求是成功完成（FIN）
+									了，还是被打断了（INTR）
+
+	cache-result-code				缓存结果代码；说明缓存是如何响应请求的
+
+```
+
+#### Squid代理日志格式
+
+* Squid日志格式字段
+
+```
+	timestamp            请求到达时的时间戳，是从格林尼治标准时间1970年
+						 1月1日开始的秒数
+
+	time-elapsed		 请求和响应通过代理传输所经历的时间（以毫秒为单位）
+
+	host-ip				 客户端（请求端）主机的IP地址
+
+	result-code/status   result字段是Squid类型的，用来说明在此请求过程中代理
+						 采取了什么动作，code字段是代理发送客户端的HTTP响应代码
+
+	size 				 代理响应客户端的字节长度，包括HTTP响应首部和主体
+
+	method               客户端请求的HTTP方法
+
+	url                  客户端请求中的URL
+
+	rfc931-ident         客户端经过认证的用户名
+
+	hierarchy/from       与网景格式中的route字段一样，hierarchy字段说明了代理向客户端
+						 发送请求时经由的路径。from字段说明了代理发起请求时的服务器名称
+
+	content-type 		 代理响应实体的Content-Type
+
+
+```
+
+### 命中率测量 
+
+* 缓存服务器位于客户端和服务器之间，用于防止服务器同时处理大量访问请求（这正是缓存的目的）。缓存要处理很多HTTP请求，并在不访问原始服务器的情况下满足它们的请求，服务器中没有客户端访问其内容的记录，导致日志文件中出现遗漏。由于日志数据会遗失，所以，内容提供者会对其最重要的页面进行缓存清除（cachebust）。缓存清除是指内容提供者有意将某些内容设置为无法缓存，这样，所有对此内容的请求都会被导向原始服务器。于是，原始服务器就可以记录下访问情况了。不使用缓存可能会生成更好的日志，但会减缓原始服务器和网络的请求速度，并增其负荷。
+
 * 命中率测量协议是对HTTP的一种扩展，它为这个问题提供了一种解决方案。命中率测量协议要求缓存周期性地向原始服务器汇报缓存访问的统计数据。
\ No newline at end of file
diff --git "a/10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/all.md"
similarity index 100%
rename from "10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/all.md"
diff --git "a/10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2545\347\253\240 \344\274\232\350\257\235\350\267\237\350\270\252.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2545\347\253\240 \344\274\232\350\257\235\350\267\237\350\270\252.md"
similarity index 100%
rename from "10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2545\347\253\240 \344\274\232\350\257\235\350\267\237\350\270\252.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2545\347\253\240 \344\274\232\350\257\235\350\267\237\350\270\252.md"
diff --git "a/10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2546\347\253\240 \350\277\207\346\273\244\345\231\250Filter.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2546\347\253\240 \350\277\207\346\273\244\345\231\250Filter.md"
similarity index 100%
rename from "10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2546\347\253\240 \350\277\207\346\273\244\345\231\250Filter.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2546\347\253\240 \350\277\207\346\273\244\345\231\250Filter.md"
diff --git "a/10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2547\347\253\240 \347\233\221\345\220\254\345\231\250Listener.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2547\347\253\240 \347\233\221\345\220\254\345\231\250Listener.md"
similarity index 100%
rename from "10 - Reading Notes/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2547\347\253\240 \347\233\221\345\220\254\345\231\250Listener.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/JavaWeb\346\225\264\345\220\210\345\274\200\345\217\221\347\216\213\350\200\205\345\275\222\346\235\245/\347\254\2547\347\253\240 \347\233\221\345\220\254\345\231\250Listener.md"
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/all.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/all.md"
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2541\347\253\240 Java\345\244\232\347\272\277\347\250\213\346\212\200\350\203\275.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2541\347\253\240 Java\345\244\232\347\272\277\347\250\213\346\212\200\350\203\275.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2541\347\253\240 Java\345\244\232\347\272\277\347\250\213\346\212\200\350\203\275.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2541\347\253\240 Java\345\244\232\347\272\277\347\250\213\346\212\200\350\203\275.md"
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2542\347\253\240 \345\257\271\350\261\241\345\217\212\345\217\230\351\207\217\347\232\204\345\271\266\345\217\221\350\256\277\351\227\256.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2542\347\253\240 \345\257\271\350\261\241\345\217\212\345\217\230\351\207\217\347\232\204\345\271\266\345\217\221\350\256\277\351\227\256.md"
similarity index 96%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2542\347\253\240 \345\257\271\350\261\241\345\217\212\345\217\230\351\207\217\347\232\204\345\271\266\345\217\221\350\256\277\351\227\256.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2542\347\253\240 \345\257\271\350\261\241\345\217\212\345\217\230\351\207\217\347\232\204\345\271\266\345\217\221\350\256\277\351\227\256.md"
index e1900743..f050e7fe 100644
--- "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2542\347\253\240 \345\257\271\350\261\241\345\217\212\345\217\230\351\207\217\347\232\204\345\271\266\345\217\221\350\256\277\351\227\256.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2542\347\253\240 \345\257\271\350\261\241\345\217\212\345\217\230\351\207\217\347\232\204\345\271\266\345\217\221\350\256\277\351\227\256.md"	
@@ -1,5 +1,5 @@
-### 2.1 Synchronized ['sɪŋkrənaɪzd]  同步方法
-
-### 2.1 Synchronized 同步语句块
-
-### 2.3 Volatile [ˈvɑ:lətl] 关键字
+### 2.1 Synchronized ['sɪŋkrənaɪzd]  同步方法
+
+### 2.1 Synchronized 同步语句块
+
+### 2.3 Volatile [ˈvɑ:lətl] 关键字
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2543\347\253\240 \347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2543\347\253\240 \347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"
similarity index 93%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2543\347\253\240 \347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2543\347\253\240 \347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 1fa78464..d3bcea2f 100644
--- "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2543\347\253\240 \347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2543\347\253\240 \347\272\277\347\250\213\351\227\264\351\200\232\344\277\241.md"	
@@ -1,25 +1,25 @@
-### 3.1 等待/通知机制
-
-  wait()
-
-  notify()
-
-  notifyAll()
-
-  wait(long)
-
-### 3.2 方法join的使用
-
-  join() 让父线程等待子线程结束之后才能继续运行。
-
-  join(long)
-
-  join(long)与sleep(long)的区别
-
-### 3.3 类ThreadLocal的使用
-
-  方法get()
-
-### 3.4 类InheritableThreadLocal的使用
-
-  值继承
+### 3.1 等待/通知机制
+
+  wait()
+
+  notify()
+
+  notifyAll()
+
+  wait(long)
+
+### 3.2 方法join的使用
+
+  join() 让父线程等待子线程结束之后才能继续运行。
+
+  join(long)
+
+  join(long)与sleep(long)的区别
+
+### 3.3 类ThreadLocal的使用
+
+  方法get()
+
+### 3.4 类InheritableThreadLocal的使用
+
+  值继承
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2544\347\253\240 Lock\347\232\204\344\275\277\347\224\250.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2544\347\253\240 Lock\347\232\204\344\275\277\347\224\250.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2544\347\253\240 Lock\347\232\204\344\275\277\347\224\250.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2544\347\253\240 Lock\347\232\204\344\275\277\347\224\250.md"
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2545\347\253\240 \345\256\232\346\227\266\345\231\250Timer.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2545\347\253\240 \345\256\232\346\227\266\345\231\250Timer.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2545\347\253\240 \345\256\232\346\227\266\345\231\250Timer.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2545\347\253\240 \345\256\232\346\227\266\345\231\250Timer.md"
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2547\347\253\240 \346\223\215\344\275\234\347\240\201\345\212\251\350\256\260\347\254\246.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2546\347\253\240 \345\215\225\344\276\213\346\250\241\345\274\217\344\270\216\345\244\232\347\272\277\347\250\213.md"
similarity index 100%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2547\347\253\240 \346\223\215\344\275\234\347\240\201\345\212\251\350\256\260\347\254\246.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2546\347\253\240 \345\215\225\344\276\213\346\250\241\345\274\217\344\270\216\345\244\232\347\272\277\347\250\213.md"
diff --git "a/10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2547\347\253\240 \346\213\276\351\201\227\345\242\236\350\241\245.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2547\347\253\240 \346\213\276\351\201\227\345\242\236\350\241\245.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2547\347\253\240 \346\213\276\351\201\227\345\242\236\350\241\245.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\244\232\347\272\277\347\250\213\347\274\226\347\250\213\346\240\270\345\277\203\346\212\200\346\234\257/\347\254\2547\347\253\240 \346\213\276\351\201\227\345\242\236\350\241\245.md"
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/all.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/all.md"
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2542\347\253\240 \347\272\277\347\250\213\345\256\211\345\205\250\346\200\247.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2542\347\253\240 \347\272\277\347\250\213\345\256\211\345\205\250\346\200\247.md"
similarity index 96%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2542\347\253\240 \347\272\277\347\250\213\345\256\211\345\205\250\346\200\247.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2542\347\253\240 \347\272\277\347\250\213\345\256\211\345\205\250\346\200\247.md"
index 8497924c..92f7fde9 100644
--- "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2542\347\253\240 \347\272\277\347\250\213\345\256\211\345\205\250\346\200\247.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2542\347\253\240 \347\272\277\347\250\213\345\256\211\345\205\250\346\200\247.md"	
@@ -1,27 +1,27 @@
-2.1 什么是线程安全性
-	正确性
-	
-	当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，
-这个类都能表现出正确的行为，那么就称这个类是线程安全的。	
-
-
-	无状态对象一定是线程安全的。
-	
-2.2 原子性
-
-	线程安全对象
-	Java.util.concurrent.atomic
-	
-	AtomicLong incrementAndGet()
-	
-2.3.2 重入
-
-	重入意味着获取锁的操作的粒度是“线程”
-	
-2.5 活跃性与性能
-
-	不良并发
-	
-3.1 可见性
-
+2.1 什么是线程安全性
+	正确性
+	
+	当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，
+这个类都能表现出正确的行为，那么就称这个类是线程安全的。	
+
+
+	无状态对象一定是线程安全的。
+	
+2.2 原子性
+
+	线程安全对象
+	Java.util.concurrent.atomic
+	
+	AtomicLong incrementAndGet()
+	
+2.3.2 重入
+
+	重入意味着获取锁的操作的粒度是“线程”
+	
+2.5 活跃性与性能
+
+	不良并发
+	
+3.1 可见性
+
 	加锁机制既可以确保可见性又可以确保原子性，而volatile变量智能确保可见性
\ No newline at end of file
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2545\347\253\240 \345\237\272\347\241\200\346\236\204\345\273\272\346\250\241\345\235\227.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2545\347\253\240 \345\237\272\347\241\200\346\236\204\345\273\272\346\250\241\345\235\227.md"
similarity index 97%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2545\347\253\240 \345\237\272\347\241\200\346\236\204\345\273\272\346\250\241\345\235\227.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2545\347\253\240 \345\237\272\347\241\200\346\236\204\345\273\272\346\250\241\345\235\227.md"
index a4814e5a..81bfb33b 100644
--- "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2545\347\253\240 \345\237\272\347\241\200\346\236\204\345\273\272\346\250\241\345\235\227.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2545\347\253\240 \345\237\272\347\241\200\346\236\204\345\273\272\346\250\241\345\235\227.md"	
@@ -1,53 +1,53 @@
-### 5.1 同步容器类
-
-  Vector Hashtable
-
-
-### 5.2 并发容器
-
-  ConcurrentMap
-
-  CopyOnWriteArrayList
-
-### 5.3 阻塞队列 和 生产者-消费者模式
-
-  BlockingQueue
-
-### 5.4 阻塞方法与中断方法
-
-  **传递InterruptException** 避开这个异常通常是最明智的策略 ———— 只需把 InterruptException 传递给方法的调用者。
-    传递的方法包括 根本不捕获该异常，或者捕获该异常，然后在执行某种简单的清理工作后再次抛出这个异常。
-
-  **恢复中断**
-
-### 5.5 同步工具类
-
-  所有的同步工具都包含一些 **特定的结构化属性**：它们封装了一些状态，这些状态将 **决定** 执行同步工具类的 **线程** 是 **继续执行还是等待**，此外还提供了一些方法对状态进行操作，以及一些方法用于高效地等待同步工具类 **进入预期状态**。
-
-#### 5.5.1 闭锁(Latch)
-  闭锁是一种同步工具类，可以延迟线程的进度直到其达到终止状态。
-  闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因此这扇门会永远保持打开状态。**闭锁可以用来确保某些活动指导其他活动都完成后才继续执行。**
-
-  **CountDownLatch**
-
-#### 5.5.2 FutureTask
-
-  FutureTask 也可用作闭锁
-
-#### 5.5.3 信号量(Semaphore)
-
-  计数信号量（Counting Semaphore） 用来 **控制** **同时访问** 某个 **特定资源** 的 **操作数量** ，或者 **同时执行** 某个 **指定操作的数量**【CPJ 3.4.1】。计数信号量还可以用来实现某种 **资源池** ，或者对容器 **施加边界**
-
-  Semaphore
-
-#### 5.5.4 栅栏(Barrier)
-
-  栅栏类似于闭锁，它能 **阻塞一组线程直到某个事件发生**。
-  栅栏与闭锁的关键区别在于 所有线程必须同时到达栅栏位置，才能继续执行，。闭锁用于等待事件，而栅栏用于等待其他线程。
-  栅栏用于实现一些协议。
-
-  **CyclicBarrier**
-
-### 5.6 构建高效且可伸缩的结果缓存
-
-  ConcurrentHashMap
+### 5.1 同步容器类
+
+  Vector Hashtable
+
+
+### 5.2 并发容器
+
+  ConcurrentMap
+
+  CopyOnWriteArrayList
+
+### 5.3 阻塞队列 和 生产者-消费者模式
+
+  BlockingQueue
+
+### 5.4 阻塞方法与中断方法
+
+  **传递InterruptException** 避开这个异常通常是最明智的策略 ———— 只需把 InterruptException 传递给方法的调用者。
+    传递的方法包括 根本不捕获该异常，或者捕获该异常，然后在执行某种简单的清理工作后再次抛出这个异常。
+
+  **恢复中断**
+
+### 5.5 同步工具类
+
+  所有的同步工具都包含一些 **特定的结构化属性**：它们封装了一些状态，这些状态将 **决定** 执行同步工具类的 **线程** 是 **继续执行还是等待**，此外还提供了一些方法对状态进行操作，以及一些方法用于高效地等待同步工具类 **进入预期状态**。
+
+#### 5.5.1 闭锁(Latch)
+  闭锁是一种同步工具类，可以延迟线程的进度直到其达到终止状态。
+  闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因此这扇门会永远保持打开状态。**闭锁可以用来确保某些活动指导其他活动都完成后才继续执行。**
+
+  **CountDownLatch**
+
+#### 5.5.2 FutureTask
+
+  FutureTask 也可用作闭锁
+
+#### 5.5.3 信号量(Semaphore)
+
+  计数信号量（Counting Semaphore） 用来 **控制** **同时访问** 某个 **特定资源** 的 **操作数量** ，或者 **同时执行** 某个 **指定操作的数量**【CPJ 3.4.1】。计数信号量还可以用来实现某种 **资源池** ，或者对容器 **施加边界**
+
+  Semaphore
+
+#### 5.5.4 栅栏(Barrier)
+
+  栅栏类似于闭锁，它能 **阻塞一组线程直到某个事件发生**。
+  栅栏与闭锁的关键区别在于 所有线程必须同时到达栅栏位置，才能继续执行，。闭锁用于等待事件，而栅栏用于等待其他线程。
+  栅栏用于实现一些协议。
+
+  **CyclicBarrier**
+
+### 5.6 构建高效且可伸缩的结果缓存
+
+  ConcurrentHashMap
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2546\347\253\240 \344\273\273\345\212\241\346\211\247\350\241\214.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2546\347\253\240 \344\273\273\345\212\241\346\211\247\350\241\214.md"
similarity index 96%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2546\347\253\240 \344\273\273\345\212\241\346\211\247\350\241\214.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2546\347\253\240 \344\273\273\345\212\241\346\211\247\350\241\214.md"
index b8279298..818867d2 100644
--- "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2546\347\253\240 \344\273\273\345\212\241\346\211\247\350\241\214.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2546\347\253\240 \344\273\273\345\212\241\346\211\247\350\241\214.md"	
@@ -1,59 +1,59 @@
-### 6.1 在线程中执行任务
-
-  **串行地执行任务**
-
-  **显式地为任务创建线程**
-
-  **无限制创建线程的不足**
-    线程生命周期的开销非常高
-    资源消耗
-    稳定性
-
-### 6.2 Executor框架
-
-```
-public interface Executor{
-  void execute(Runnable command)；
-}
-```
-
-为灵活且强大的异步任务执行框架提供了基础，该框架支持多种不同类型的任务执行策略。
-提供了一种标准的方法将任务的提交过程与执行过程解耦开来，并用Runnable来表示任务。
-Executor 的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。
-
-#### 6.2.2 执行策略
-
-#### 6.2.3 线程池
-
-#### 6.2.4 Executor的生命周期
-
-#### 6.2.5 延迟任务和周期任务
-
-  Timer 支持绝对时间 而不是 相对时间的调度机制，因此任务的执行对系统时钟变化很敏感
-
-  ScheduleThreadPoolExecutor 只支持基于相对时间的调度
-
-### 6.3 找出可利用的并行性
-
-#### 6.3.1 示例：串行的 **页面渲染器**
-
-#### 6.3.2 携带结果的任务Callable与Future
-
-  Future.get()
-  Future.get(long timeout,TimeUnit unit)
-
-#### 6.3.3 示例：使用Future实现 **页面渲染器**
-
-#### 6.3.4 在异构任务并行化中存在的局限
-
-#### 6.3.5 CompletionService:Executor 与 BlockingQueue
-
-  CompletionService.take()
-
-#### 6.3.6 示例：使用CompletionService实现 **页面渲染器**
-
-#### 6.3.7 为任务设置时限
-
-#### 6.3.8 示例：旅行预定门户网站
-
-  InvokeAll()
+### 6.1 在线程中执行任务
+
+  **串行地执行任务**
+
+  **显式地为任务创建线程**
+
+  **无限制创建线程的不足**
+    线程生命周期的开销非常高
+    资源消耗
+    稳定性
+
+### 6.2 Executor框架
+
+```
+public interface Executor{
+  void execute(Runnable command)；
+}
+```
+
+为灵活且强大的异步任务执行框架提供了基础，该框架支持多种不同类型的任务执行策略。
+提供了一种标准的方法将任务的提交过程与执行过程解耦开来，并用Runnable来表示任务。
+Executor 的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。
+
+#### 6.2.2 执行策略
+
+#### 6.2.3 线程池
+
+#### 6.2.4 Executor的生命周期
+
+#### 6.2.5 延迟任务和周期任务
+
+  Timer 支持绝对时间 而不是 相对时间的调度机制，因此任务的执行对系统时钟变化很敏感
+
+  ScheduleThreadPoolExecutor 只支持基于相对时间的调度
+
+### 6.3 找出可利用的并行性
+
+#### 6.3.1 示例：串行的 **页面渲染器**
+
+#### 6.3.2 携带结果的任务Callable与Future
+
+  Future.get()
+  Future.get(long timeout,TimeUnit unit)
+
+#### 6.3.3 示例：使用Future实现 **页面渲染器**
+
+#### 6.3.4 在异构任务并行化中存在的局限
+
+#### 6.3.5 CompletionService:Executor 与 BlockingQueue
+
+  CompletionService.take()
+
+#### 6.3.6 示例：使用CompletionService实现 **页面渲染器**
+
+#### 6.3.7 为任务设置时限
+
+#### 6.3.8 示例：旅行预定门户网站
+
+  InvokeAll()
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2547\347\253\240 \345\217\226\346\266\210\344\270\216\345\205\263\351\227\255.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2547\347\253\240 \345\217\226\346\266\210\344\270\216\345\205\263\351\227\255.md"
similarity index 97%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2547\347\253\240 \345\217\226\346\266\210\344\270\216\345\205\263\351\227\255.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2547\347\253\240 \345\217\226\346\266\210\344\270\216\345\205\263\351\227\255.md"
index 9b73ae9a..2fb97530 100644
--- "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2547\347\253\240 \345\217\226\346\266\210\344\270\216\345\205\263\351\227\255.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2547\347\253\240 \345\217\226\346\266\210\344\270\216\345\205\263\351\227\255.md"	
@@ -1,62 +1,62 @@
-### 7.1 **任务取消**
-
-#### 7.1.1 中断
-
-  Thread
-    interrupt()     方法能中断目标线程
-    isInterrupted() 方法能返回目标线程的中断状态。
-    静态的inInterrupted() 方法将清除当前线程的中断状态，并返回它之前的值，这也是清除中断状态的唯一方法。
-
-    **中断的理解**：它并不会真正地中断一个正在运行的线程，而只是发出中断请求，然后由线程在下一个合适的时刻中断自己。
-
-    wait、sleep、join等，将严格地处理这种请求，当它们收到中断请求或者在开始执行时发现某个已被设置好的中断状态时，将抛出一个异常。
-    设计良好的方法 可以完全忽略这种请求，只要它们能使调用代码对中断请求进行某种处理。
-
-
-#### 7.1.2 中断策略
-
-  由于每个线程拥有各自的中断策略，因此除非你知道中断对该线程的含义，否则就不应该中断这个线程。
-
-#### 7.1.3 中断响应
-
-  当调用可中断的阻塞函数时，例如 Thread.sleep或BlockingQueue.put等，有两种使用策略可用以处理InterruptException:
-  1. 传递异常
-    传递InterruptException与将InterruptException添加到throws子句中一样容易
-  2. 恢复中断状态
-    Thread.currentThread().interrupt();
-
-#### 7.1.4 示例：计时运行
-
-#### 7.1.5 通过Future来实现取消
-
-#### 7.1.6 处理不可中断的阻塞
-
-#### 7.1.7 采用newTaskFor来封装非标准的取消
-
-### 7.2 **停止基于线程的服务**
-
-#### 7.2.1 示例：日志服务
-
-#### 7.2.2 关闭ExecutorService
-  shutdown()    正常关闭
-  shutdownNow() 强行关闭
-
-#### 7.2.3 “毒丸” 对象
-
-#### 7.2.4 示例：只执行一次的服务
-
-#### 7.2.5 shutdownNow的局限性
-
-### 7.3 **处理非正常的线程中止**
-
-    未捕获异常的处理
-
-### 7.4 **JVM的关闭**
-
-#### 7.4.1 关闭钩子
-
-  关闭钩子是指通过Runtime.addShutdownHook注册的但尚未开始的线程。
-
-#### 7.4.1 守护线程
-
-#### 7.4.3 终结器
+### 7.1 **任务取消**
+
+#### 7.1.1 中断
+
+  Thread
+    interrupt()     方法能中断目标线程
+    isInterrupted() 方法能返回目标线程的中断状态。
+    静态的inInterrupted() 方法将清除当前线程的中断状态，并返回它之前的值，这也是清除中断状态的唯一方法。
+
+    **中断的理解**：它并不会真正地中断一个正在运行的线程，而只是发出中断请求，然后由线程在下一个合适的时刻中断自己。
+
+    wait、sleep、join等，将严格地处理这种请求，当它们收到中断请求或者在开始执行时发现某个已被设置好的中断状态时，将抛出一个异常。
+    设计良好的方法 可以完全忽略这种请求，只要它们能使调用代码对中断请求进行某种处理。
+
+
+#### 7.1.2 中断策略
+
+  由于每个线程拥有各自的中断策略，因此除非你知道中断对该线程的含义，否则就不应该中断这个线程。
+
+#### 7.1.3 中断响应
+
+  当调用可中断的阻塞函数时，例如 Thread.sleep或BlockingQueue.put等，有两种使用策略可用以处理InterruptException:
+  1. 传递异常
+    传递InterruptException与将InterruptException添加到throws子句中一样容易
+  2. 恢复中断状态
+    Thread.currentThread().interrupt();
+
+#### 7.1.4 示例：计时运行
+
+#### 7.1.5 通过Future来实现取消
+
+#### 7.1.6 处理不可中断的阻塞
+
+#### 7.1.7 采用newTaskFor来封装非标准的取消
+
+### 7.2 **停止基于线程的服务**
+
+#### 7.2.1 示例：日志服务
+
+#### 7.2.2 关闭ExecutorService
+  shutdown()    正常关闭
+  shutdownNow() 强行关闭
+
+#### 7.2.3 “毒丸” 对象
+
+#### 7.2.4 示例：只执行一次的服务
+
+#### 7.2.5 shutdownNow的局限性
+
+### 7.3 **处理非正常的线程中止**
+
+    未捕获异常的处理
+
+### 7.4 **JVM的关闭**
+
+#### 7.4.1 关闭钩子
+
+  关闭钩子是指通过Runtime.addShutdownHook注册的但尚未开始的线程。
+
+#### 7.4.1 守护线程
+
+#### 7.4.3 终结器
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2548\347\253\240 \347\272\277\347\250\213\346\261\240\347\232\204\344\275\277\347\224\250.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2548\347\253\240 \347\272\277\347\250\213\346\261\240\347\232\204\344\275\277\347\224\250.md"
similarity index 96%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2548\347\253\240 \347\272\277\347\250\213\346\261\240\347\232\204\344\275\277\347\224\250.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2548\347\253\240 \347\272\277\347\250\213\346\261\240\347\232\204\344\275\277\347\224\250.md"
index f41bd2d8..16877de2 100644
--- "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2548\347\253\240 \347\272\277\347\250\213\346\261\240\347\232\204\344\275\277\347\224\250.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2548\347\253\240 \347\272\277\347\250\213\346\261\240\347\232\204\344\275\277\347\224\250.md"	
@@ -1,65 +1,65 @@
-### 8.1 在任务与执行策略之间的隐性耦合
-
-    依赖性任务
-    使用线程封闭机制的任务
-    对响应时间敏感的任务
-    使用ThreadLocal的任务
-
-
-#### 8.1.1 线程饥饿死锁
-
-  正在执行的任务都由于等待其他人处于工作队列中的任务而阻塞
-
-#### 8.1.2 运行时间较长的任务
-
-  限定任务等待资源的时间
-
-
-### 8.2 设置线程池的大小
-
-  策略公式
-
-### 8.3 配置ThreadPoolExecutor
-
-#### 8.3.1 线程的创建与销毁
-
-#### 8.3.2 管理队列任务
-
-  基本的任务排队方法有3种：无界队列、有界队列、同步移交
-
-  newFixedPoolExecutor和 newSingleThreadExecutor在默认情况下将使用一个无界的LinkedBlockingQueue
-
-  一种更稳妥的资源管理策略是使用有界队列，例如ArrayBlockingQueue、有界的LinkedBlockingQueue、PriorityBlockingQueue。
-  避免资源耗尽的情况发生，
-
-  对于非常大的或者无界的线程池，可以通过使用SynchronousQueue来避免任务排队。
-
-#### 8.3.3 饱和策略
-
-  **中止 Abort** 是默认的饱和策略，将抛出未检查的RejectedExecutionException。
-
-  **抛弃 Discard** 会悄悄抛弃该任务
-
-  **抛弃最旧的 Discard-Oldest** 会抛弃下一个将被执行的任务，然后尝试重新提交新的任务。
-
-  **调用者运行 Caller-Runs** 实现了一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
-
-#### 8.3.4 线程工厂
-
-    每当线程池需要创建一个线程时，都是通过线程工厂方法来完成的。
-
-#### 8.3.5 在调用构造函数后再定制ThreadPoolExecutor
-
-### 8.4 扩展ThreadPoolExecutor
-
-    beforeExecutor 执行前
-
-    afterExecutor 执行前
-
-    terminated 在线程池完成关闭操作时调用
-
-    实例：给线程池添加统计信息
-
-### 8.5 递归算法的并行化
-
-    实例：谜题框架
+### 8.1 在任务与执行策略之间的隐性耦合
+
+    依赖性任务
+    使用线程封闭机制的任务
+    对响应时间敏感的任务
+    使用ThreadLocal的任务
+
+
+#### 8.1.1 线程饥饿死锁
+
+  正在执行的任务都由于等待其他人处于工作队列中的任务而阻塞
+
+#### 8.1.2 运行时间较长的任务
+
+  限定任务等待资源的时间
+
+
+### 8.2 设置线程池的大小
+
+  策略公式
+
+### 8.3 配置ThreadPoolExecutor
+
+#### 8.3.1 线程的创建与销毁
+
+#### 8.3.2 管理队列任务
+
+  基本的任务排队方法有3种：无界队列、有界队列、同步移交
+
+  newFixedPoolExecutor和 newSingleThreadExecutor在默认情况下将使用一个无界的LinkedBlockingQueue
+
+  一种更稳妥的资源管理策略是使用有界队列，例如ArrayBlockingQueue、有界的LinkedBlockingQueue、PriorityBlockingQueue。
+  避免资源耗尽的情况发生，
+
+  对于非常大的或者无界的线程池，可以通过使用SynchronousQueue来避免任务排队。
+
+#### 8.3.3 饱和策略
+
+  **中止 Abort** 是默认的饱和策略，将抛出未检查的RejectedExecutionException。
+
+  **抛弃 Discard** 会悄悄抛弃该任务
+
+  **抛弃最旧的 Discard-Oldest** 会抛弃下一个将被执行的任务，然后尝试重新提交新的任务。
+
+  **调用者运行 Caller-Runs** 实现了一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
+
+#### 8.3.4 线程工厂
+
+    每当线程池需要创建一个线程时，都是通过线程工厂方法来完成的。
+
+#### 8.3.5 在调用构造函数后再定制ThreadPoolExecutor
+
+### 8.4 扩展ThreadPoolExecutor
+
+    beforeExecutor 执行前
+
+    afterExecutor 执行前
+
+    terminated 在线程池完成关闭操作时调用
+
+    实例：给线程池添加统计信息
+
+### 8.5 递归算法的并行化
+
+    实例：谜题框架
diff --git "a/10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2549\347\253\240 \345\233\276\345\275\242\347\224\250\346\210\267\347\225\214\351\235\242\345\272\224\347\224\250\347\250\213\345\272\217.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2549\347\253\240 \345\233\276\345\275\242\347\224\250\346\210\267\347\225\214\351\235\242\345\272\224\347\224\250\347\250\213\345\272\217.md"
similarity index 100%
rename from "10 - Reading Notes/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2549\347\253\240 \345\233\276\345\275\242\347\224\250\346\210\267\347\225\214\351\235\242\345\272\224\347\224\250\347\250\213\345\272\217.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/\347\254\2549\347\253\240 \345\233\276\345\275\242\347\224\250\346\210\267\347\225\214\351\235\242\345\272\224\347\224\250\347\250\213\345\272\217.md"
diff --git "a/10 - Reading Notes/Java\347\274\226\347\250\213\346\200\235\346\203\263/01 .md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\347\274\226\347\250\213\346\200\235\346\203\263/01 .md"
similarity index 100%
rename from "10 - Reading Notes/Java\347\274\226\347\250\213\346\200\235\346\203\263/01 .md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\347\274\226\347\250\213\346\200\235\346\203\263/01 .md"
diff --git "a/10 - Reading Notes/Java\347\274\226\347\250\213\346\200\235\346\203\263/02 .md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\347\274\226\347\250\213\346\200\235\346\203\263/02 .md"
similarity index 100%
rename from "10 - Reading Notes/Java\347\274\226\347\250\213\346\200\235\346\203\263/02 .md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\347\274\226\347\250\213\346\200\235\346\203\263/02 .md"
diff --git "a/10 - Reading Notes/Java\347\274\226\347\250\213\346\200\235\346\203\263/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\347\274\226\347\250\213\346\200\235\346\203\263/all.md"
similarity index 100%
rename from "10 - Reading Notes/Java\347\274\226\347\250\213\346\200\235\346\203\263/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\347\274\226\347\250\213\346\200\235\346\203\263/all.md"
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/all.md"
similarity index 100%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/all.md"
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2542\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\273\223\346\236\204.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2542\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\273\223\346\236\204.md"
similarity index 98%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2542\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\273\223\346\236\204.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2542\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\273\223\346\236\204.md"
index 2778b2f4..1bb5a7ec 100644
--- "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2542\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\273\223\346\236\204.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2542\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\273\223\346\236\204.md"	
@@ -1,112 +1,112 @@
-概览Java虚拟机整体架构；
-
-### 2.1 class文件格式
-
-### 2.2 数据类型
-
-  Java虚拟机可以操作的数据类型可分为两类：**原始类型** 和 **引用类型**
-  与之对应，也存在 **原始值** 和 **引用值** 两种类型的数值
-
-### 2.3 原始类型与值
-  Java虚拟机所支持的原始数据类型包括数值类型、boolean类型 和 returnAddress类型三类。
-  其中数值类型分为 整数类型 浮点类型 两种
-
-  整数类型：
-    byte类型  8位
-    short类型 16位
-    int类型 32位
-    long类型  64位
-    char类型 16位
-  浮点类型
-    float类型
-    double类型
-  boolean类型
-    true 和 false 默认为false
-  returnAddress类型
-    表示一条字节码指令的操作码（opcode）
-
-#### 2.3.1 整数类型与整数型
-  Java虚拟机的整数类型的取值范围如下：
-  byte  -128  ~ 127  -27 ~ 27 -1
-  short -32768 ~ 32767 -215 ~ 215 -1
-  int -2147483648 ~ 2147483647 -231 ~ 231 - 1
-  long -9223372036854775808 ~ 9223372036854775807 -263 ~ 263 - 1
-  char  0 ~ 65535
-
-#### 2.3.2 浮点类型、取值集合及浮点值
-#### 2.3.3 returnAddress类型
-#### 2.3.4 boolean类型
-
-### 2.4 引用类型与值
-  Java虚拟机有三种引用类型：类类型、数组类型、接口类型。
-
-### 2.5 运行时数据区
-  Java虚拟机定义了若干种程序运行期间会使用到的运行时数据区，其中一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应的，这些与线程对应的数据区域会随着线程开水和结束而创建和销毁。
-#### 2.5.1 PC寄存器 程序计数器 **线程都有自己私有**
-  Java虚拟机可以支持多条线程同时执行。每一条Java虚拟机线程都有自己的PC（program counter）寄存器。
-  一条Java虚拟机线程只会执行一个方法的代码，这个正在被执行的方法被称为该线程的当前方法。
-  如果这个方法不是native的，那Pc寄存器保存Java虚拟机正在执行的字节码指令的地址，
-  如果这个方法就是native的，那PC寄存器的值是undefined。
-  PC寄存器的容器至少应当能保存一个returnAddress类型的数据或者一个与平台相关的本地指针的值。
-#### 2.5.2 Java虚拟机栈 **线程都有自己私有**
-  每一条Java虚拟机 **线程都有自己私有** 的Java虚拟机栈，这个栈与线程同时创建，用于存储 **栈帧**。
-  用于存储局部变量与一些尚未计算好的结果。
-  另外，它在方法调用和返回也扮演了重要角色。因为除了栈帧的出栈和入栈之外，Java虚拟机栈不会再受其他因素的影响，所以栈帧可以在堆中分配，**Java虚拟机所使用的内存不需要保存是连续的**。
-  Java虚拟机规范既允许Java虚拟机栈被实现成固定大小，也允许根据计算动态来扩展和收缩。如果采用固定大小的Java虚拟机栈，那每一个线程Java虚拟机栈容量可以在线程创建的时候独立选定。
-  Java虚拟机栈实现当应提供程序员或者最终用户调节虚拟机栈初始容量的手段，对于可以动态扩展和收缩Java虚拟机栈来说，则应当提供调节其最大、最小容量的手段。
-  Java虚拟机栈可能发生如下异常情况
-  如果线程请求分配的栈容量超过Java虚拟机允许的最大容量，Java虚拟机将会抛出
-  StackOverflowError
-  如果Java虚拟机可以允许动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那么Java虚拟机将会抛出一个
-  OutOfMemoryError
-
-#### 2.5.3 Java堆 **线程共享**
-  在Java虚拟机中，堆（heap）是可供各个 **线程共享** 的运行时内存区域，也是供所有 **类实例** 和 **数组对象** 分配内存的区域。
-  Java堆在虚拟机启动的时候被创建，它存储了被自动内存管理系统（也就是垃圾收集器）所管理的各种对象，这些受管理的对象无需也无法显式地销毁。
-  Java堆的容量可以是固定的，也可以随着程序执行的需求动态扩展，并在不需要过多空间时自动收缩。**Java堆所使用的内存不需要保证是连续的**。
-  Java堆可能发生如下异常情况
-  如果实际所需的堆超过了自动内存管理系统提供的最大容量，那么Java虚拟机将会抛出一个
-  OutOfMemoryError
-#### 2.5.4 方法区
-  方法区是供各个 **线程共享** 的运行时内存区域。
-  它存储每一个类的结构信息：运行时常量池，字段和 方法数据、构造函数和普通方法的字节码内容，还包括一些在类、实例、接口初始化时用到的特殊方法（2.9）
-  方法区的容量可以是固定的，也可以随着程序执行的需求动态扩展，并在不需要过多空间时自动收缩。**方法区所使用的内存不需要保证是连续的**。
-  OutOfMemoryError
-#### 2.5.5 运行时常量池 **线程共享** 属于方法区
-  运行时常量池是class文件中每一个类或接口的常量池表的运行时表示形式，它包括了若干种不同的常量，从编译期可知的数值字面量到必须在运行期解析后才能获得的方法或字段引用。
-  运行时常量池类似于传统语言中的符号表，不过它存储数据的范围比通常意义上的符号表更为广泛。
-  每一个运行时常量池都在Java虚拟机的方法区中分配，在加载类和接口到虚拟机后，就创建对应的运行时常量池。
-  OutOfMemoryError
-#### 2.5.6 本地方法栈 **线程都有自己私有**
-  Java虚拟机实现可能会使用到传统的栈来支持Native方法(指用Java以外的其他语言编写的方法)的执行，这个栈就是本地方法栈。
-  StackOverflowError
-  OutOfMemoryError
-
-### 2.6 栈帧
-  栈帧是用来存储数据和部分过程结果的数据结构，同时也用来处理动态链接、方法返回值和异常分派。
-  栈帧会随着方法的调用而创建，随着方法的结束而销毁。无论方法是正常完成还是异常完成都算作方法结束。
-  栈帧的存储空间由创建它的线程分配再Java虚拟机栈之中，每一个栈帧都有自己的 **本地变量表**、**操作数栈** 和 **指向当前方法所属的类的运行时常量池的引用**.
-#### 2.6.1 局部变量表
-
-#### 2.6.2 操作数栈
-#### 2.6.3 动态链接
-#### 2.6.4 方法调用正常完成
-#### 2.6.5 方法调用异常完成
-
-### 2.7 对象的表示
-  在Oracle的某些Java虚拟机实现中，指向对象实例的引用是一个指向句柄的指针，这个句柄包含两部分信息，
-  一部分是指向这个对象所包括的方法表以及指向这个对象所属类相关的信息；
-  另一部分是指向在堆中分配的对象实例数据。
-
-### 2.8 浮点计算
-
-### 2.9 特殊方法
-  一个类或者接口最多包含不超过一个类或接口的初始化方法，类或者接口就是通过这个方法完成初始化的。这个方法是一个不包含参数的、返回类型为void的方法，名为<clinit>
-
-### 2.10 异常
-
-### 2.11 字节码指令集简介
-
-### 2.12 类库
-
-### 2.13 公有设计，私有实现
+概览Java虚拟机整体架构；
+
+### 2.1 class文件格式
+
+### 2.2 数据类型
+
+  Java虚拟机可以操作的数据类型可分为两类：**原始类型** 和 **引用类型**
+  与之对应，也存在 **原始值** 和 **引用值** 两种类型的数值
+
+### 2.3 原始类型与值
+  Java虚拟机所支持的原始数据类型包括数值类型、boolean类型 和 returnAddress类型三类。
+  其中数值类型分为 整数类型 浮点类型 两种
+
+  整数类型：
+    byte类型  8位
+    short类型 16位
+    int类型 32位
+    long类型  64位
+    char类型 16位
+  浮点类型
+    float类型
+    double类型
+  boolean类型
+    true 和 false 默认为false
+  returnAddress类型
+    表示一条字节码指令的操作码（opcode）
+
+#### 2.3.1 整数类型与整数型
+  Java虚拟机的整数类型的取值范围如下：
+  byte  -128  ~ 127  -27 ~ 27 -1
+  short -32768 ~ 32767 -215 ~ 215 -1
+  int -2147483648 ~ 2147483647 -231 ~ 231 - 1
+  long -9223372036854775808 ~ 9223372036854775807 -263 ~ 263 - 1
+  char  0 ~ 65535
+
+#### 2.3.2 浮点类型、取值集合及浮点值
+#### 2.3.3 returnAddress类型
+#### 2.3.4 boolean类型
+
+### 2.4 引用类型与值
+  Java虚拟机有三种引用类型：类类型、数组类型、接口类型。
+
+### 2.5 运行时数据区
+  Java虚拟机定义了若干种程序运行期间会使用到的运行时数据区，其中一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应的，这些与线程对应的数据区域会随着线程开水和结束而创建和销毁。
+#### 2.5.1 PC寄存器 程序计数器 **线程都有自己私有**
+  Java虚拟机可以支持多条线程同时执行。每一条Java虚拟机线程都有自己的PC（program counter）寄存器。
+  一条Java虚拟机线程只会执行一个方法的代码，这个正在被执行的方法被称为该线程的当前方法。
+  如果这个方法不是native的，那Pc寄存器保存Java虚拟机正在执行的字节码指令的地址，
+  如果这个方法就是native的，那PC寄存器的值是undefined。
+  PC寄存器的容器至少应当能保存一个returnAddress类型的数据或者一个与平台相关的本地指针的值。
+#### 2.5.2 Java虚拟机栈 **线程都有自己私有**
+  每一条Java虚拟机 **线程都有自己私有** 的Java虚拟机栈，这个栈与线程同时创建，用于存储 **栈帧**。
+  用于存储局部变量与一些尚未计算好的结果。
+  另外，它在方法调用和返回也扮演了重要角色。因为除了栈帧的出栈和入栈之外，Java虚拟机栈不会再受其他因素的影响，所以栈帧可以在堆中分配，**Java虚拟机所使用的内存不需要保存是连续的**。
+  Java虚拟机规范既允许Java虚拟机栈被实现成固定大小，也允许根据计算动态来扩展和收缩。如果采用固定大小的Java虚拟机栈，那每一个线程Java虚拟机栈容量可以在线程创建的时候独立选定。
+  Java虚拟机栈实现当应提供程序员或者最终用户调节虚拟机栈初始容量的手段，对于可以动态扩展和收缩Java虚拟机栈来说，则应当提供调节其最大、最小容量的手段。
+  Java虚拟机栈可能发生如下异常情况
+  如果线程请求分配的栈容量超过Java虚拟机允许的最大容量，Java虚拟机将会抛出
+  StackOverflowError
+  如果Java虚拟机可以允许动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那么Java虚拟机将会抛出一个
+  OutOfMemoryError
+
+#### 2.5.3 Java堆 **线程共享**
+  在Java虚拟机中，堆（heap）是可供各个 **线程共享** 的运行时内存区域，也是供所有 **类实例** 和 **数组对象** 分配内存的区域。
+  Java堆在虚拟机启动的时候被创建，它存储了被自动内存管理系统（也就是垃圾收集器）所管理的各种对象，这些受管理的对象无需也无法显式地销毁。
+  Java堆的容量可以是固定的，也可以随着程序执行的需求动态扩展，并在不需要过多空间时自动收缩。**Java堆所使用的内存不需要保证是连续的**。
+  Java堆可能发生如下异常情况
+  如果实际所需的堆超过了自动内存管理系统提供的最大容量，那么Java虚拟机将会抛出一个
+  OutOfMemoryError
+#### 2.5.4 方法区
+  方法区是供各个 **线程共享** 的运行时内存区域。
+  它存储每一个类的结构信息：运行时常量池，字段和 方法数据、构造函数和普通方法的字节码内容，还包括一些在类、实例、接口初始化时用到的特殊方法（2.9）
+  方法区的容量可以是固定的，也可以随着程序执行的需求动态扩展，并在不需要过多空间时自动收缩。**方法区所使用的内存不需要保证是连续的**。
+  OutOfMemoryError
+#### 2.5.5 运行时常量池 **线程共享** 属于方法区
+  运行时常量池是class文件中每一个类或接口的常量池表的运行时表示形式，它包括了若干种不同的常量，从编译期可知的数值字面量到必须在运行期解析后才能获得的方法或字段引用。
+  运行时常量池类似于传统语言中的符号表，不过它存储数据的范围比通常意义上的符号表更为广泛。
+  每一个运行时常量池都在Java虚拟机的方法区中分配，在加载类和接口到虚拟机后，就创建对应的运行时常量池。
+  OutOfMemoryError
+#### 2.5.6 本地方法栈 **线程都有自己私有**
+  Java虚拟机实现可能会使用到传统的栈来支持Native方法(指用Java以外的其他语言编写的方法)的执行，这个栈就是本地方法栈。
+  StackOverflowError
+  OutOfMemoryError
+
+### 2.6 栈帧
+  栈帧是用来存储数据和部分过程结果的数据结构，同时也用来处理动态链接、方法返回值和异常分派。
+  栈帧会随着方法的调用而创建，随着方法的结束而销毁。无论方法是正常完成还是异常完成都算作方法结束。
+  栈帧的存储空间由创建它的线程分配再Java虚拟机栈之中，每一个栈帧都有自己的 **本地变量表**、**操作数栈** 和 **指向当前方法所属的类的运行时常量池的引用**.
+#### 2.6.1 局部变量表
+
+#### 2.6.2 操作数栈
+#### 2.6.3 动态链接
+#### 2.6.4 方法调用正常完成
+#### 2.6.5 方法调用异常完成
+
+### 2.7 对象的表示
+  在Oracle的某些Java虚拟机实现中，指向对象实例的引用是一个指向句柄的指针，这个句柄包含两部分信息，
+  一部分是指向这个对象所包括的方法表以及指向这个对象所属类相关的信息；
+  另一部分是指向在堆中分配的对象实例数据。
+
+### 2.8 浮点计算
+
+### 2.9 特殊方法
+  一个类或者接口最多包含不超过一个类或接口的初始化方法，类或者接口就是通过这个方法完成初始化的。这个方法是一个不包含参数的、返回类型为void的方法，名为<clinit>
+
+### 2.10 异常
+
+### 2.11 字节码指令集简介
+
+### 2.12 类库
+
+### 2.13 公有设计，私有实现
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2543\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\274\226\350\257\221\345\231\250.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2543\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\274\226\350\257\221\345\231\250.md"
similarity index 93%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2543\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\274\226\350\257\221\345\231\250.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2543\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\274\226\350\257\221\345\231\250.md"
index 7367848b..5e8f4ba2 100644
--- "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2543\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\274\226\350\257\221\345\231\250.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2543\347\253\240 Java\350\231\232\346\213\237\346\234\272\347\274\226\350\257\221\345\231\250.md"	
@@ -1,32 +1,32 @@
-编译前后的代码
-如何将Java语言编写的程序转换为虚拟机指令集；
-
-## 3.1 示例的格式说明
-
-## 3.2 常量、局部变量和控制结构的使用
-
-## 3.3 算术运算
-
-## 3.4 访问运行时常量池
-
-## 3.5 更多控制结构示例
-
-## 3.6 接收参数
-
-## 3.7 方法调用
-
-## 3.8 使用类实例
-
-## 3.9 数组
-
-## 3.10 编译switch语句
-
-## 3.11 使用操作数栈
-
-## 3.12 抛出异常和处理异常
-
-## 3.13 编译finally语句块
-
-## 3.14 同步
-
-## 3.15 注解
+编译前后的代码
+如何将Java语言编写的程序转换为虚拟机指令集；
+
+## 3.1 示例的格式说明
+
+## 3.2 常量、局部变量和控制结构的使用
+
+## 3.3 算术运算
+
+## 3.4 访问运行时常量池
+
+## 3.5 更多控制结构示例
+
+## 3.6 接收参数
+
+## 3.7 方法调用
+
+## 3.8 使用类实例
+
+## 3.9 数组
+
+## 3.10 编译switch语句
+
+## 3.11 使用操作数栈
+
+## 3.12 抛出异常和处理异常
+
+## 3.13 编译finally语句块
+
+## 3.14 同步
+
+## 3.15 注解
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2544\347\253\240 class\346\226\207\344\273\266\346\240\274\345\274\217.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2544\347\253\240 class\346\226\207\344\273\266\346\240\274\345\274\217.md"
similarity index 96%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2544\347\253\240 class\346\226\207\344\273\266\346\240\274\345\274\217.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2544\347\253\240 class\346\226\207\344\273\266\346\240\274\345\274\217.md"
index fd7dddbf..e3053d8c 100644
--- "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2544\347\253\240 class\346\226\207\344\273\266\346\240\274\345\274\217.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2544\347\253\240 class\346\226\207\344\273\266\346\240\274\345\274\217.md"	
@@ -1,54 +1,54 @@
-定义class文件格式。它是一种与硬件和操作系统无关的二进制格式，用来表示编译后的类和接口；
-### 4.1 classFile格式
-每个class文件对应一个如下所示的ClassFile结构
-```
-ClassFile{
-  u4                magic 魔数
-  u2                minor_version 副版本号
-  u2                major_version 主版本号
-  u2                constant_pool_count 常量池计数器
-  cp_info           constant_pool[constant_pool_count-1]  常量池
-  u2                access_flags  访问标志
-  u2                this_class    类索引
-  u2                super_class   父类索引
-  u2                interfaces_count  接口计数器
-  u2                interfaces[interfaces_count] 接口表
-  u2                fields_count  字段计数器
-  field_info        fields[fields_count] 字段表
-  u2                methods_count 方法计数器
-  method_info       methods[methods_count] 方法表
-  u2                attributes_count 属性计数器
-  attribute_info    attributes[attributes_count] 属性表
-}
-```
-各项含义如下
-
-### 4.2 各种内部表示名称
-
-#### 4.2.1 类和接口的二进制名称
-
-#### 4.2.2 非全限定名
-
-### 4.3 描述符和签名
-
-#### 4.3.1 语法符号
-#### 4.3.2 字段描述符
-#### 4.3.3 方法描述符
-#### 4.3.4 签名
-
-### 4.4 常量池
-#### 4.4.1 CONSTANT_Class_info结构
-
-### 4.5 字段
-
-### 4.6 方法
-
-### 4.7 属性
-
-### 4.8 格式检查
-
-### 4.9 Java虚拟机代码约束
-
-### 4.10 **class文件校验**
-
-### 4.11 Java虚拟机限制
+定义class文件格式。它是一种与硬件和操作系统无关的二进制格式，用来表示编译后的类和接口；
+### 4.1 classFile格式
+每个class文件对应一个如下所示的ClassFile结构
+```
+ClassFile{
+  u4                magic 魔数
+  u2                minor_version 副版本号
+  u2                major_version 主版本号
+  u2                constant_pool_count 常量池计数器
+  cp_info           constant_pool[constant_pool_count-1]  常量池
+  u2                access_flags  访问标志
+  u2                this_class    类索引
+  u2                super_class   父类索引
+  u2                interfaces_count  接口计数器
+  u2                interfaces[interfaces_count] 接口表
+  u2                fields_count  字段计数器
+  field_info        fields[fields_count] 字段表
+  u2                methods_count 方法计数器
+  method_info       methods[methods_count] 方法表
+  u2                attributes_count 属性计数器
+  attribute_info    attributes[attributes_count] 属性表
+}
+```
+各项含义如下
+
+### 4.2 各种内部表示名称
+
+#### 4.2.1 类和接口的二进制名称
+
+#### 4.2.2 非全限定名
+
+### 4.3 描述符和签名
+
+#### 4.3.1 语法符号
+#### 4.3.2 字段描述符
+#### 4.3.3 方法描述符
+#### 4.3.4 签名
+
+### 4.4 常量池
+#### 4.4.1 CONSTANT_Class_info结构
+
+### 4.5 字段
+
+### 4.6 方法
+
+### 4.7 属性
+
+### 4.8 格式检查
+
+### 4.9 Java虚拟机代码约束
+
+### 4.10 **class文件校验**
+
+### 4.11 Java虚拟机限制
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2545\347\253\240 \345\212\240\350\275\275\343\200\201\351\223\276\346\216\245\344\270\216\345\210\235\345\247\213\345\214\226.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2545\347\253\240 \345\212\240\350\275\275\343\200\201\351\223\276\346\216\245\344\270\216\345\210\235\345\247\213\345\214\226.md"
similarity index 98%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2545\347\253\240 \345\212\240\350\275\275\343\200\201\351\223\276\346\216\245\344\270\216\345\210\235\345\247\213\345\214\226.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2545\347\253\240 \345\212\240\350\275\275\343\200\201\351\223\276\346\216\245\344\270\216\345\210\235\345\247\213\345\214\226.md"
index 8eb9f475..4a75f705 100644
--- "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2545\347\253\240 \345\212\240\350\275\275\343\200\201\351\223\276\346\216\245\344\270\216\345\210\235\345\247\213\345\214\226.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2545\347\253\240 \345\212\240\350\275\275\343\200\201\351\223\276\346\216\245\344\270\216\345\210\235\345\247\213\345\214\226.md"	
@@ -1,76 +1,76 @@
-定义了Java虚拟机启动以及类和接口的加载、链接和初始化的过程；
-
-  **加载** 是根据特定名称查找类和接口类型的二进制表示，并由此二进制表示 **创建** 类或接口的过程。
-  **链接** 是为了让类或接口可以被Java虚拟机执行，而将类或接口并入虚拟机运行时状态的过程。
-  **初始化** 是指执行类或接口的初始化方法<clinit>
-
-### 5.1 运行时常量池
-  **描述Java虚拟机如何从类或接口的二进制表示中得到符号引用**
-  Java虚拟机为每个类型都维护一个常量池。该常量池是Java虚拟机中的运行时数据结构，像传统编程语言实现中的符号表一样有很多用途。
-  当类或接口创建时，它的二进制表示中的常量池表被用来构造运行时常量池。运行时常量池中的所有引用最初都是符号引用。
-  这些符号引用来自于类或接口的二进制表示的如下结构中：
-
-  某个类或接口的符号引用来自于类或接口二进制表示中的CONSTANT_Class_info结构
-  类或接口的 **某个字段的符号引用** 来自于类或接口二进制表示中的 **CONSTANT_Fieldref_info** 结构
-  **类中某个方法** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_Methodref_info** 结构
-  **接口的某个方法** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_InterfaceMethodref_info** 结构
-  **方法句柄** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_MethodHandle_info** 结构
-  **方法类型** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_MethodType_info** 结构
-  **调用点限定符** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_InvokeDynamic_info** 结构
-  **字符常量表示String类实例的一个引用** 它来自于类或接口二进制表示中的 **CONSTANT_String_info** 结构
-  **其他运行时常量值** 来自于类或接口二进制表示中的 **CONSTANT_Integer_info**、**CONSTANT_Float_info**、**CONSTANT_Logn_info**、**CONSTANT_Double_info** 结构
-  在类或接口的二进制表示中，常量池表中剩下的结构还有  **CONSTANT_NameAndType_info** 和 **CONSTANT_Utf8_info**，它们间接用来获得对类、接口、方法、字段、方法类型和方法句柄的符号引用，或在需要得到字符常量和调用点限定符时使用
-
-### 5.2 虚拟机启动
-  **解释Java虚拟机启动时会有怎样的加载、链接和初始化过程**
-  1. Java虚拟机的启动时通过引导类加载器( **bootstrap class loader** )创建一个初始类（ **initial class** ）来完成的，这个类是有虚拟机的具体实现指定的。
-  紧接着，Java虚拟机链接这个初始类，初始化它并调用它的public方法void main(String[])。之后的整个执行过程都是由对此方法的调用开始。执行main方法中的java虚拟机指令可能会导致Java虚拟机链接另外的一些类或接口，也可能会调用另外的方法。
-
-  2. 在某种Java虚拟机的实现上，初始类可能会作为命令行参数（ **command line argument** ）被提供给虚拟机。当然虚拟机实现也可以利用一个初始类让加载器依次加载整个应用。当然初始类也可以选择组合上述的方式来工作。
-
-### 5.3 创建和加载
-  **详述了类和接口的二进制表示是如何通过类加载器并由此创建类和接口的。**
-
-  Java虚拟机支持两种类加载器：Java虚拟机提供的 **引导加载器** 和 **用户自定义的类加载器（抽象类ClassLoader的某个子类的实例）** 。
-
-#### 5.3.1 使用引导类加载器来加载类型
-  ClassNotFoundException
-#### 5.3.2 使用用户自定义类加载器来加载类型
-  ClassNotFoundException
-#### 5.3.3 创建数组类
-#### 5.3.4 加载限制
-#### 5.3.5 从class文件表示得到类
-  ClassFormatError
-  UnspportedClassVersionError
-
-### 5.4 链接
-  **描述链接过程**
-  
-  在类或接口被链接之前，它**必须被成功地加载过
-  在类或接口初始化之前，它必须被成功地验证及准备过
-  程序的直接或间接行为可能会导致链接发生，链接过程中检查到的错误应该请求链接的程序处抛出
-
-#### 5.4.1 验证
-#### 5.4.2 准备
-#### 5.4.3 解析
-  1. 类与接口解析
-  2. 字段解析
-  3. 普通方法解析
-  4. 接口方法解析
-  5. 方法类型与方法句柄解析
-  6. 调用点限定符解析
-#### 5.4.4 访问控制
-  public protected private
-#### 5.4.5 方法覆盖
-  子类
-
-### 5.5 初始化
-  **详述雷和接口是如何被初始化的**
-
-### 5.6 绑定本地方法实现
-  **介绍绑定本地方法的概念**
-
-### 5.7 Java虚拟机退出
-  **介绍Java虚拟机的退出时机**
-  某些线程调用Runtime类或System类的exit方法 或Runtime类的halt方法。Java安全管理器也允许这些exit和halt操作。
-  除此之外，JNI规范描述Java虚拟机的终止条件是，当JNI调用API来加载或卸载Java虚拟机。
+定义了Java虚拟机启动以及类和接口的加载、链接和初始化的过程；
+
+  **加载** 是根据特定名称查找类和接口类型的二进制表示，并由此二进制表示 **创建** 类或接口的过程。
+  **链接** 是为了让类或接口可以被Java虚拟机执行，而将类或接口并入虚拟机运行时状态的过程。
+  **初始化** 是指执行类或接口的初始化方法<clinit>
+
+### 5.1 运行时常量池
+  **描述Java虚拟机如何从类或接口的二进制表示中得到符号引用**
+  Java虚拟机为每个类型都维护一个常量池。该常量池是Java虚拟机中的运行时数据结构，像传统编程语言实现中的符号表一样有很多用途。
+  当类或接口创建时，它的二进制表示中的常量池表被用来构造运行时常量池。运行时常量池中的所有引用最初都是符号引用。
+  这些符号引用来自于类或接口的二进制表示的如下结构中：
+
+  某个类或接口的符号引用来自于类或接口二进制表示中的CONSTANT_Class_info结构
+  类或接口的 **某个字段的符号引用** 来自于类或接口二进制表示中的 **CONSTANT_Fieldref_info** 结构
+  **类中某个方法** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_Methodref_info** 结构
+  **接口的某个方法** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_InterfaceMethodref_info** 结构
+  **方法句柄** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_MethodHandle_info** 结构
+  **方法类型** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_MethodType_info** 结构
+  **调用点限定符** 的符号引用来自于类或接口二进制表示中的 **CONSTANT_InvokeDynamic_info** 结构
+  **字符常量表示String类实例的一个引用** 它来自于类或接口二进制表示中的 **CONSTANT_String_info** 结构
+  **其他运行时常量值** 来自于类或接口二进制表示中的 **CONSTANT_Integer_info**、**CONSTANT_Float_info**、**CONSTANT_Logn_info**、**CONSTANT_Double_info** 结构
+  在类或接口的二进制表示中，常量池表中剩下的结构还有  **CONSTANT_NameAndType_info** 和 **CONSTANT_Utf8_info**，它们间接用来获得对类、接口、方法、字段、方法类型和方法句柄的符号引用，或在需要得到字符常量和调用点限定符时使用
+
+### 5.2 虚拟机启动
+  **解释Java虚拟机启动时会有怎样的加载、链接和初始化过程**
+  1. Java虚拟机的启动时通过引导类加载器( **bootstrap class loader** )创建一个初始类（ **initial class** ）来完成的，这个类是有虚拟机的具体实现指定的。
+  紧接着，Java虚拟机链接这个初始类，初始化它并调用它的public方法void main(String[])。之后的整个执行过程都是由对此方法的调用开始。执行main方法中的java虚拟机指令可能会导致Java虚拟机链接另外的一些类或接口，也可能会调用另外的方法。
+
+  2. 在某种Java虚拟机的实现上，初始类可能会作为命令行参数（ **command line argument** ）被提供给虚拟机。当然虚拟机实现也可以利用一个初始类让加载器依次加载整个应用。当然初始类也可以选择组合上述的方式来工作。
+
+### 5.3 创建和加载
+  **详述了类和接口的二进制表示是如何通过类加载器并由此创建类和接口的。**
+
+  Java虚拟机支持两种类加载器：Java虚拟机提供的 **引导加载器** 和 **用户自定义的类加载器（抽象类ClassLoader的某个子类的实例）** 。
+
+#### 5.3.1 使用引导类加载器来加载类型
+  ClassNotFoundException
+#### 5.3.2 使用用户自定义类加载器来加载类型
+  ClassNotFoundException
+#### 5.3.3 创建数组类
+#### 5.3.4 加载限制
+#### 5.3.5 从class文件表示得到类
+  ClassFormatError
+  UnspportedClassVersionError
+
+### 5.4 链接
+  **描述链接过程**
+  
+  在类或接口被链接之前，它**必须被成功地加载过
+  在类或接口初始化之前，它必须被成功地验证及准备过
+  程序的直接或间接行为可能会导致链接发生，链接过程中检查到的错误应该请求链接的程序处抛出
+
+#### 5.4.1 验证
+#### 5.4.2 准备
+#### 5.4.3 解析
+  1. 类与接口解析
+  2. 字段解析
+  3. 普通方法解析
+  4. 接口方法解析
+  5. 方法类型与方法句柄解析
+  6. 调用点限定符解析
+#### 5.4.4 访问控制
+  public protected private
+#### 5.4.5 方法覆盖
+  子类
+
+### 5.5 初始化
+  **详述雷和接口是如何被初始化的**
+
+### 5.6 绑定本地方法实现
+  **介绍绑定本地方法的概念**
+
+### 5.7 Java虚拟机退出
+  **介绍Java虚拟机的退出时机**
+  某些线程调用Runtime类或System类的exit方法 或Runtime类的halt方法。Java安全管理器也允许这些exit和halt操作。
+  除此之外，JNI规范描述Java虚拟机的终止条件是，当JNI调用API来加载或卸载Java虚拟机。
diff --git "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2546\347\253\240 Java\350\231\232\346\213\237\346\234\272\346\214\207\344\273\244\351\233\206.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2546\347\253\240 Java\350\231\232\346\213\237\346\234\272\346\214\207\344\273\244\351\233\206.md"
similarity index 94%
rename from "10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2546\347\253\240 Java\350\231\232\346\213\237\346\234\272\346\214\207\344\273\244\351\233\206.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2546\347\253\240 Java\350\231\232\346\213\237\346\234\272\346\214\207\344\273\244\351\233\206.md"
index 1dfce7b7..f2a3875a 100644
--- "a/10 - Reading Notes/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2546\347\253\240 Java\350\231\232\346\213\237\346\234\272\346\214\207\344\273\244\351\233\206.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2546\347\253\240 Java\350\231\232\346\213\237\346\234\272\346\214\207\344\273\244\351\233\206.md"	
@@ -1,11 +1,11 @@
-定义了Java虚拟机指令集；  
-
-### 6.1 设定：“必须”的含义
-
-### 6.2 保留操作码
-
-### 6.3 虚拟机错误
-
-### 6.4 指令描述格式
-
-### 6.5 指令集描述
+定义了Java虚拟机指令集；  
+
+### 6.1 设定：“必须”的含义
+
+### 6.2 保留操作码
+
+### 6.3 虚拟机错误
+
+### 6.4 指令描述格式
+
+### 6.5 指令集描述
diff --git "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2543\347\253\240 \346\234\215\345\212\241\346\262\273\347\220\206\357\274\232Spring Cloud Eureka.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2547\347\253\240 \346\223\215\344\275\234\347\240\201\345\212\251\350\256\260\347\254\246.md"
similarity index 100%
rename from "10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2543\347\253\240 \346\234\215\345\212\241\346\262\273\347\220\206\357\274\232Spring Cloud Eureka.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Java\350\231\232\346\213\237\346\234\272\350\247\204\350\214\203(Java SE 7\347\211\210)/\347\254\2547\347\253\240 \346\223\215\344\275\234\347\240\201\345\212\251\350\256\260\347\254\246.md"
diff --git "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/all.md"
similarity index 95%
rename from "10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/all.md"
index 6ea48983..5d9f1b6f 100644
--- "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/all.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/all.md"	
@@ -1,193 +1,193 @@
-## 第1章　基础知识	1
-什么是微服务架构	1
--- 与单体系统的区别	1
--- 如何实施微服务	2
-为什么选择Spring Cloud	6
-Spring Cloud简介	7
-版本说明	8
-## 第2章　微服务构建：Spring Boot	11
-框架简介	12
-快速入门	13
--- 项目构建与解析	13
--- 实现RESTful API	17
-配置详解	20
--- 配置文件	20
--- 自定义参数	22
--- 参数引用	22
--- 使用随机数	23
--- 命令行参数	23
--- 多环境配置	24
--- 加载顺序	25
-监控与管理	26
--- 初识actuator	27
--- 原生端点	28
-小结	38
-## 第3章　服务治理：Spring Cloud Eureka	39
-服务治理	39
--- Netflix Eureka	40
---搭建服务注册中心	41
---注册服务提供者	43
---高可用注册中心	46
---服务发现与消费	48
-Eureka详解	51
---基础架构	52
---服务治理机制	52
---源码分析	56
-配置详解	65
---服务注册类配置	65
---服务实例类配置	67
-跨平台支持	71
-## 第4章　客户端负载均衡：Spring Cloud Ribbon	73
-客户端负载均衡	73
-RestTemplate详解	75
--- GET请求	75
--- POST请求	77
--- PUT请求	79
--- DELETE请求	79
-源码分析	80
--- 负载均衡器	91
--- 负载均衡策略	109
-配置详解	123
---自动化配置	124
--- Camden版本对RibbonClient配置的优化	125
--- 参数配置	127
--- 与Eureka结合	127
-重试机制	128
-## 第5章　服务容错保护：Spring Cloud Hystrix	130
-快速入门	131
-原理分析	135
--- 工作流程	135
--- 断路器原理	144
--- 依赖隔离	148
-使用详解	151
--- 创建请求命令	151
--- 定义服务降级	154
--- 异常处理	157
--- 命令名称、分组以及线程池划分	158
--- 请求缓存	159
--- 请求合并	166
-属性详解	172
--- Command属性	174
--- collapser属性	184
--- threadPool属性	185
-Hystrix仪表盘	187
-Turbine集群监控	192
--- 构建监控聚合服务	192
--- 与消息代理结合	196
-## 第6章　声明式服务调用：Spring Cloud Feign	199
-快速入门	200
-参数绑定	202
-继承特性	205
-Ribbon配置	209
-全局配置	209
-指定服务配置	209
-重试机制	210
-Hystrix配置	211
-全局配置	211
-禁用Hystrix	211
-指定命令配置	212
-服务降级配置	212
-其他配置	214
-## 第7章　API网关服务：Spring Cloud Zuul	217
-快速入门	219
--- 构建网关	220
--- 请求路由	221
--- 请求过滤	223
-路由详解	226
--- 传统路由配置	226
--- 服务路由配置	228
--- 服务路由的默认规则	229
--- 自定义路由映射规则	229
--- 路径匹配	230
--- 路由前缀	233
--- 本地跳转	234
--- Cookie与头信息	235
--- Hystrix和Ribbon支持	236
-过滤器详解	238
--- 过滤器	238
--- 请求生命周期	239
--- 核心过滤器	240
--- 异常处理	244
--- 禁用过滤器	256
-动态加载	257
--- 动态路由	257
--- 动态过滤器	261
-## 第8章　分布式配置中心：Spring Cloud Config	267
-快速入门	267
--- 构建配置中心	268
--- 配置规则详解	269
--- 客户端配置映射	272
-服务端详解	274
--- 基础架构	274
--- Git配置仓库	276
--- SVN配置仓库	279
--- 本地仓库	279
--- 本地文件系统	279
--- 健康监测	280
--- 属性覆盖	281
--- 安全保护	281
--- 加密解密	282
--- 高可用配置	286
-客户端详解	286
--- URI指定配置中心	287
--- 服务化配置中心	287
--- 失败快速响应与重试	290
--- 获取远程配置	292
--- 动态刷新配置	293
-## 第9章　消息总线：Spring Cloud Bus	295
-消息代理	295
-RabbitMQ实现消息总线	296
--- 基本概念	297
--- 安装与使用	298
--- 快速入门	302
--- 整合Spring Cloud Bus	306
--- 原理分析	307
--- 指定刷新范围	308
--- 架构优化	309
--- RabbitMQ配置	310
-Kafka实现消息总线	312
--- Kafka简介	312
--- 快速入门	313
---整合Spring Cloud Bus	315
--- Kafka配置	318
-深入理解	318
--- 源码分析	320
--- 其他消息代理的支持	342
-## 第10章　消息驱动的微服务：Spring Cloud Stream	344
-快速入门	344
-核心概念	349
--- 绑定器	350
--- 发布-订阅模式	351
--- 消费组	353
--- 消息分区	354
-使用详解	355
--- 开启绑定功能	355
--- 绑定消息通道	356
--- 消息生产与消费	360
--- 响应式编程	366
--- 消费组与消息分区	368
--- 消息类型	370
-绑定器详解	373
--- 绑定器SPI	373
--- 自动化配置	374
--- 多绑定器配置	374
--- RabbitMQ与Kafka绑定器	376
-配置详解	376
--- 基础配置	377
--- 绑定通道配置	377
--- 绑定器配置	379
-## 第11章　分布式服务跟踪：Spring Cloud Sleuth	386
-快速入门	386
--- 准备工作	386
--- 实现跟踪	389
-跟踪原理	390
-抽样收集	392
-与Logstash整合	394
-与Zipkin整合	397
--- HTTP收集	398
--- 消息中间件收集	402
--- 收集原理	404
--- 数据存储	414
--- API接口	417
-附录A　Starter POMs	419
-后记	421
+## 第1章　基础知识	1
+什么是微服务架构	1
+-- 与单体系统的区别	1
+-- 如何实施微服务	2
+为什么选择Spring Cloud	6
+Spring Cloud简介	7
+版本说明	8
+## 第2章　微服务构建：Spring Boot	11
+框架简介	12
+快速入门	13
+-- 项目构建与解析	13
+-- 实现RESTful API	17
+配置详解	20
+-- 配置文件	20
+-- 自定义参数	22
+-- 参数引用	22
+-- 使用随机数	23
+-- 命令行参数	23
+-- 多环境配置	24
+-- 加载顺序	25
+监控与管理	26
+-- 初识actuator	27
+-- 原生端点	28
+小结	38
+## 第3章　服务治理：Spring Cloud Eureka	39
+服务治理	39
+-- Netflix Eureka	40
+--搭建服务注册中心	41
+--注册服务提供者	43
+--高可用注册中心	46
+--服务发现与消费	48
+Eureka详解	51
+--基础架构	52
+--服务治理机制	52
+--源码分析	56
+配置详解	65
+--服务注册类配置	65
+--服务实例类配置	67
+跨平台支持	71
+## 第4章　客户端负载均衡：Spring Cloud Ribbon	73
+客户端负载均衡	73
+RestTemplate详解	75
+-- GET请求	75
+-- POST请求	77
+-- PUT请求	79
+-- DELETE请求	79
+源码分析	80
+-- 负载均衡器	91
+-- 负载均衡策略	109
+配置详解	123
+--自动化配置	124
+-- Camden版本对RibbonClient配置的优化	125
+-- 参数配置	127
+-- 与Eureka结合	127
+重试机制	128
+## 第5章　服务容错保护：Spring Cloud Hystrix	130
+快速入门	131
+原理分析	135
+-- 工作流程	135
+-- 断路器原理	144
+-- 依赖隔离	148
+使用详解	151
+-- 创建请求命令	151
+-- 定义服务降级	154
+-- 异常处理	157
+-- 命令名称、分组以及线程池划分	158
+-- 请求缓存	159
+-- 请求合并	166
+属性详解	172
+-- Command属性	174
+-- collapser属性	184
+-- threadPool属性	185
+Hystrix仪表盘	187
+Turbine集群监控	192
+-- 构建监控聚合服务	192
+-- 与消息代理结合	196
+## 第6章　声明式服务调用：Spring Cloud Feign	199
+快速入门	200
+参数绑定	202
+继承特性	205
+Ribbon配置	209
+全局配置	209
+指定服务配置	209
+重试机制	210
+Hystrix配置	211
+全局配置	211
+禁用Hystrix	211
+指定命令配置	212
+服务降级配置	212
+其他配置	214
+## 第7章　API网关服务：Spring Cloud Zuul	217
+快速入门	219
+-- 构建网关	220
+-- 请求路由	221
+-- 请求过滤	223
+路由详解	226
+-- 传统路由配置	226
+-- 服务路由配置	228
+-- 服务路由的默认规则	229
+-- 自定义路由映射规则	229
+-- 路径匹配	230
+-- 路由前缀	233
+-- 本地跳转	234
+-- Cookie与头信息	235
+-- Hystrix和Ribbon支持	236
+过滤器详解	238
+-- 过滤器	238
+-- 请求生命周期	239
+-- 核心过滤器	240
+-- 异常处理	244
+-- 禁用过滤器	256
+动态加载	257
+-- 动态路由	257
+-- 动态过滤器	261
+## 第8章　分布式配置中心：Spring Cloud Config	267
+快速入门	267
+-- 构建配置中心	268
+-- 配置规则详解	269
+-- 客户端配置映射	272
+服务端详解	274
+-- 基础架构	274
+-- Git配置仓库	276
+-- SVN配置仓库	279
+-- 本地仓库	279
+-- 本地文件系统	279
+-- 健康监测	280
+-- 属性覆盖	281
+-- 安全保护	281
+-- 加密解密	282
+-- 高可用配置	286
+客户端详解	286
+-- URI指定配置中心	287
+-- 服务化配置中心	287
+-- 失败快速响应与重试	290
+-- 获取远程配置	292
+-- 动态刷新配置	293
+## 第9章　消息总线：Spring Cloud Bus	295
+消息代理	295
+RabbitMQ实现消息总线	296
+-- 基本概念	297
+-- 安装与使用	298
+-- 快速入门	302
+-- 整合Spring Cloud Bus	306
+-- 原理分析	307
+-- 指定刷新范围	308
+-- 架构优化	309
+-- RabbitMQ配置	310
+Kafka实现消息总线	312
+-- Kafka简介	312
+-- 快速入门	313
+--整合Spring Cloud Bus	315
+-- Kafka配置	318
+深入理解	318
+-- 源码分析	320
+-- 其他消息代理的支持	342
+## 第10章　消息驱动的微服务：Spring Cloud Stream	344
+快速入门	344
+核心概念	349
+-- 绑定器	350
+-- 发布-订阅模式	351
+-- 消费组	353
+-- 消息分区	354
+使用详解	355
+-- 开启绑定功能	355
+-- 绑定消息通道	356
+-- 消息生产与消费	360
+-- 响应式编程	366
+-- 消费组与消息分区	368
+-- 消息类型	370
+绑定器详解	373
+-- 绑定器SPI	373
+-- 自动化配置	374
+-- 多绑定器配置	374
+-- RabbitMQ与Kafka绑定器	376
+配置详解	376
+-- 基础配置	377
+-- 绑定通道配置	377
+-- 绑定器配置	379
+## 第11章　分布式服务跟踪：Spring Cloud Sleuth	386
+快速入门	386
+-- 准备工作	386
+-- 实现跟踪	389
+跟踪原理	390
+抽样收集	392
+与Logstash整合	394
+与Zipkin整合	397
+-- HTTP收集	398
+-- 消息中间件收集	402
+-- 收集原理	404
+-- 数据存储	414
+-- API接口	417
+附录A　Starter POMs	419
+后记	421
diff --git "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\237\272\347\241\200\347\237\245\350\257\206.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\237\272\347\241\200\347\237\245\350\257\206.md"
similarity index 100%
rename from "10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\237\272\347\241\200\347\237\245\350\257\206.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\237\272\347\241\200\347\237\245\350\257\206.md"
diff --git "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\276\256\346\234\215\345\212\241\346\236\204\345\273\272\357\274\232Spring Boot.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\276\256\346\234\215\345\212\241\346\236\204\345\273\272\357\274\232Spring Boot.md"
similarity index 100%
rename from "10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\276\256\346\234\215\345\212\241\346\236\204\345\273\272\357\274\232Spring Boot.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\276\256\346\234\215\345\212\241\346\236\204\345\273\272\357\274\232Spring Boot.md"
diff --git "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2544\347\253\240 \345\256\242\346\210\267\347\253\257\350\264\237\350\275\275\345\235\207\350\241\241\357\274\232Spring Cloud Ribbon.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2543\347\253\240 \346\234\215\345\212\241\346\262\273\347\220\206\357\274\232Spring Cloud Eureka.md"
similarity index 100%
rename from "10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2544\347\253\240 \345\256\242\346\210\267\347\253\257\350\264\237\350\275\275\345\235\207\350\241\241\357\274\232Spring Cloud Ribbon.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2543\347\253\240 \346\234\215\345\212\241\346\262\273\347\220\206\357\274\232Spring Cloud Eureka.md"
diff --git "a/10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2545\347\253\240 \346\234\215\345\212\241\345\256\271\351\224\231\344\277\235\346\212\244\357\274\232Spring Cloud Hystrix.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2544\347\253\240 \345\256\242\346\210\267\347\253\257\350\264\237\350\275\275\345\235\207\350\241\241\357\274\232Spring Cloud Ribbon.md"
similarity index 100%
rename from "10 - Reading Notes/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2545\347\253\240 \346\234\215\345\212\241\345\256\271\351\224\231\344\277\235\346\212\244\357\274\232Spring Cloud Hystrix.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2544\347\253\240 \345\256\242\346\210\267\347\253\257\350\264\237\350\275\275\345\235\207\350\241\241\357\274\232Spring Cloud Ribbon.md"
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25410\347\253\240 \344\272\213\345\212\241.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2545\347\253\240 \346\234\215\345\212\241\345\256\271\351\224\231\344\277\235\346\212\244\357\274\232Spring Cloud Hystrix.md"
similarity index 100%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25410\347\253\240 \344\272\213\345\212\241.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring Cloud\345\276\256\346\234\215\345\212\241\345\256\236\346\210\230/\347\254\2545\347\253\240 \346\234\215\345\212\241\345\256\271\351\224\231\344\277\235\346\212\244\357\274\232Spring Cloud Hystrix.md"
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/all.md"
similarity index 96%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/all.md"
index 33b6a08e..69e0e56c 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/all.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/all.md"	
@@ -1,67 +1,67 @@
-## 第1章　入门　　1
-1.1　Spring风云再起　　1
-
-1.2　Spring Boot入门　　6
-
-1.3　小结　　18
-## 第2章　开发第一个应用程序　　19
-2.1　运用Spring Boot　　19
-
-2.2　使用起步依赖　　27
-
-2.3　使用自动配置　　30
-
-2.4　小结　　41
-## 第3章　自定义配置　　42
-3.1　覆盖Spring Boot自动配置　　42
-
-3.2　通过属性文件外置配置　　49
-
-3.3　定制应用程序错误页面　　62
-
-3.4　小结　　64
-
-## 第4章　测试　　66
-4.1　集成测试自动配置　　66
-4.2　测试Web应用程序　　68
-
-4.3　测试运行中的应用程序　　74
-
-4.4　小结　
-## 第5章　Groovy与Spring Boot CLI　
-5.1　开发Spring Boot CLI应用程序
-
-5.2　获取依赖
-
-5.3　用CLI运行测试
-5.4　创建可部署的产物
-5.5　小结
-## 第6章　在Spring Boot中使用Grails　　93
-6.1　使用GORM进行数据持久化　
-6.2　使用Groovy Server Pages定义视图　
-6.3　结合Spring Boot与Grails 3　　
-6.4　小结　　
-## 第7章　深入Actuator　　
-7.1　揭秘Actuator的端点　　
-
-7.2　连接Actuator的远程shell　
-
-7.3　通过JMX监控应用程序　　
-7.4　定制Actuator　　
-
-7.5　保护Actuator端点　　
-7.6　小结　　138
-## 第8章　部署Spring Boot应用程序　　139
-8.1　衡量多种部署方式　　139
-8.2　部署到应用服务器　　140
-8.2.1　构建WAR文件　　141
-8.2.2　创建生产Profile　　142
-8.2.3　开启数据库迁移　　145
-8.3　推上云端　　150
-8.3.1　部署到Cloud Foundry　　150
-8.3.2　部署到Heroku　　153
-8.4　小结　　155
-附录A　Spring Boot开发者工具　　157
-附录B　Spring Boot起步依赖　　163
-附录C　配置属性　　169
-附录D　Spring Boot依赖　　202
+## 第1章　入门　　1
+1.1　Spring风云再起　　1
+
+1.2　Spring Boot入门　　6
+
+1.3　小结　　18
+## 第2章　开发第一个应用程序　　19
+2.1　运用Spring Boot　　19
+
+2.2　使用起步依赖　　27
+
+2.3　使用自动配置　　30
+
+2.4　小结　　41
+## 第3章　自定义配置　　42
+3.1　覆盖Spring Boot自动配置　　42
+
+3.2　通过属性文件外置配置　　49
+
+3.3　定制应用程序错误页面　　62
+
+3.4　小结　　64
+
+## 第4章　测试　　66
+4.1　集成测试自动配置　　66
+4.2　测试Web应用程序　　68
+
+4.3　测试运行中的应用程序　　74
+
+4.4　小结　
+## 第5章　Groovy与Spring Boot CLI　
+5.1　开发Spring Boot CLI应用程序
+
+5.2　获取依赖
+
+5.3　用CLI运行测试
+5.4　创建可部署的产物
+5.5　小结
+## 第6章　在Spring Boot中使用Grails　　93
+6.1　使用GORM进行数据持久化　
+6.2　使用Groovy Server Pages定义视图　
+6.3　结合Spring Boot与Grails 3　　
+6.4　小结　　
+## 第7章　深入Actuator　　
+7.1　揭秘Actuator的端点　　
+
+7.2　连接Actuator的远程shell　
+
+7.3　通过JMX监控应用程序　　
+7.4　定制Actuator　　
+
+7.5　保护Actuator端点　　
+7.6　小结　　138
+## 第8章　部署Spring Boot应用程序　　139
+8.1　衡量多种部署方式　　139
+8.2　部署到应用服务器　　140
+8.2.1　构建WAR文件　　141
+8.2.2　创建生产Profile　　142
+8.2.3　开启数据库迁移　　145
+8.3　推上云端　　150
+8.3.1　部署到Cloud Foundry　　150
+8.3.2　部署到Heroku　　153
+8.4　小结　　155
+附录A　Spring Boot开发者工具　　157
+附录B　Spring Boot起步依赖　　163
+附录C　配置属性　　169
+附录D　Spring Boot依赖　　202
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\205\245\351\227\250.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\205\245\351\227\250.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\205\245\351\227\250.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\205\245\351\227\250.md"
index 431408a5..2b890b85 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\205\245\351\227\250.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2541\347\253\240 \345\205\245\351\227\250.md"	
@@ -1,8 +1,8 @@
-1.1　Spring风云再起　　1
-1.1.1　重新认识Spring　　2
-1.1.2　Spring Boot精要　　3
-1.1.3　Spring Boot不是什么　　6
-1.2　Spring Boot入门　　6
-1.2.1　安装Spring Boot CLI　　7
-1.2.2　使用Spring Initializr初始化Spring Boot项目　　10
-1.3　小结　　18
+1.1　Spring风云再起　　1
+1.1.1　重新认识Spring　　2
+1.1.2　Spring Boot精要　　3
+1.1.3　Spring Boot不是什么　　6
+1.2　Spring Boot入门　　6
+1.2.1　安装Spring Boot CLI　　7
+1.2.2　使用Spring Initializr初始化Spring Boot项目　　10
+1.3　小结　　18
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\274\200\345\217\221\347\254\254\344\270\200\344\270\252\345\272\224\347\224\250\347\250\213\345\272\217.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\274\200\345\217\221\347\254\254\344\270\200\344\270\252\345\272\224\347\224\250\347\250\213\345\272\217.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\274\200\345\217\221\347\254\254\344\270\200\344\270\252\345\272\224\347\224\250\347\250\213\345\272\217.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\274\200\345\217\221\347\254\254\344\270\200\344\270\252\345\272\224\347\224\250\347\250\213\345\272\217.md"
index 475efdbd..b5fb2456 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\274\200\345\217\221\347\254\254\344\270\200\344\270\252\345\272\224\347\224\250\347\250\213\345\272\217.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2542\347\253\240 \345\274\200\345\217\221\347\254\254\344\270\200\344\270\252\345\272\224\347\224\250\347\250\213\345\272\217.md"	
@@ -1,11 +1,11 @@
-2.1　运用Spring Boot　　19
-2.1.1　查看初始化的Spring Boot新项目　　21
-2.1.2　Spring Boot项目构建过程解析　　24
-2.2　使用起步依赖　　27
-2.2.1　指定基于功能的依赖　　28
-2.2.2　覆盖起步依赖引入的传递依赖　　29
-2.3　使用自动配置　　30
-2.3.1　专注于应用程序功能　　31
-2.3.2　运行应用程序　　36
-2.3.3　刚刚发生了什么　　38
-2.4　小结　　41
+2.1　运用Spring Boot　　19
+2.1.1　查看初始化的Spring Boot新项目　　21
+2.1.2　Spring Boot项目构建过程解析　　24
+2.2　使用起步依赖　　27
+2.2.1　指定基于功能的依赖　　28
+2.2.2　覆盖起步依赖引入的传递依赖　　29
+2.3　使用自动配置　　30
+2.3.1　专注于应用程序功能　　31
+2.3.2　运行应用程序　　36
+2.3.3　刚刚发生了什么　　38
+2.4　小结　　41
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2543\347\253\240 \350\207\252\345\256\232\344\271\211\351\205\215\347\275\256.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2543\347\253\240 \350\207\252\345\256\232\344\271\211\351\205\215\347\275\256.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2543\347\253\240 \350\207\252\345\256\232\344\271\211\351\205\215\347\275\256.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2543\347\253\240 \350\207\252\345\256\232\344\271\211\351\205\215\347\275\256.md"
index fbac3956..9607da9b 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2543\347\253\240 \350\207\252\345\256\232\344\271\211\351\205\215\347\275\256.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2543\347\253\240 \350\207\252\345\256\232\344\271\211\351\205\215\347\275\256.md"	
@@ -1,10 +1,10 @@
-3.1　覆盖Spring Boot自动配置　　42
-3.1.1　保护应用程序　　43
-3.1.2　创建自定义的安全配置　　44
-3.1.3　掀开自动配置的神秘面纱　　48
-3.2　通过属性文件外置配置　　49
-3.2.1　自动配置微调　　50
-3.2.2　应用程序Bean的配置外置　　55
-3.2.3　使用Profile进行配置　　59
-3.3　定制应用程序错误页面　　62
-3.4　小结　　64
+3.1　覆盖Spring Boot自动配置　　42
+3.1.1　保护应用程序　　43
+3.1.2　创建自定义的安全配置　　44
+3.1.3　掀开自动配置的神秘面纱　　48
+3.2　通过属性文件外置配置　　49
+3.2.1　自动配置微调　　50
+3.2.2　应用程序Bean的配置外置　　55
+3.2.3　使用Profile进行配置　　59
+3.3　定制应用程序错误页面　　62
+3.4　小结　　64
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2544\347\253\240 \346\265\213\350\257\225.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2544\347\253\240 \346\265\213\350\257\225.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2544\347\253\240 \346\265\213\350\257\225.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2544\347\253\240 \346\265\213\350\257\225.md"
index d2627214..74514b44 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2544\347\253\240 \346\265\213\350\257\225.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2544\347\253\240 \346\265\213\350\257\225.md"	
@@ -1,8 +1,8 @@
-4.1　集成测试自动配置　　66
-4.2　测试Web应用程序　　68
-4.2.1　模拟Spring MVC　　69
-4.2.2　测试Web安全　　72
-4.3　测试运行中的应用程序　　74
-4.3.1　用随机端口启动服务器　　75
-4.3.2　使用Selenium测试HTML页面　　76
-4.4　小结　　78
+4.1　集成测试自动配置　　66
+4.2　测试Web应用程序　　68
+4.2.1　模拟Spring MVC　　69
+4.2.2　测试Web安全　　72
+4.3　测试运行中的应用程序　　74
+4.3.1　用随机端口启动服务器　　75
+4.3.2　使用Selenium测试HTML页面　　76
+4.4　小结　　78
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2545\347\253\240 Groovy\344\270\216Spring Boot CLI.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2545\347\253\240 Groovy\344\270\216Spring Boot CLI.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2545\347\253\240 Groovy\344\270\216Spring Boot CLI.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2545\347\253\240 Groovy\344\270\216Spring Boot CLI.md"
index 8900d4dd..f0540ec8 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2545\347\253\240 Groovy\344\270\216Spring Boot CLI.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2545\347\253\240 Groovy\344\270\216Spring Boot CLI.md"	
@@ -1,10 +1,10 @@
-5.1　开发Spring Boot CLI应用程序　　80
-5.1.1　设置CLI项目　　81
-5.1.2　通过Groovy消除代码噪声　　81
-5.1.3　发生了什么　　85
-5.2　获取依赖　　86
-5.2.1　覆盖默认依赖版本　　87
-5.2.2　添加依赖仓库　　88
-5.3　用CLI运行测试　　89
-5.4　创建可部署的产物　　91
-5.5　小结　　91
+5.1　开发Spring Boot CLI应用程序　　80
+5.1.1　设置CLI项目　　81
+5.1.2　通过Groovy消除代码噪声　　81
+5.1.3　发生了什么　　85
+5.2　获取依赖　　86
+5.2.1　覆盖默认依赖版本　　87
+5.2.2　添加依赖仓库　　88
+5.3　用CLI运行测试　　89
+5.4　创建可部署的产物　　91
+5.5　小结　　91
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2546\347\253\240 \345\234\250Spring Boot\344\270\255\344\275\277\347\224\250Grails.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2546\347\253\240 \345\234\250Spring Boot\344\270\255\344\275\277\347\224\250Grails.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2546\347\253\240 \345\234\250Spring Boot\344\270\255\344\275\277\347\224\250Grails.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2546\347\253\240 \345\234\250Spring Boot\344\270\255\344\275\277\347\224\250Grails.md"
index a781ae6d..56bd38fc 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2546\347\253\240 \345\234\250Spring Boot\344\270\255\344\275\277\347\224\250Grails.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2546\347\253\240 \345\234\250Spring Boot\344\270\255\344\275\277\347\224\250Grails.md"	
@@ -1,8 +1,8 @@
-6.1　使用GORM进行数据持久化　　93
-6.2　使用Groovy Server Pages定义视图　　98
-6.3　结合Spring Boot与Grails 3　　100
-6.3.1　创建新的Grails项目　　100
-6.3.2　定义领域模型　　103
-6.3.3　开发Grails控制器　　104
-6.3.4　创建视图　　105
-6.4　小结　　107
+6.1　使用GORM进行数据持久化　　93
+6.2　使用Groovy Server Pages定义视图　　98
+6.3　结合Spring Boot与Grails 3　　100
+6.3.1　创建新的Grails项目　　100
+6.3.2　定义领域模型　　103
+6.3.3　开发Grails控制器　　104
+6.3.4　创建视图　　105
+6.4　小结　　107
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2547\347\253\240 \346\267\261\345\205\245Actuator.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2547\347\253\240 \346\267\261\345\205\245Actuator.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2547\347\253\240 \346\267\261\345\205\245Actuator.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2547\347\253\240 \346\267\261\345\205\245Actuator.md"
index e4bd1ece..27714451 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2547\347\253\240 \346\267\261\345\205\245Actuator.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2547\347\253\240 \346\267\261\345\205\245Actuator.md"	
@@ -1,19 +1,19 @@
-7.1　揭秘Actuator的端点　　108
-7.1.1　查看配置明细　　109
-7.1.2　运行时度量　　115
-7.1.3　关闭应用程序　　121
-7.1.4　获取应用信息　　121
-7.2　连接Actuator的远程shell　　122
-7.2.1　查看autoconfig报告　　123
-7.2.2　列出应用程序的Bean　　124
-7.2.3　查看应用程序的度量信息　　124
-7.2.4　调用Actuator端点　　125
-7.3　通过JMX监控应用程序　　126
-7.4　定制Actuator　　128
-7.4.1　修改端点ID　　128
-7.4.2　启用和禁用端点　　129
-7.4.3　添加自定义度量信息　　129
-7.4.4　创建自定义跟踪仓库　　132
-7.4.5　插入自定义健康指示器　　134
-7.5　保护Actuator端点　　136
-7.6　小结　　138
+7.1　揭秘Actuator的端点　　108
+7.1.1　查看配置明细　　109
+7.1.2　运行时度量　　115
+7.1.3　关闭应用程序　　121
+7.1.4　获取应用信息　　121
+7.2　连接Actuator的远程shell　　122
+7.2.1　查看autoconfig报告　　123
+7.2.2　列出应用程序的Bean　　124
+7.2.3　查看应用程序的度量信息　　124
+7.2.4　调用Actuator端点　　125
+7.3　通过JMX监控应用程序　　126
+7.4　定制Actuator　　128
+7.4.1　修改端点ID　　128
+7.4.2　启用和禁用端点　　129
+7.4.3　添加自定义度量信息　　129
+7.4.4　创建自定义跟踪仓库　　132
+7.4.5　插入自定义健康指示器　　134
+7.5　保护Actuator端点　　136
+7.6　小结　　138
diff --git "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2548\347\253\240 \351\203\250\347\275\262Spring Boot\345\272\224\347\224\250\347\250\213\345\272\217.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2548\347\253\240 \351\203\250\347\275\262Spring Boot\345\272\224\347\224\250\347\250\213\345\272\217.md"
similarity index 97%
rename from "10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2548\347\253\240 \351\203\250\347\275\262Spring Boot\345\272\224\347\224\250\347\250\213\345\272\217.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2548\347\253\240 \351\203\250\347\275\262Spring Boot\345\272\224\347\224\250\347\250\213\345\272\217.md"
index b018bc4f..3f8df8b2 100644
--- "a/10 - Reading Notes/SpringBoot\345\256\236\346\210\230/\347\254\2548\347\253\240 \351\203\250\347\275\262Spring Boot\345\272\224\347\224\250\347\250\213\345\272\217.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/SpringBoot\345\256\236\346\210\230/\347\254\2548\347\253\240 \351\203\250\347\275\262Spring Boot\345\272\224\347\224\250\347\250\213\345\272\217.md"	
@@ -1,9 +1,9 @@
-8.1　衡量多种部署方式　　139
-8.2　部署到应用服务器　　140
-8.2.1　构建WAR文件　　141
-8.2.2　创建生产Profile　　142
-8.2.3　开启数据库迁移　　145
-8.3　推上云端　　150
-8.3.1　部署到Cloud Foundry　　150
-8.3.2　部署到Heroku　　153
-8.4　小结　　155
+8.1　衡量多种部署方式　　139
+8.2　部署到应用服务器　　140
+8.2.1　构建WAR文件　　141
+8.2.2　创建生产Profile　　142
+8.2.3　开启数据库迁移　　145
+8.3　推上云端　　150
+8.3.1　部署到Cloud Foundry　　150
+8.3.2　部署到Heroku　　153
+8.4　小结　　155
diff --git "a/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\345\256\236\346\210\230/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\345\256\236\346\210\230/all.md"
new file mode 100644
index 00000000..db0948c8
--- /dev/null
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\345\256\236\346\210\230/all.md"	
@@ -0,0 +1,326 @@
+### 第1部分　Spring的核心
+### 第1章　Spring之旅　3
+1.1　简化Java开发　4
+1.1.1　激发POJO的潜能　5
+1.1.2　依赖注入　5
+1.1.3　应用切面　11
+1.1.4　使用模板消除样板式代码　16
+1.2　容纳你的Bean　18
+1.2.1　使用应用上下文　19
+1.2.2　bean的生命周期　20
+1.3　俯瞰Spring风景线　21
+1.3.1　Spring模块　22
+1.3.2　Spring Portfolio　24
+1.4　Spring的新功能　27
+1.4.1　Spring 3.1新特性　27
+1.4.2　Spring 3.2新特性　28
+1.4.3　Spring 4.0新特性　30
+1.5　小结　30
+### 第2章　装配Bean　33
+2.1　Spring配置的可选方案　34
+2.2　自动化装配bean　35
+2.2.1　创建可被发现的bean　35
+2.2.2　为组件扫描的bean命名　38
+2.2.3　设置组件扫描的基础包　39
+2.2.4　通过为bean添加注解实现自动装配　40
+2.2.5　验证自动装配　42
+2.3　通过Java代码装配
+bean　44
+2.3.1　创建配置类　44
+2.3.2　声明简单的bean　45
+2.3.3　借助JavaConfig实现注入　46
+2.4　通过XML装配bean　48
+2.4.1　创建XML配置规范　48
+2.4.2　声明一个简单的
+[bean]　49
+2.4.3　借助构造器注入初始化bean　50
+2.4.4　设置属性　56
+2.5　导入和混合配置　61
+2.5.1　在JavaConfig中引用XML配置　61
+2.5.2　在XML配置中引用JavaConfig　63
+2.6　小结　65
+### 第3章　高级装配　67
+3.1　环境与profile　67
+3.1.1　配置profile bean　69
+3.1.2　激活profile　73
+3.2　条件化的bean　75
+3.3　处理自动装配的歧义性　78
+3.3.1　标示首选的bean　79
+3.3.2　限定自动装配的bean　80
+3.4　bean的作用域　84
+3.4.1　使用会话和请求作用域　86
+3.4.2　在XML中声明作用域代理　88
+3.5　运行时值注入　88
+3.5.1　注入外部的值　89
+3.5.2　使用Spring表达式语言进行装配　93
+3.6　小结　99
+### 第4章　面向切面的Spring　101
+4.1　什么是面向切面编程？　102
+4.1.1　定义AOP术语　103
+4.1.2　Spring对AOP的支持　105
+4.2　通过切点来选择连接点　107
+4.2.1　编写切点　108
+4.2.2　在切点中选择bean　109
+4.3　使用注解创建切面　109
+4.3.1　定义切面　110
+4.3.2　创建环绕通知　114
+4.3.3　处理通知中的参数　115
+4.3.4　通过注解引入新功能　118
+4.4　在XML中声明切面　120
+4.4.1　声明前置和后置通知　122
+4.4.2　声明环绕通知　124
+4.4.3　为通知传递参数　125
+4.4.4　通过切面引入新的功能　127
+4.5　注入AspectJ切面　128
+4.5　小结　131
+### 第２部分　Web中的Spring
+### 第5章　构建Spring Web应用程序　135
+5.1　Spring MVC起步　136
+5.1.1　跟踪Spring MVC的请求　136
+5.1.2　搭建Spring MVC　138
+5.1.3　Spittr应用简介　142
+5.2　编写基本的控制器　143
+5.2.1　测试控制器　145
+5.2.2　定义类级别的请求处理　146
+5.2.3　传递模型数据到视图中　147
+5.3　接受请求的输入　153
+5.3.1　处理查询参数　153
+5.3.2　通过路径参数接受输入　155
+5.4　处理表单　157
+5.4.1　编写处理表单的控制器　160
+5.4.2　校验表单　163
+5.5　小结　166
+### 第6章　渲染Web视图　167
+6.1　理解视图解析　167
+6.2　创建JSP视图　170
+6.2.1　配置适用于JSP的视图解析器　170
+6.2.2　使用Spring的JSP库　172
+6.3　使用Apache Tiles视图定义布局　184
+6.3.1　配置Tiles视图解析器　185
+6.4　使用Thymeleaf　190
+6.4.1　配置Thymeleaf视图解析器　190
+6.4.2　定义Thymeleaf模板　192
+6.5　小结　196
+### 第7章　Spring MVC的高级技术　197
+7.1　Spring MVC配置的替代方案　198
+7.1.1　自定义DispatcherServlet配置　198
+7.1.2　添加其他的Servlet和Filter　199
+7.1.3　在web.xml中声明DispatcherServlet　201
+7.2　处理multipart形式的数据　204
+7.2.1　配置multipart解析器　205
+7.2.2　处理multipart请求　208
+7.3　处理异常　212
+7.3.1　将异常映射为HTTP状态码　213
+7.3.2　编写异常处理的方法　214
+7.4　为控制器添加通知　216
+7.5　跨重定向请求传递数据　217
+7.5.1　通过URL模板进行重定向　218
+7.5.2　使用flash属性　219
+7.6　小结　221
+### 第8章　使用Spring WebFlow　223
+8.1　在Spring中配置Web　Flow　224
+8.1.1　装配流程执行器　224
+8.1.2　配置流程注册表　224
+8.1.3　处理流程请求　225
+8.2　流程的组件　226
+8.2.1　状态　226
+8.2.2　转移　230
+8.2.3　流程数据　231
+8.3　组合起来：披萨流程　232
+8.3.1　定义基本流程　233
+8.3.2　收集顾客信息　236
+8.3.2　构建订单　242
+8.3.2　支付　244
+8.4　保护Web流程　246
+8.5　小结　246
+### 第9章　保护Web应用　249
+9.1　Spring Security简介　250
+9.1.1　理解Spring Security的模块　250
+9.1.2　过滤Web请求　251
+9.1.3　编写简单的安全性配置　252
+9.2　选择查询用户详细信息的服务　255
+9.2.1使用基于内存的用户存储　255
+9.2.2　基于数据库表进行认证　257
+9.2.3　基于LDAP进行认证　259
+9.2.4　配置自定义的用户服务　263
+9.3　拦截请求　265
+9.3.1　使用Spring表达式进行安全保护　267
+9.3.2　强制通道的安全性　269
+9.3.3　防止跨站请求伪造　270
+9.4　认证用户　271
+9.4.1　添加自定义的登录页　272
+9.4.2　启用HTTP Basic认证　274
+9.4.3　启用Remember-me功能　274
+9.4.4　退出　275
+9.5　保护视图　276
+9.5.1　使用Spring Security的JSP标签库　276
+9.5.2　使用Thymeleaf的SpringSecurity方言　280
+9.6　小结　281
+### 第3部分　后端中的Spring
+### 第10章　通过Spring和JDBC征服数据库　285
+10.1　Spring的数据访问哲学　286
+10.1.1　了解Spring的数据访问异常体系　287
+10.1.2　数据访问模板化　289
+10.2　配置数据源　291
+10.2.1　使用JNDI数据源　292
+10.2.2　使用数据源连接池　292
+10.2.3　基于JDBC驱动的数据源　294
+10.2.4　使用嵌入式的数据源　295
+10.2.5　使用profile选择数据源　296
+10.3　在Spring中使用
+JDBC　298
+10.3.1　应对失控的JDBC代码　299
+10.3.2　使用JDBC模板　302
+10.4　小结　307
+### 第11章　使用对象-关系映射持久化数据　309
+11.1　在Spring中集成Hibernate　310
+11.1.1　声明Hibernate的Session工厂　311
+11.1.2　构建不依赖于Spring的Hibernate代码　313
+11.2　Spring与Java持久化API　315
+11.2.1　配置实体管理器工厂　315
+11.2.2　编写基于JPA的Repository　320
+11.3　借助Spring Data实现自动化的JPA　Repository　322
+11.3.1　定义查询方法　325
+11.3.2　声明自定义查询　328
+11.3.3　混合自定义的功能　329
+11.4　小结　330
+### 第12章　使用NoSQL数据库　333
+12.1　使用MongoDB持久化文档数据　334
+12.1.1　启用MongoDB　335
+12.1.2　为模型添加注解，实现MongoDB持久化　338
+12.1.3　使用MongoTemplate访问MongoDB　341
+12.1.4　编写MongoDBRepository　342
+12.2　使用Neo4j操作图数据　347
+12.2.1　配置Spring DataNeo4j　347
+12.2.2　使用注解标注图实体　350
+12.2.3　使用Neo4jTemplate　353
+12.2.4　创建自动化的Neo4j　Repository　354
+12.3　使用Redis操作key-value数据　359
+12.3.1　连接到Redis　359
+12.3.2　使用RedisTemplate　360
+12.3.3　使用key和value的序列化器　364
+12.4　小结　365
+### 第13章　缓存数据　367
+13.1　启用对缓存的支持　368
+13.1.1　配置缓存管理器　369
+13.2　为方法添加注解以支持缓存　373
+13.2.1　填充缓存　374
+13.2.2　移除缓存条目　378
+13.3　使用XML声明缓存　379
+13.4　小结　383
+### 第14章　保护方法应用　385
+14.1　使用注解保护方法　386
+14.1.1　使用@Secured注解限制方法调用　386
+14.1.2　在Spring Security中使用
+JSR-250的@RolesAllowed注解　387
+14.2　使用表达式实现方法级别的安全性　388
+14.2.1　表述方法访问规则　389
+14.2.2　过滤方法的输入和输出　391
+14.3　小结　395
+### 第4部分　Spring集成
+### 第15章　使用远程服务　399
+15.1　Spring远程调用概览　400
+15.2　使用RMI　402
+15.2.1　导出RMI服务　403
+15.2.2　装配RMI服务　405
+15.3　使用Hessian和Burlap发布远程服务　407
+15.3.1　使用Hessian和Burlap导出bean的功能　408
+15.3.2　访问Hessian/Burlap服务　411
+15.4　使用Spring的HttpInvoker　413
+15.4.1　将bean导出为HTTP服务　413
+15.4.2　通过HTTP访问服务　414
+15.5　发布和使用Web服务　416
+15.5.1　创建基于Spring的JAX-WS端点　416
+15.5.2　在客户端代理JAX-WS服务　419
+15.6　小结　421
+### 第16章　使用Spring MVC创建REST API　423
+16.1　了解REST　424
+16.1.1　REST的基础知识　424
+16.1.2　Spring是如何支持REST的　425
+16.2　创建### 第一个REST端点　426
+16.2.1　协商资源表述　428
+16.2.2　使用HTTP信息转换器　433
+16.3　提供资源之外的其他内容　438
+16.3.1　发送错误信息到客户端　438
+16.3.2　在响应中设置头部信息　443
+16.4　编写REST客户端　445
+16.4.1　了解RestTemplate的操作　446
+16.4.2　GET资源　447
+16.4.3　检索资源　448
+16.4.4　抽取响应的元数据　449
+16.4.5　PUT资源　450
+16.4.6　DELETE资源　451
+16.4.7　POST资源数据　452
+16.4.8　在POST请求中获取响应对象　452
+16.4.9　在POST请求后获取资源位置　453
+16.4.10　交换资源　454
+16.5　小结　456
+### 第17章　Spring消息　457
+17.1　异步消息简介　458
+17.1.1　发送消息　459
+17.1.2　评估异步消息的优点　461
+17.2　使用JMS发送消息　463
+17.2.1　在Spring中搭建消息代理　463
+17.2.2　使用Spring的JMS模板　465
+17.2.3　创建消息驱动的POJO　474
+17.2.4　使用基于消息的RPC　477
+17.3　使用AMQP实现消息功能　479
+17.3.1　AMQP简介　480
+17.3.2　配置Spring支持AMQP消息　481
+17.3.3　使用RabbitTemplate发送消息　484
+17.3.4　接收AMQP消息　486
+17.4　小结　489
+### 第18章　使用WebSocket和STOMP实现消息功能　491
+18.1　使用Spring的低层级WebSocket　API　492
+18.2　应对不支持WebSocket的场景　497
+18.3　使用STOMP消息　500
+18.3.1　启用STOMP消息功能　501
+18.3.2　处理来自客户端的STOMP消息　504
+18.3.3　发送消息到客户端　507
+18.4　为目标用户发送消息　511
+18.4.1　在控制器中处理用户的消息　512
+18.4.2　为指定用户发送消息　514
+18.5　处理消息异常　515
+18.6　小结　516
+### 第19章　使用Spring发送Email　517
+19.1　配置Spring发送邮件　518
+19.1.1　配置邮件发送器　518
+19.1.2　装配和使用邮件发送器　520
+19.2　构建丰富内容的Email消息　521
+19.2.1　添加附件　521
+19.2.2　发送富文本内容的Email　522
+19.3　使用模板生成Email　524
+19.3.1　使用Velocity构建Email消息　524
+19.3.2　使用Thymeleaf构建Email消息　526
+19.4　小结　528
+### 第20章　使用JMX管理Spring　Bean　529
+20.1　将Spring bean导出为MBean　530
+20.1.1　通过名称暴露方法　533
+20.1.2　使用接口定义MBean的操作和属性　535
+20.1.3　使用注解驱动的MBean　536
+20.1.4　处理MBean冲突　538
+20.2　远程MBean　539
+20.2.1　暴露远程MBean　539
+20.2.2　访问远程MBean　540
+20.2.3　代理MBean　542
+20.3　处理通知　543
+20.3.1　监听通知　544
+20.4　小结　545
+### 第21章　借助Spring Boot简化Spring开发　547
+21.1　Spring Boot简介　548
+21.1.1　添加Starter依赖　548
+21.1.2　自动配置　552
+21.1.3　Spring Boot CLI　552
+21.1.4　Actuator　553
+21.2　使用Spring Boot构建应用　553
+21.2.1　处理请求　556
+21.2.2　创建视图　558
+21.2.3　添加静态内容　560
+21.2.4　持久化数据　561
+21.2.5　尝试运行　563
+21.3　组合使用Groovy与SpringBoot　CLI　566
+21.3.1　编写Groovy控制器　566
+21.3.2　使用Groovy Repository实现数据持久化　569
+21.3.3　运行Spring Boot CLI　570
+21.4　通过Actuator获取了解应用内部状况　571
+21.5　小结　574
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220.txt" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220.txt"
similarity index 95%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220.txt"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220.txt"
index c8091a20..10cc7c1f 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220.txt"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220.txt"	
@@ -1,16 +1,16 @@
-前言
-	阅读源码是一个非常好的学习方式
-
-第一章 Spring整体架构和环境搭建
-
-	Spring 分为大约20个模块
-	Core Container 包含 Core、Beans、Context、Expresssion Language模块
-
-第二章	容器的基本实现
-
-	封装Resource
-	XML验证
-	加载Document
-	解析注册Bean
-
-第三章 默认标签的解析
+前言
+	阅读源码是一个非常好的学习方式
+
+第一章 Spring整体架构和环境搭建
+
+	Spring 分为大约20个模块
+	Core Container 包含 Core、Beans、Context、Expresssion Language模块
+
+第二章	容器的基本实现
+
+	封装Resource
+	XML验证
+	加载Document
+	解析注册Bean
+
+第三章 默认标签的解析
diff --git "a/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/all.md"
new file mode 100644
index 00000000..835deb78
--- /dev/null
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/all.md"	
@@ -0,0 +1,150 @@
+## 第一部分　核心实现
+### 第1章　Spring整体架构和环境搭建　2
+1.1　Spring的整体架构　2
+1.2　环境搭建　4
+1.2.1　安装GitHub　4
+1.2.2　安装Gradle　5
+1.2.3　下载Spring　6
+### 第2章　容器的基本实现　10
+2.1　容器基本用法　10
+2.2　功能分析　11
+2.3　工程搭建　12
+2.4　Spring的结构组成　13
+2.4.1　beans包的层级结构　13
+2.4.2　核心类介绍　13
+2.5　容器的基础XmlBeanFactory　17
+2.5.1　配置文件封装　18
+2.5.2　加载Bean　21
+2.6　获取XML的验证模式　24
+2.6.1　DTD与XSD区别　24
+2.6.2　验证模式的读取　26
+2.7　获取Document　28
+2.7.1　EntityResolver用法　29
+2.8　解析及注册BeanDefinitions　31
+2.8.1　profile属性的使用　32
+2.8.2　解析并注册BeanDefinition　33
+### 第3章　默认标签的解析　35
+3.1　bean标签的解析及注册　35
+3.1.1　解析BeanDefinition　37
+3.1.2　AbstractBeanDefinition属性　55
+3.1.3　解析默认标签中的自定义标签元素　58
+3.1.4　注册解析的BeanDefinition　60
+3.1.5　通知监听器解析及注册完成　63
+3.2　alias标签的解析　63
+3.3　import标签的解析　65
+3.4　嵌入式beans标签的解析　67
+### 第4章　自定义标签的解析　68
+4.1　自定义标签使用　69
+4.2　自定义标签解析　71
+4.2.1　获取标签的命名空间　72
+4.2.2　提取自定义标签处理器　72
+4.2.3　标签解析　74
+### 第5章　bean的加载　78
+5.1　FactoryBean的使用　83
+5.2　缓存中获取单例bean　85
+5.3　从bean的实例中获取对象　86
+5.4　获取单例　90
+5.5　准备创建bean　92
+5.5.1　处理ovverride属性　93
+5.5.2　实例化的前置处理　94
+5.6　循环依赖　96
+5.6.1　什么是循环依赖　96
+5.6.2　Spring如何解决循环依赖　96
+5.7　创建bean　100
+5.7.1　创建bean的实例　103
+5.7.2　记录创建bean的ObjectFactory　112
+5.7.3　属性注入　115
+5.7.4　初始化bean　124
+5.7.5　注册DisposableBean　128
+### 第6章　容器的功能扩展　129
+6.1　设置配置路径　130
+6.2　扩展功能　130
+6.3　环境准备　132
+6.4　加载BeanFactory　133
+6.4.1　定制BeanFactory　135
+6.4.2　加载BeanDefinition　136
+6.5　功能扩展　137
+6.5.1　增加SPEL语言的支持　138
+6.5.2　增加属性注册编辑器　139
+6.5.3　添加ApplicationContext AwareProcessor处理器　144
+6.5.4　设置忽略依赖　146
+6.5.5　注册依赖　146
+6.6　BeanFactory的后处理　146
+6.6.1　激活注册的BeanFactory PostProcessor　147
+6.6.2　注册BeanPostProcessor　153
+6.6.3　初始化消息资源　156
+6.6.4　初始化ApplicationEvent Multicaster　159
+6.6.5　注册监听器　161
+6.7　初始化非延迟加载单例　162
+6.8　finishRefresh　165
+### 第7章　AOP　167
+7.1　动态AOP使用示例　167
+7.2　动态AOP自定义标签　169
+7.2.1　注册AnnotationAwareAspectJ AutoProxyCreator　170
+7.3　创建AOP代理　173
+7.3.1　获取增强器　176
+7.3.2　寻找匹配的增强器　186
+7.3.3　创建代理　187
+7.4　静态AOP使用示例　201
+7.5　创建AOP静态代理　203
+7.5.1　Instrumentation使用　203
+7.5.2　自定义标签　207
+7.5.3　织入　209
+## 第二部分　企业应用
+### 第8章　数据库连接JDBC　214
+8.1　Spring连接数据库程序实现(JDBC)　215
+8.2　save/update功能的实现　217
+8.2.1　基础方法execute　219
+8.2.2　Update中的回调函数　223
+8.3　query功能的实现　225
+8.4　queryForObject　229
+### 第9章　整合MyBatis　231
+9.1　MyBatis独立使用　231
+9.2　Spring整合MyBatis　235
+9.3　源码分析　237
+9.3.1　sqlSessionFactory创建　237
+9.3.2　MapperFactoryBean的创建　241
+9.3.3　MapperScannerConfigurer　244
+### 第10章　事务　254
+10.1　JDBC方式下的事务使用 示例　254
+10.2　事务自定义标签　257
+10.2.1　注册InfrastructureAdvisor AutoProxyCreator　257
+10.2.2　获取对应class/method的增强器　261
+10.3　事务增强器　269
+10.3.1　创建事务　271
+10.3.2　回滚处理　281
+10.3.3　事务提交　287
+### 第11章　SpringMVC　291
+11.1　SpringMVC快速体验　291
+11.2　ContextLoaderListener　295
+11.2.1　ServletContextListener的使用　295
+11.2.2　Spring中的ContextLoader Listener　296
+11.3　DispatcherServlet　300
+11.3.1　servlet的使用　301
+11.3.2　DispatcherServlet的初始化　302
+11.3.3　WebApplicationContext的初始化　304
+11.4　DispatcherServlet的逻辑处理　320
+11.4.1　MultipartContent类型的request处理　326
+11.4.2　根据request信息寻找对应的Handler　327
+11.4.3　没找到对应的Handler的错误处理　331
+11.4.4　根据当前Handler寻找对应的HandlerAdapter　331
+11.4.5　缓存处理　332
+11.4.6　HandlerInterceptor的处理　333
+11.4.7　逻辑处理　334
+11.4.8　异常视图的处理　334
+11.4.9　根据视图跳转页面　335
+### 第12章　远程服务　340
+12.1　RMI　340
+12.1.1　使用示例　340
+12.1.2　服务端实现　342
+12.1.3　客户端实现　350
+12.2　HttpInvoker　355
+12.2.1　使用示例　356
+12.2.2　服务端实现　357
+12.2.3　客户端实现　361
+### 第13章　Spring消息　367
+13.1　JMS的独立使用　367
+13.2　Spring整合ActiveMQ　369
+13.3　源码分析　371
+13.3.1　JmsTemplate　372
+13.3.2　监听器容器　376
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2545\347\253\240 bean\347\232\204\345\212\240\350\275\275.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25410\347\253\240 \344\272\213\345\212\241.md"
similarity index 100%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2545\347\253\240 bean\347\232\204\345\212\240\350\275\275.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25410\347\253\240 \344\272\213\345\212\241.md"
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25411\347\253\240 SpringMVC.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25411\347\253\240 SpringMVC.md"
similarity index 98%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25411\347\253\240 SpringMVC.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25411\347\253\240 SpringMVC.md"
index a25b3964..2b02708b 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25411\347\253\240 SpringMVC.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25411\347\253\240 SpringMVC.md"	
@@ -1,139 +1,139 @@
-## 11.1 SpringMVC快速体验
-
-## 11.2 **ContextLoaderListener**
-对于SpringMVC功能实现的分析，
-  ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。
-  因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。
-
-  每一个Web应用都有一个ServletContext与之相关联。ServletContext对象在应用启动被创建，在应用关闭的时候被销毁。
-
-  在ServletContextListener中的核心逻辑便是初始化WebApplicationContext实例并存放至ServletContext
-
-### 11.2.1 **ServletContextListener** 的使用
-  目标是在系统启动时添加自定义的属性
-
-``` java
-  实现 ServletContextListener
-  // 容器启动执行方法
-	public void contextInitialized(final ServletContextEvent event) {}
-  // 容器关闭执行方法
-	public void contextDestroyed(final ServletContextEvent event) {}
-```
-注册监听器
-在Web.xml文件中需要注册自定义的容器
-<listener>
-com.XXX.xxxListener
-</listener>
-
-### 11.2.2 Spring中的 **ContextLoaderListener**
-  ContextLoaderListener只是辅助功能，用于创建WebApplicationContext类型实例。
-  **initWebApplicationContext** 函数主要体现了创建WebApplicationContext实例的一个功能架构，从函数中我们看到了初始化的大致步骤
-1. WebApplicationContext存在性的验证
-2. 创建WebApplicationContext实例
-  委托给 **createWebApplicationContext** 函数
-3. 将实例记录在servletContext中
-4. 映射当前的类加载器与创建的实例到全局变量currentContextPerThread中
-
-## 11.3 DispatcherServlet
-  DispatcherServlet是实现Servlet接口的实现类。
-  Servlet的生命周期 初始化 运行 销毁
-  1. **初始化** 阶段
-  a Servlet容器加载servlet类，把它的.Class文件中的数据读到内存中。
-  b Servlet容器创建servletConfig对象。servletConfig对象包含了servlet的初始化配置信息。此外 servlet容器还会使得servletConfig对象与当前的web应用的servletContext对象关联。
-  c Servlet容器创建servlet对象。
-  d Servlet容器调用servlet对象的 **init(ServletConfig config)** 方法。
-  2. **运行** 阶段
-  当servlet容器接到访问特定的servlet请求时，servlet容器会针对与这个请求创建servletRequest和servletResponse对象，然后调用service()方法。
-  并把这两个对象当做参数传递给service()方法。Service()方法通过servletRequest对象获得请求信息，并处理该请求，再通过servletResponse对象生成响应结果。
-  然后销毁servletRequest和sevletResponse对象。
-  不管是post还是get方法提交，都会在service中处理，然后，由service来交由相应的doPost或doGet方法处理，如果你重写了service方法，就不会再处理doPost或doGet了，如果重写sevice()方法，可以自己转向doPost()或doGet（）方法
-  3. **销毁** 阶段
-  当Web应用被终止时，servlet容器会先调用web应用中所有的servlet对象的 **destroy（）** 方法，然后在销毁servlet对象。
-  此外容器还会销毁与servlet对象关联的servletConfig对象。
-  在destroy（）方法的实现中，可以释放servlet所占用的资源。如关闭文件输入输出流，关闭与数据库的连接。
-  注：sevlet的生命周期中，servlet的初始化和销毁只会发生一次，因此init()和destroy（）方法只能被servlet容器调用一次，而service()方法取决与servlet被客户端访问的次数。
-
-  HTTP的请求方式包括delete,get,options,post,put,trace 在HttpServlet类中分别提供了相应的服务方法，是
-  doDelete(),doGet(),doOption(),doPost(),doPut(),doTrace()
-
-### 11.3.1 servlet的使用
-  实现HttpServlet
-``` java
-init()
-doGet()
-doPost()
-```
-web.xml添加<servlet>配置
-``` xml
-<servlet>
-    <servlet-name></servlet-name>
-    <servlet-class></servlet-class>
-    <load-in-startup></load-in-startup>
-</servlet>
-<servlet-mapping>
-    <servlet-name></servlet-name>
-    <url-pattern></url-pattern>
-</servlet-mapping>
-```
-
-### 11.3.2 **DispatcherServlet** 的初始化
-  init()
-  主要是通过将当前的Servlet类型实例转换为BeanWrapper类型实例，以便使用Spring中提供的注入功能进行对应属性的注入。
-  这些属性如contextAttribute、 contextClass、nameSpace、contextConfigLocation等，都可以在web.xml文件以初始化参数的方式配置在Servlet的声明中。
-  DispatcherServlet继承自FrameworkServlet，FrameworkServlet类上包含对应的同名属性，Spring会保证这些参数被注入到对应的值中。
-  属性注入主要包含以下步骤：
-  1. 封装及验证初始化参数
-  2. 将当前Servlet实例转化成BeanWrapper实例
-  3. 注册相对于Resource的属性编辑器
-  4. 属性注入
-  5. ServletBean的初始化
-
-### 11.3.3 WebApplicationContext的初始化
-  initWebApplicationContext函数的主要工作就是创建或刷新WebApplicationContext实例并对Servlet功能所使用的变量进行初始化。
-  包含几个部分：
-  1. 寻找或创建对应的WebApplicationContext实例
-    1. 通过构造函数的注入进行初始化
-    2. 通过contextAttribute进行初始化
-    3. 重新创建WebApplicationContext实例
-  2. configureAndRefreshWebApplicationContext
-    configureAndRefreshWebApplicationContext方法来对已经创建的 WebApplicationContext 实例进行配置及刷新
-
-  3. 刷新
-    doRefresh是FrameworkServlet类中提供的 **模板** 方法，在其子类DispatcherServlet中进行了重写，主要用于刷新Spring在Web功能实现中所必须使用的全局变量。
-    主要介绍初始化过程以及使用场景。
-    1. 初始化 **MultipartResolver**
-      处理文件上传
-    2. 初始化 **LocaleResolver**
-      国际化配置
-      三种配置方法 基于URL参数的配置 基于session的配置 基于cookie的国际化配置
-    3. 初始化 **ThemeResolver**
-      主题控制网页风格
-    4. 初始化 **HandlerMappings**
-      当客户端发出Request时DispatcherServlet会将Request提交给HandlerMapping，然后HandlerMapping根据WebAppliction Context的配置来回传给DispatcherServlet相应的Controller。
-    5. 初始化 **HandlerAdapters**
-      适配器模式将一个类的接口适配成用户所期待的。使用适配器，可以使接口不兼容而无法在一起工作的类协同工作，做法是将类自己的接口包裹在一个已存在的类中。
-      Http请求处理器适配器 HttpRequestHandlerAdapter
-      简单控制器处理器适配器 SimpleControllerHandlerAdapter
-      注解方法处理器适配器 AnnotationMethodHandlerAdapter
-    6. 初始化 **HandlerExceptionResolvers**
-      基于HandlerExceptionResolver接口的异常处理，使用这种方式只需要实现resolveException方法，该方法返回一个ModelandView对象，在方法内部对异常的类型进行判断，
-    7. 初始化 **RequestToViewNameTranslator**
-      当Controller处理器方法没有返回一个View对象或逻辑视图名称，并且在该方法中没有直接往response的输出流里面写数据的时候，Spring就会采用约定好的方式提供一个逻辑视图名称。
-    8. 初始化 **ViewResolvers**
-      在SpringMVC中，当Controller将请求处理结果放入到ModelAndView中以后，DispatcherServlet会根据ModelAndView选择合适的视图进行渲染。
-    9. 初始化 **FlashMapManager**
-      SpringMVCFlash attributes提供了一个请求存储属性，可供其他请求使用，例如Post/Redirect/Get模式
-      Flash attributes在重定向之前暂存（就像存在session中）以便重定向之后还能使用，并立即删除。
-
-
-## 11.4 DispatcherServlet的逻辑处理
-  processRequest(request,response)
-　　11.4.1 MultipartContent类型的request处理
-　　11.4.2 根据request信息寻找对应的Handler
-　　11.4.3 没找到对应的Handler的错误处理
-　　11.4.4 根据当前Handler寻找对应的HandlerAdapter
-　　11.4.5 缓存处理
-　　11.4.6 HandlerInterceptor的处理
-　　11.4.7 逻辑处理
-　　11.4.8 异常视图的处理
-　　11.4.9 根据视图跳转页面
+## 11.1 SpringMVC快速体验
+
+## 11.2 **ContextLoaderListener**
+对于SpringMVC功能实现的分析，
+  ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。
+  因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。
+
+  每一个Web应用都有一个ServletContext与之相关联。ServletContext对象在应用启动被创建，在应用关闭的时候被销毁。
+
+  在ServletContextListener中的核心逻辑便是初始化WebApplicationContext实例并存放至ServletContext
+
+### 11.2.1 **ServletContextListener** 的使用
+  目标是在系统启动时添加自定义的属性
+
+``` java
+  实现 ServletContextListener
+  // 容器启动执行方法
+	public void contextInitialized(final ServletContextEvent event) {}
+  // 容器关闭执行方法
+	public void contextDestroyed(final ServletContextEvent event) {}
+```
+注册监听器
+在Web.xml文件中需要注册自定义的容器
+<listener>
+com.XXX.xxxListener
+</listener>
+
+### 11.2.2 Spring中的 **ContextLoaderListener**
+  ContextLoaderListener只是辅助功能，用于创建WebApplicationContext类型实例。
+  **initWebApplicationContext** 函数主要体现了创建WebApplicationContext实例的一个功能架构，从函数中我们看到了初始化的大致步骤
+1. WebApplicationContext存在性的验证
+2. 创建WebApplicationContext实例
+  委托给 **createWebApplicationContext** 函数
+3. 将实例记录在servletContext中
+4. 映射当前的类加载器与创建的实例到全局变量currentContextPerThread中
+
+## 11.3 DispatcherServlet
+  DispatcherServlet是实现Servlet接口的实现类。
+  Servlet的生命周期 初始化 运行 销毁
+  1. **初始化** 阶段
+  a Servlet容器加载servlet类，把它的.Class文件中的数据读到内存中。
+  b Servlet容器创建servletConfig对象。servletConfig对象包含了servlet的初始化配置信息。此外 servlet容器还会使得servletConfig对象与当前的web应用的servletContext对象关联。
+  c Servlet容器创建servlet对象。
+  d Servlet容器调用servlet对象的 **init(ServletConfig config)** 方法。
+  2. **运行** 阶段
+  当servlet容器接到访问特定的servlet请求时，servlet容器会针对与这个请求创建servletRequest和servletResponse对象，然后调用service()方法。
+  并把这两个对象当做参数传递给service()方法。Service()方法通过servletRequest对象获得请求信息，并处理该请求，再通过servletResponse对象生成响应结果。
+  然后销毁servletRequest和sevletResponse对象。
+  不管是post还是get方法提交，都会在service中处理，然后，由service来交由相应的doPost或doGet方法处理，如果你重写了service方法，就不会再处理doPost或doGet了，如果重写sevice()方法，可以自己转向doPost()或doGet（）方法
+  3. **销毁** 阶段
+  当Web应用被终止时，servlet容器会先调用web应用中所有的servlet对象的 **destroy（）** 方法，然后在销毁servlet对象。
+  此外容器还会销毁与servlet对象关联的servletConfig对象。
+  在destroy（）方法的实现中，可以释放servlet所占用的资源。如关闭文件输入输出流，关闭与数据库的连接。
+  注：sevlet的生命周期中，servlet的初始化和销毁只会发生一次，因此init()和destroy（）方法只能被servlet容器调用一次，而service()方法取决与servlet被客户端访问的次数。
+
+  HTTP的请求方式包括delete,get,options,post,put,trace 在HttpServlet类中分别提供了相应的服务方法，是
+  doDelete(),doGet(),doOption(),doPost(),doPut(),doTrace()
+
+### 11.3.1 servlet的使用
+  实现HttpServlet
+``` java
+init()
+doGet()
+doPost()
+```
+web.xml添加<servlet>配置
+``` xml
+<servlet>
+    <servlet-name></servlet-name>
+    <servlet-class></servlet-class>
+    <load-in-startup></load-in-startup>
+</servlet>
+<servlet-mapping>
+    <servlet-name></servlet-name>
+    <url-pattern></url-pattern>
+</servlet-mapping>
+```
+
+### 11.3.2 **DispatcherServlet** 的初始化
+  init()
+  主要是通过将当前的Servlet类型实例转换为BeanWrapper类型实例，以便使用Spring中提供的注入功能进行对应属性的注入。
+  这些属性如contextAttribute、 contextClass、nameSpace、contextConfigLocation等，都可以在web.xml文件以初始化参数的方式配置在Servlet的声明中。
+  DispatcherServlet继承自FrameworkServlet，FrameworkServlet类上包含对应的同名属性，Spring会保证这些参数被注入到对应的值中。
+  属性注入主要包含以下步骤：
+  1. 封装及验证初始化参数
+  2. 将当前Servlet实例转化成BeanWrapper实例
+  3. 注册相对于Resource的属性编辑器
+  4. 属性注入
+  5. ServletBean的初始化
+
+### 11.3.3 WebApplicationContext的初始化
+  initWebApplicationContext函数的主要工作就是创建或刷新WebApplicationContext实例并对Servlet功能所使用的变量进行初始化。
+  包含几个部分：
+  1. 寻找或创建对应的WebApplicationContext实例
+    1. 通过构造函数的注入进行初始化
+    2. 通过contextAttribute进行初始化
+    3. 重新创建WebApplicationContext实例
+  2. configureAndRefreshWebApplicationContext
+    configureAndRefreshWebApplicationContext方法来对已经创建的 WebApplicationContext 实例进行配置及刷新
+
+  3. 刷新
+    doRefresh是FrameworkServlet类中提供的 **模板** 方法，在其子类DispatcherServlet中进行了重写，主要用于刷新Spring在Web功能实现中所必须使用的全局变量。
+    主要介绍初始化过程以及使用场景。
+    1. 初始化 **MultipartResolver**
+      处理文件上传
+    2. 初始化 **LocaleResolver**
+      国际化配置
+      三种配置方法 基于URL参数的配置 基于session的配置 基于cookie的国际化配置
+    3. 初始化 **ThemeResolver**
+      主题控制网页风格
+    4. 初始化 **HandlerMappings**
+      当客户端发出Request时DispatcherServlet会将Request提交给HandlerMapping，然后HandlerMapping根据WebAppliction Context的配置来回传给DispatcherServlet相应的Controller。
+    5. 初始化 **HandlerAdapters**
+      适配器模式将一个类的接口适配成用户所期待的。使用适配器，可以使接口不兼容而无法在一起工作的类协同工作，做法是将类自己的接口包裹在一个已存在的类中。
+      Http请求处理器适配器 HttpRequestHandlerAdapter
+      简单控制器处理器适配器 SimpleControllerHandlerAdapter
+      注解方法处理器适配器 AnnotationMethodHandlerAdapter
+    6. 初始化 **HandlerExceptionResolvers**
+      基于HandlerExceptionResolver接口的异常处理，使用这种方式只需要实现resolveException方法，该方法返回一个ModelandView对象，在方法内部对异常的类型进行判断，
+    7. 初始化 **RequestToViewNameTranslator**
+      当Controller处理器方法没有返回一个View对象或逻辑视图名称，并且在该方法中没有直接往response的输出流里面写数据的时候，Spring就会采用约定好的方式提供一个逻辑视图名称。
+    8. 初始化 **ViewResolvers**
+      在SpringMVC中，当Controller将请求处理结果放入到ModelAndView中以后，DispatcherServlet会根据ModelAndView选择合适的视图进行渲染。
+    9. 初始化 **FlashMapManager**
+      SpringMVCFlash attributes提供了一个请求存储属性，可供其他请求使用，例如Post/Redirect/Get模式
+      Flash attributes在重定向之前暂存（就像存在session中）以便重定向之后还能使用，并立即删除。
+
+
+## 11.4 DispatcherServlet的逻辑处理
+  processRequest(request,response)
+　　11.4.1 MultipartContent类型的request处理
+　　11.4.2 根据request信息寻找对应的Handler
+　　11.4.3 没找到对应的Handler的错误处理
+　　11.4.4 根据当前Handler寻找对应的HandlerAdapter
+　　11.4.5 缓存处理
+　　11.4.6 HandlerInterceptor的处理
+　　11.4.7 逻辑处理
+　　11.4.8 异常视图的处理
+　　11.4.9 根据视图跳转页面
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25412\347\253\240 \350\277\234\347\250\213\346\234\215\345\212\241.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25412\347\253\240 \350\277\234\347\250\213\346\234\215\345\212\241.md"
similarity index 97%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25412\347\253\240 \350\277\234\347\250\213\346\234\215\345\212\241.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25412\347\253\240 \350\277\234\347\250\213\346\234\215\345\212\241.md"
index f1065af0..9a24409b 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25412\347\253\240 \350\277\234\347\250\213\346\234\215\345\212\241.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25412\347\253\240 \350\277\234\347\250\213\346\234\215\345\212\241.md"	
@@ -1,61 +1,61 @@
-Java远程方法调用，即Java RMI(Java Remote Method Invocation),是Java编程语言里一种用于 **实现远程过程调用的应用程序编程接口**。
-它使 **客户机上运行的程序** 可以 **调用远程服务器上的对象**。远程方法调用特性使Java编程人员能够在 **网络环境中分布操作**。
-RMI的全部宗旨就是 **尽可能地简化远程接口对象的使用**。
-## 12.1 RMI
-### 12.1.1 使用示例
-Spring整合RMI的使用示例
-1. 建立RMI对外接口
-2. 建立接口实现类
-3. 建立服务端配置文件
-4. 建立服务端测试
-5. 完成了服务端的配置后，还需要在测试端建立测试环境以及测试代码。
-  5.1 首先建立测试端配置文件
-6. 编写测试代码
-
-### 12.1.2 服务端实现
-  **org.Springframework.remoting.RMI.RMIServiceExporter**
-  发布流程：
-  1 验证service
-  2 处理用户自动以的SocketFactory属性
-  3 根据配置参数获取Registry
-  4 构造对外发布的实例
-  5 发布实例
-  1. 获取registry
-  2. 初始化将要导出的实体对象
-  3. RMI服务激活调用
-
-### 12.1.3 客户端实现
-  **org.Springframework.remoting.RMI.RMIProxyFactoryBean**
-
-  1. 通过代理拦截并获取stub
-  2. 增强器进行远程连接
-
-## 12.2 HttpInvoker
-  RMI服务和基于HTTP的服务（Hessian\Burlap）之间空白，
-    RMI使用Java标准的对象序列化，但很难穿越防火墙，
-    Hessian\Burlap能很好地穿过防火墙工作，但使用自己私有的一套对象序列化机制。
-  Spring 的HttpInvoker应运而生。
-    是一个新的远程调用模型，作为Spring框架的一部分，来执行基于HTTP的远程调用*（让防火墙高兴的事），并使用Java的序列化机制（让程序员高效的事）
-### 12.2.1 使用示例
-  1. 创建对外接口
-  2. 创建接口实现类
-  3. 创建服务端配置文件 applicationContext-server.xml
-  4. 在WEB-INF下创建remote-servlet.xml
-  5. 创建测试端配置client.xml
-  6. 创建测试类
-
-### 12.2.2 服务端实现
-  **org.Springframework.remoting.httpinvoker.HttpInvokerServiceExporter**
-  1. 创建代理
-  2. 处理来自客户端的Request
-  2.1 从request中读取序列化对象
-  2.2 执行调用
-  2.3 将结果的序列化对象写入输出流
-### 12.2.3 客户端实现
-  **org.Springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean**
-  1. 创建HttpPost
-  2. 设置RequestBody
-  3. 执行远程方法
-  4. 远程相应验证
-  5. 提取响应信息
-  6. 提取返回结果
+Java远程方法调用，即Java RMI(Java Remote Method Invocation),是Java编程语言里一种用于 **实现远程过程调用的应用程序编程接口**。
+它使 **客户机上运行的程序** 可以 **调用远程服务器上的对象**。远程方法调用特性使Java编程人员能够在 **网络环境中分布操作**。
+RMI的全部宗旨就是 **尽可能地简化远程接口对象的使用**。
+## 12.1 RMI
+### 12.1.1 使用示例
+Spring整合RMI的使用示例
+1. 建立RMI对外接口
+2. 建立接口实现类
+3. 建立服务端配置文件
+4. 建立服务端测试
+5. 完成了服务端的配置后，还需要在测试端建立测试环境以及测试代码。
+  5.1 首先建立测试端配置文件
+6. 编写测试代码
+
+### 12.1.2 服务端实现
+  **org.Springframework.remoting.RMI.RMIServiceExporter**
+  发布流程：
+  1 验证service
+  2 处理用户自动以的SocketFactory属性
+  3 根据配置参数获取Registry
+  4 构造对外发布的实例
+  5 发布实例
+  1. 获取registry
+  2. 初始化将要导出的实体对象
+  3. RMI服务激活调用
+
+### 12.1.3 客户端实现
+  **org.Springframework.remoting.RMI.RMIProxyFactoryBean**
+
+  1. 通过代理拦截并获取stub
+  2. 增强器进行远程连接
+
+## 12.2 HttpInvoker
+  RMI服务和基于HTTP的服务（Hessian\Burlap）之间空白，
+    RMI使用Java标准的对象序列化，但很难穿越防火墙，
+    Hessian\Burlap能很好地穿过防火墙工作，但使用自己私有的一套对象序列化机制。
+  Spring 的HttpInvoker应运而生。
+    是一个新的远程调用模型，作为Spring框架的一部分，来执行基于HTTP的远程调用*（让防火墙高兴的事），并使用Java的序列化机制（让程序员高效的事）
+### 12.2.1 使用示例
+  1. 创建对外接口
+  2. 创建接口实现类
+  3. 创建服务端配置文件 applicationContext-server.xml
+  4. 在WEB-INF下创建remote-servlet.xml
+  5. 创建测试端配置client.xml
+  6. 创建测试类
+
+### 12.2.2 服务端实现
+  **org.Springframework.remoting.httpinvoker.HttpInvokerServiceExporter**
+  1. 创建代理
+  2. 处理来自客户端的Request
+  2.1 从request中读取序列化对象
+  2.2 执行调用
+  2.3 将结果的序列化对象写入输出流
+### 12.2.3 客户端实现
+  **org.Springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean**
+  1. 创建HttpPost
+  2. 设置RequestBody
+  3. 执行远程方法
+  4. 远程相应验证
+  5. 提取响应信息
+  6. 提取返回结果
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25413\347\253\240 Spring\346\266\210\346\201\257.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25413\347\253\240 Spring\346\266\210\346\201\257.md"
similarity index 97%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25413\347\253\240 Spring\346\266\210\346\201\257.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25413\347\253\240 Spring\346\266\210\346\201\257.md"
index 9d9e55d4..86b3b93b 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25413\347\253\240 Spring\346\266\210\346\201\257.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\25413\347\253\240 Spring\346\266\210\346\201\257.md"	
@@ -1,93 +1,93 @@
-Java消息服务（Java Message Service， JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API。
-
-用于两个应用程序之间或分布式系统中发送消息、进行异步通信。
-
-Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
-
-Java消息服务的规范包括两种消息模式，点对点和发布者/订阅者。
-
-Java消息服务支持同步和异步的消息处理
-
-Java消息服务支持面向事件的方法接收消息，事件驱动的程序设计现在被广泛认为是一种富有成效的程序设计范例。
-
-## 13.1 JMS的独立使用
-1. 发送端实现
-  发送
-2. 接收端实现
-  接收
-
-## 13.2 Spring整合ActiveMQ
-1. Spring配置文件
-  Spring整合消息服务的使用从配置文件配置开始。
-  类似于数据库操作，Spring也将ActiveMQ中的操作统一封装至jmsTemplate中，以便我们统一使用。
-  ActiveMQConnectionFactory用于连接消息服务器，是消息服务的基础，也要注册
-  ActiveMQQueue用于指定消息的目的地
-
-```xml
-    <!-- 第三方MQ工厂: ConnectionFactory -->
-    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
-    <!-- ActiveMQ Address -->
-        <property name="brokerURL" value="${activemq.brokerURL}" />
-        <property name="userName" value="${activemq.userName}"></property>
-        <property name="password" value="${activemq.password}"></property>
-    </bean>
-    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
-    <!-- 队列模板 -->
-    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
-        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
-        <property name="connectionFactory" ref="connectionFactory"/>  
-        <property name="defaultDestinationName" value="${activemq.queueName}"></property>
-    </bean>
-    <!--这个是目的地:destination -->
-    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
-    <constructor-arg>
-    <value>${activemq.queueName}</value>
-    </constructor-arg>
-    </bean>
-```
-2. 发送端
-  Spring可以根据配置信息简化我们的工作量。
-  Spring使用发送消息到消息服务器，省去了冗余的Connection以及Session等的创建与销毁过程，简化了工作量。
-  ``` java
-  jmsTemplate.send(destination,new MessageCreator(){
-      public Message createMessage(Session session) throws JMSException{
-        return session.createTextMessage("ceshi");
-      }
-  });
-  ```
-3. 接收端
-  ``` java
-  TextMessage msg = (TextMessage)jmsTemplate.receive(destination);
-  System.out.println(msg.getText());
-  ```
-以上的操作
-jmsTemplate.receive(destination)方法只能接收一次消息，如果未接收到消息，则会一直等待，可设置timeout超时，但是一旦接收到消息本次接收任务就会结束。
-可通过while(true)来实现循环监听消息服务器的消息。
-更好的方法创建消息监听器
-**消息监听器使用方式如下：**
-1. 创建消息监听器
-  一旦有新消息Spring会将消息引导至消息监听器以便用户进行相应的逻辑处理
-  MessageListener
-  实现OnMessage()方法
-  OnMessage(Message arg0)
-2. 修改配置文件
-  使用消息监听器，需要在配置文件中注册消息容器，并将消息监听器注入到容器中
-``` xml
-    <!-- 配置自定义监听：MessageListener -->
-    <bean id="textMessageListener" class="com.xxx.mq.MessageListener"></bean>
-    <!-- 将连接工厂、目标对了、自定义监听注入jms模板 -->
-    <bean id="sessionAwareListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
-        <property name="connectionFactory" ref="connectionFactory" />
-        <property name="destination" ref="destination" />
-        <property name="messageListener" ref="textMessageListener" />
-    </bean>
-```
-通过以上的修改便可以进行消息监听的功能了，一旦有消息传入消息服务器，则会被消息监听器坚挺到，并有Spring将消息内容引导至消息监听器的处理函数中等待用户进一步逻辑处理。
-
-## 13.3 源码分析
-### 13.3.1 JmsTemplate
-  1. 通用代码抽取
-  2. 发送消息的实现
-  3. 接收消息
-### 13.3.2 监听器容器
-  
+Java消息服务（Java Message Service， JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API。
+
+用于两个应用程序之间或分布式系统中发送消息、进行异步通信。
+
+Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
+
+Java消息服务的规范包括两种消息模式，点对点和发布者/订阅者。
+
+Java消息服务支持同步和异步的消息处理
+
+Java消息服务支持面向事件的方法接收消息，事件驱动的程序设计现在被广泛认为是一种富有成效的程序设计范例。
+
+## 13.1 JMS的独立使用
+1. 发送端实现
+  发送
+2. 接收端实现
+  接收
+
+## 13.2 Spring整合ActiveMQ
+1. Spring配置文件
+  Spring整合消息服务的使用从配置文件配置开始。
+  类似于数据库操作，Spring也将ActiveMQ中的操作统一封装至jmsTemplate中，以便我们统一使用。
+  ActiveMQConnectionFactory用于连接消息服务器，是消息服务的基础，也要注册
+  ActiveMQQueue用于指定消息的目的地
+
+```xml
+    <!-- 第三方MQ工厂: ConnectionFactory -->
+    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
+    <!-- ActiveMQ Address -->
+        <property name="brokerURL" value="${activemq.brokerURL}" />
+        <property name="userName" value="${activemq.userName}"></property>
+        <property name="password" value="${activemq.password}"></property>
+    </bean>
+    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
+    <!-- 队列模板 -->
+    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
+        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
+        <property name="connectionFactory" ref="connectionFactory"/>  
+        <property name="defaultDestinationName" value="${activemq.queueName}"></property>
+    </bean>
+    <!--这个是目的地:destination -->
+    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
+    <constructor-arg>
+    <value>${activemq.queueName}</value>
+    </constructor-arg>
+    </bean>
+```
+2. 发送端
+  Spring可以根据配置信息简化我们的工作量。
+  Spring使用发送消息到消息服务器，省去了冗余的Connection以及Session等的创建与销毁过程，简化了工作量。
+  ``` java
+  jmsTemplate.send(destination,new MessageCreator(){
+      public Message createMessage(Session session) throws JMSException{
+        return session.createTextMessage("ceshi");
+      }
+  });
+  ```
+3. 接收端
+  ``` java
+  TextMessage msg = (TextMessage)jmsTemplate.receive(destination);
+  System.out.println(msg.getText());
+  ```
+以上的操作
+jmsTemplate.receive(destination)方法只能接收一次消息，如果未接收到消息，则会一直等待，可设置timeout超时，但是一旦接收到消息本次接收任务就会结束。
+可通过while(true)来实现循环监听消息服务器的消息。
+更好的方法创建消息监听器
+**消息监听器使用方式如下：**
+1. 创建消息监听器
+  一旦有新消息Spring会将消息引导至消息监听器以便用户进行相应的逻辑处理
+  MessageListener
+  实现OnMessage()方法
+  OnMessage(Message arg0)
+2. 修改配置文件
+  使用消息监听器，需要在配置文件中注册消息容器，并将消息监听器注入到容器中
+``` xml
+    <!-- 配置自定义监听：MessageListener -->
+    <bean id="textMessageListener" class="com.xxx.mq.MessageListener"></bean>
+    <!-- 将连接工厂、目标对了、自定义监听注入jms模板 -->
+    <bean id="sessionAwareListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
+        <property name="connectionFactory" ref="connectionFactory" />
+        <property name="destination" ref="destination" />
+        <property name="messageListener" ref="textMessageListener" />
+    </bean>
+```
+通过以上的修改便可以进行消息监听的功能了，一旦有消息传入消息服务器，则会被消息监听器坚挺到，并有Spring将消息内容引导至消息监听器的处理函数中等待用户进一步逻辑处理。
+
+## 13.3 源码分析
+### 13.3.1 JmsTemplate
+  1. 通用代码抽取
+  2. 发送消息的实现
+  3. 接收消息
+### 13.3.2 监听器容器
+  
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2542\347\253\240 \345\256\271\345\231\250\347\232\204\345\237\272\346\234\254\345\256\236\347\216\260.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2542\347\253\240 \345\256\271\345\231\250\347\232\204\345\237\272\346\234\254\345\256\236\347\216\260.md"
similarity index 96%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2542\347\253\240 \345\256\271\345\231\250\347\232\204\345\237\272\346\234\254\345\256\236\347\216\260.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2542\347\253\240 \345\256\271\345\231\250\347\232\204\345\237\272\346\234\254\345\256\236\347\216\260.md"
index e7d34411..b32a7814 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2542\347\253\240 \345\256\271\345\231\250\347\232\204\345\237\272\346\234\254\345\256\236\347\216\260.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2542\347\253\240 \345\256\271\345\231\250\347\232\204\345\237\272\346\234\254\345\256\236\347\216\260.md"	
@@ -1,60 +1,60 @@
-## 2.4 Spring结构组成
-
-### 2.4.1 核心类介绍
-
-package org.springframework.beans.factory.support;
-**DefaultListableBeanFactory**
-
-package org.springframework.beans.factory.xml;
-**XmlBeanDefinitionReader**
-
-## 2.5 容器的基础 XmlBeanFactory
-
-### 2.5.1 配置文件封装
-  Spring的配置文件读取是通过 ClassPathResource 进行封装的，入 new ClassPathResource("XXX.xml")。
-  ClassPathResource完成了什么功能？
-
-  Spring对其内部使用到的资源实现了自己的抽象结构：Resource接口来封装底层资源
-  package org.springframework.core.io;
-  ``` java
-  public interface Resource extends InputStreamSource {
-      boolean exists();
-      default boolean isReadable() {
-		      return true;
-	    }
-      default boolean isOpen() {
-		      return false;
-	    }
-      default boolean isFile() {
-          return false;
-      }
-	    URL getURL() throws IOException;
-      URI getURI() throws IOException;
-      File getFile() throws IOException;
-      default ReadableByteChannel readableChannel() throws IOException {
-		      return Channels.newChannel(getInputStream());
-	    }
-      long contentLength() throws IOException;
-      long lastModified() throws IOException;
-      Resource createRelative(String relativePath) throws IOException;
-      @Nullable
-	    String getFilename();
-      String getDescription();
-  }
-  ```
-  对不同来源的资源文件都有相应的Resource实现：
-  文件 FileSystemResource Classpath资源 ClassPathResource URL资源 URLResource InputStream资源 InputStreamResource
-  Byte数组 ByteArrayResource等。
-
-### 2.5.2 加载Bean
-
-## 2.6 获取XML的验证模式
-### 2.6.1 DTD与XSD的区别
-### 2.6.2 验证模式的读取
-
-## 2.7 获取Document
-### 2.7.1 EntityResolve用法
-
-## 2.8 解析及注册BeanDefinition
-### 2.8.1 profile属性的使用
-### 2.8.2 解析并注册BeanDefinition
+## 2.4 Spring结构组成
+
+### 2.4.1 核心类介绍
+
+package org.springframework.beans.factory.support;
+**DefaultListableBeanFactory**
+
+package org.springframework.beans.factory.xml;
+**XmlBeanDefinitionReader**
+
+## 2.5 容器的基础 XmlBeanFactory
+
+### 2.5.1 配置文件封装
+  Spring的配置文件读取是通过 ClassPathResource 进行封装的，入 new ClassPathResource("XXX.xml")。
+  ClassPathResource完成了什么功能？
+
+  Spring对其内部使用到的资源实现了自己的抽象结构：Resource接口来封装底层资源
+  package org.springframework.core.io;
+  ``` java
+  public interface Resource extends InputStreamSource {
+      boolean exists();
+      default boolean isReadable() {
+		      return true;
+	    }
+      default boolean isOpen() {
+		      return false;
+	    }
+      default boolean isFile() {
+          return false;
+      }
+	    URL getURL() throws IOException;
+      URI getURI() throws IOException;
+      File getFile() throws IOException;
+      default ReadableByteChannel readableChannel() throws IOException {
+		      return Channels.newChannel(getInputStream());
+	    }
+      long contentLength() throws IOException;
+      long lastModified() throws IOException;
+      Resource createRelative(String relativePath) throws IOException;
+      @Nullable
+	    String getFilename();
+      String getDescription();
+  }
+  ```
+  对不同来源的资源文件都有相应的Resource实现：
+  文件 FileSystemResource Classpath资源 ClassPathResource URL资源 URLResource InputStream资源 InputStreamResource
+  Byte数组 ByteArrayResource等。
+
+### 2.5.2 加载Bean
+
+## 2.6 获取XML的验证模式
+### 2.6.1 DTD与XSD的区别
+### 2.6.2 验证模式的读取
+
+## 2.7 获取Document
+### 2.7.1 EntityResolve用法
+
+## 2.8 解析及注册BeanDefinition
+### 2.8.1 profile属性的使用
+### 2.8.2 解析并注册BeanDefinition
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2543\347\253\240 \351\273\230\350\256\244\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2543\347\253\240 \351\273\230\350\256\244\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"
similarity index 95%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2543\347\253\240 \351\273\230\350\256\244\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2543\347\253\240 \351\273\230\350\256\244\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"
index 1aa8d210..068e7d21 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2543\347\253\240 \351\273\230\350\256\244\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2543\347\253\240 \351\273\230\350\256\244\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"	
@@ -1,35 +1,35 @@
-## 3.1 **bean标签的解析及注册**
-
-### 3.1.1 解析BeanDefinition
-
-1. 创建用于属性承载的BeanDefinition
-
-2. 解析各种属性
-
-3. 解析子元素meta
-
-4. 解析子元素lookup-method
-
-5. 解析子元素replace-method
-
-6. 解析子元素constructor-arg
-
-7. 解析子元素property
-
-### 3.1.2 AbstractBeanDefinition属性
-
-### 3.1.3 解析默认标签中的自定义标签元素
-
-### 3.1.4 注册解析的BeanDefinition
-
-1. 通过beanName 注册 BeanDefinition
-
-2. 通过别名注册 BeanDefinition
-
-### 3.1.5 通知监听器解析及注册完成
-
-## 3.2 **alias标签的解析**
-
-## 3.3 **import标签的解析**
-
-## 3.4 **嵌入式beans标签的解析**
+## 3.1 **bean标签的解析及注册**
+
+### 3.1.1 解析BeanDefinition
+
+1. 创建用于属性承载的BeanDefinition
+
+2. 解析各种属性
+
+3. 解析子元素meta
+
+4. 解析子元素lookup-method
+
+5. 解析子元素replace-method
+
+6. 解析子元素constructor-arg
+
+7. 解析子元素property
+
+### 3.1.2 AbstractBeanDefinition属性
+
+### 3.1.3 解析默认标签中的自定义标签元素
+
+### 3.1.4 注册解析的BeanDefinition
+
+1. 通过beanName 注册 BeanDefinition
+
+2. 通过别名注册 BeanDefinition
+
+### 3.1.5 通知监听器解析及注册完成
+
+## 3.2 **alias标签的解析**
+
+## 3.3 **import标签的解析**
+
+## 3.4 **嵌入式beans标签的解析**
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2544\347\253\240 \350\207\252\345\256\232\344\271\211\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2544\347\253\240 \350\207\252\345\256\232\344\271\211\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"
similarity index 95%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2544\347\253\240 \350\207\252\345\256\232\344\271\211\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2544\347\253\240 \350\207\252\345\256\232\344\271\211\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"
index eee1be37..12cec71f 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2544\347\253\240 \350\207\252\345\256\232\344\271\211\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2544\347\253\240 \350\207\252\345\256\232\344\271\211\346\240\207\347\255\276\347\232\204\350\247\243\346\236\220.md"	
@@ -1,7 +1,7 @@
-## 4.1 自定义标签使用
-
-## 4.2 自定义标签解析
-
-### 4.2.1 获取标签的命名空间
-### 4.2.2 提取自定义标签处理器
-### 4.2.3 标签解析
+## 4.1 自定义标签使用
+
+## 4.2 自定义标签解析
+
+### 4.2.1 获取标签的命名空间
+### 4.2.2 提取自定义标签处理器
+### 4.2.3 标签解析
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2546\347\253\240 \345\256\271\345\231\250\347\232\204\345\212\237\350\203\275\346\211\251\345\261\225.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2545\347\253\240 bean\347\232\204\345\212\240\350\275\275.md"
similarity index 100%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2546\347\253\240 \345\256\271\345\231\250\347\232\204\345\212\237\350\203\275\346\211\251\345\261\225.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2545\347\253\240 bean\347\232\204\345\212\240\350\275\275.md"
diff --git "a/12 - Practice (problems encountered during development)/spring \345\234\250Thread\344\270\255\346\263\250\345\205\245@Resource@Autowired\345\244\261\350\264\245\357\274\214\346\200\273\344\270\272null~\350\247\243\345\206\263.txt" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2546\347\253\240 \345\256\271\345\231\250\347\232\204\345\212\237\350\203\275\346\211\251\345\261\225.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/spring \345\234\250Thread\344\270\255\346\263\250\345\205\245@Resource@Autowired\345\244\261\350\264\245\357\274\214\346\200\273\344\270\272null~\350\247\243\345\206\263.txt"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2546\347\253\240 \345\256\271\345\231\250\347\232\204\345\212\237\350\203\275\346\211\251\345\261\225.md"
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2547\347\253\240 AOP.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2547\347\253\240 AOP.md"
similarity index 96%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2547\347\253\240 AOP.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2547\347\253\240 AOP.md"
index e45f520c..ba18323f 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2547\347\253\240 AOP.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2547\347\253\240 AOP.md"	
@@ -1,13 +1,13 @@
-
-## 7.1 动态AOP使用示例
-## 7.2 动态AOP自定义标签
-　　7.2.1 注册Annotation Aware Aspect JAuto Proxy Creator
-## 7.3 创建AOP代理
-　　7.3.1 获取增强器
-　　7.3.2 寻找匹配的增强器
-　　7.3.3 创建代理
-## 7.4 静态AOP使用示例
-## 7.5 创建AOP静态代理
-　　7.5.1 Instrumentation使用
-　　7.5.2 自定义标签
-　　7.5.3 织入
+
+## 7.1 动态AOP使用示例
+## 7.2 动态AOP自定义标签
+　　7.2.1 注册Annotation Aware Aspect JAuto Proxy Creator
+## 7.3 创建AOP代理
+　　7.3.1 获取增强器
+　　7.3.2 寻找匹配的增强器
+　　7.3.3 创建代理
+## 7.4 静态AOP使用示例
+## 7.5 创建AOP静态代理
+　　7.5.1 Instrumentation使用
+　　7.5.2 自定义标签
+　　7.5.3 织入
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2548\347\253\240 \346\225\260\346\215\256\345\272\223\350\277\236\346\216\245JDBC.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2548\347\253\240 \346\225\260\346\215\256\345\272\223\350\277\236\346\216\245JDBC.md"
similarity index 97%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2548\347\253\240 \346\225\260\346\215\256\345\272\223\350\277\236\346\216\245JDBC.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2548\347\253\240 \346\225\260\346\215\256\345\272\223\350\277\236\346\216\245JDBC.md"
index c602ca11..c350e291 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2548\347\253\240 \346\225\260\346\215\256\345\272\223\350\277\236\346\216\245JDBC.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2548\347\253\240 \346\225\260\346\215\256\345\272\223\350\277\236\346\216\245JDBC.md"	
@@ -1,42 +1,42 @@
-JDBC(Java Data Base Connectivity，Java数据库连接)是一种执行Sql语句的JavaAPI，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。
-JDBC连接数据库的流程及其原理如下：
-1 在开发环境中加载指定数据库的驱动程序
-2 在Java程序中加载驱动程序
-3 创建数据连接对象
-4 创建Statement对象
-5 调用Statement对象的相关方法执行相对应的SQL语句
-6 关闭数据库连接
-
-## 8.1 Spring连接数据库程序实现（JDBC）
-  1 创建数据表结构
-  2 创建对应数据表的PO
-  3 创建表与实体间的映射
-  4 创建数据操作接口
-  5 创建数据操作接口实现类
-    **JDBCTemplate**
-  6 创建Spring配置文件
-    配置数据源
-    ``` xml
-    <beans id="dataSource" class="">
-    </beans>
-    ```
-  7 测试
-## 8.2 save/update功能的实现
-    DataSource是整个数据库操作的基础，里面封装了整个数据库的连接信息。
-    execute方法是最基础的操作，而其他操作如update、query等方法则是传入不用的PreparedStatementCallback参数来执行不同的逻辑。
-### 8.2.1 基础方法execute
-  **execute** 作为数据库操作的核心入口，将大多数数据库操作相同的步骤统一封装，而将个性化的操作使用参数 **PreparedStatementCallback** 进行回调
-  1. 获取数据库连接
-  2. 应用用户设定的输入参数
-  3. 调用回调函数
-  4. 警告处理
-  5. 资源释放
-### 8.2.2 Update中的回调函数
-  PreparedStatementCallback 作为一个接口，其中只有一个函数doInPreparedStatement,这个函数是用于调用通用方法execute的时候无法处理的一些个性化处理方法
-  pss.setValues(ps)
-
-## 8.3 query功能的实现
-  回调类PreparedStatementCallback的实现中使用ps.executeQuery()执行查询操作，
-  rse.extractData(rsToUse)方法负责将结果进行封装并转换至POJO
-## 8.4 queryForObject
-  
+JDBC(Java Data Base Connectivity，Java数据库连接)是一种执行Sql语句的JavaAPI，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。
+JDBC连接数据库的流程及其原理如下：
+1 在开发环境中加载指定数据库的驱动程序
+2 在Java程序中加载驱动程序
+3 创建数据连接对象
+4 创建Statement对象
+5 调用Statement对象的相关方法执行相对应的SQL语句
+6 关闭数据库连接
+
+## 8.1 Spring连接数据库程序实现（JDBC）
+  1 创建数据表结构
+  2 创建对应数据表的PO
+  3 创建表与实体间的映射
+  4 创建数据操作接口
+  5 创建数据操作接口实现类
+    **JDBCTemplate**
+  6 创建Spring配置文件
+    配置数据源
+    ``` xml
+    <beans id="dataSource" class="">
+    </beans>
+    ```
+  7 测试
+## 8.2 save/update功能的实现
+    DataSource是整个数据库操作的基础，里面封装了整个数据库的连接信息。
+    execute方法是最基础的操作，而其他操作如update、query等方法则是传入不用的PreparedStatementCallback参数来执行不同的逻辑。
+### 8.2.1 基础方法execute
+  **execute** 作为数据库操作的核心入口，将大多数数据库操作相同的步骤统一封装，而将个性化的操作使用参数 **PreparedStatementCallback** 进行回调
+  1. 获取数据库连接
+  2. 应用用户设定的输入参数
+  3. 调用回调函数
+  4. 警告处理
+  5. 资源释放
+### 8.2.2 Update中的回调函数
+  PreparedStatementCallback 作为一个接口，其中只有一个函数doInPreparedStatement,这个函数是用于调用通用方法execute的时候无法处理的一些个性化处理方法
+  pss.setValues(ps)
+
+## 8.3 query功能的实现
+  回调类PreparedStatementCallback的实现中使用ps.executeQuery()执行查询操作，
+  rse.extractData(rsToUse)方法负责将结果进行封装并转换至POJO
+## 8.4 queryForObject
+  
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2549\347\253\240 \346\225\264\345\220\210MyBatis.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2549\347\253\240 \346\225\264\345\220\210MyBatis.md"
similarity index 97%
rename from "10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2549\347\253\240 \346\225\264\345\220\210MyBatis.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2549\347\253\240 \346\225\264\345\220\210MyBatis.md"
index f7f2cbd9..77eceb3e 100644
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2549\347\253\240 \346\225\264\345\220\210MyBatis.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/\347\254\2549\347\253\240 \346\225\264\345\220\210MyBatis.md"	
@@ -1,33 +1,33 @@
-## 9.1 MyBatis独立使用
-  1. 建立PO
-  2. 建立Mapper
-  3. 建立配置文件
-  4. 建立映射文件
-  5. 建立测试类
-## 9.2 Spring整合MyBatis
-  1. Spring配置文件
-  2. MyBatis配置文件
-  3. 映射文件
-  4. 测试
-## 9.3 源码分析
-### 9.3.1 sqlSessionFactory创建
-  实现了 FactoryBean 和 InitializingBean
-  FactoryBean：一旦某个bean实现此接口，name通过getBean方法获取bean时其实是获取此类的getObject()返回的实例。
-  InitializingBean：实现此接口的bean会在初始化时调用 afterPropertiesSet 方法来进行bean的逻辑初始化。
-  1 SqlSessionFactoryBean初始化
-  2 获取SqlSessionFactoryBean 实例
-### 9.3.2 MapperFactoryBean 的创建
-
-  1 MapperFactoryBean 初始化
-  2 获取 MapperFactoryBean 实例
-### 9.3.3 MapperScannerConfigurer
-  使用MapperScannerConfigurer，让它扫描特定的包，自动帮我们成批地创建映射器。
-  ``` xml
-  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
-      <property name="basePackage" value="com.xxx.xxx.dao" />
-      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
-  </bean>
-  ```
-  1. processPropertyPlaceHolders 属性的处理
-  2. 根据配置属性生成过滤器
-  3. 扫描Java文件
+## 9.1 MyBatis独立使用
+  1. 建立PO
+  2. 建立Mapper
+  3. 建立配置文件
+  4. 建立映射文件
+  5. 建立测试类
+## 9.2 Spring整合MyBatis
+  1. Spring配置文件
+  2. MyBatis配置文件
+  3. 映射文件
+  4. 测试
+## 9.3 源码分析
+### 9.3.1 sqlSessionFactory创建
+  实现了 FactoryBean 和 InitializingBean
+  FactoryBean：一旦某个bean实现此接口，name通过getBean方法获取bean时其实是获取此类的getObject()返回的实例。
+  InitializingBean：实现此接口的bean会在初始化时调用 afterPropertiesSet 方法来进行bean的逻辑初始化。
+  1 SqlSessionFactoryBean初始化
+  2 获取SqlSessionFactoryBean 实例
+### 9.3.2 MapperFactoryBean 的创建
+
+  1 MapperFactoryBean 初始化
+  2 获取 MapperFactoryBean 实例
+### 9.3.3 MapperScannerConfigurer
+  使用MapperScannerConfigurer，让它扫描特定的包，自动帮我们成批地创建映射器。
+  ``` xml
+  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
+      <property name="basePackage" value="com.xxx.xxx.dao" />
+      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
+  </bean>
+  ```
+  1. processPropertyPlaceHolders 属性的处理
+  2. 根据配置属性生成过滤器
+  3. 扫描Java文件
diff --git a/10 - Reading Notes/book.txt "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/book.txt"
similarity index 54%
rename from 10 - Reading Notes/book.txt
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/book.txt"
index d07083d4..b5780b7f 100644
--- a/10 - Reading Notes/book.txt	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/book.txt"	
@@ -1,37 +1,33 @@
-
-	深入理解计算机系统
-	TCP/IP详解 I II III 
-	数据结构与算法 
-	
-	Java编程思想 
-	大话设计模式
-	重构改善既有代码的设计 
-	Effective Java 
-	深入理解Java虚拟机：JVM高级特性与最佳实践 
-	HotSpot实战 
-	Java并发编程实战 
-	Java多线程编程核心技术 
-	深入分析Java Web技术内幕
-	
-	大型网站系统与Java中间件开发实践 
-	从Paxos到Zookeeper : 分布式一致性原理与实践 
-	MySQL 5.6从零开始学 
-	Spring源码深度解析 
-	spring实战 
-	
-	HTTP权威指南
-	Tomcat权威指南
-	Nginx高性能Web服务器详解
-	Git权威指南
-	Maven实战
-	
-	Holy Bible
-	活法--稻盛和夫
-	给青年诗人的十封信--里尔克
-	人生中不可不想的事--克里希那穆提
-	从0到1开启商业与未来的秘密--彼得·蒂尔 下载：http://oz3b51ys1.bkt.clouddn.com/%E3%80%8A%E4%BB%8E0%E5%88%B01%E5%BC%80%E5%90%AF%E5%95%86%E4%B8%9A%E4%B8%8E%E6%9C%AA%E6%9D%A5%E7%9A%84%E7%A7%98%E5%AF%86%E3%80%8B%E5%AE%8C%E6%95%B4%E7%89%88.pdf?attname=
-	
-	
-	
-	
-	
\ No newline at end of file
+
+	深入理解计算机系统
+	TCP/IP详解 I II III
+	数据结构与算法
+
+	Java编程思想
+	大话设计模式
+	重构改善既有代码的设计
+	Effective Java
+	深入理解Java虚拟机：JVM高级特性与最佳实践
+	HotSpot实战
+	Java并发编程实战
+	Java多线程编程核心技术
+	深入分析Java Web技术内幕
+
+	大型网站系统与Java中间件开发实践
+	从Paxos到Zookeeper : 分布式一致性原理与实践
+	MySQL 5.6从零开始学
+	Spring源码深度解析
+	spring实战
+	Spring Boot 编程思想
+
+	HTTP权威指南
+	Tomcat权威指南
+	Nginx高性能Web服务器详解
+	Git权威指南
+	Maven实战
+
+	Holy Bible
+	活法--稻盛和夫
+	给青年诗人的十封信--里尔克
+	人生中不可不想的事--克里希那穆提
+	从0到1开启商业与未来的秘密--彼得·蒂尔 下载：http://oz3b51ys1.bkt.clouddn.com/%E3%80%8A%E4%BB%8E0%E5%88%B01%E5%BC%80%E5%90%AF%E5%95%86%E4%B8%9A%E4%B8%8E%E6%9C%AA%E6%9D%A5%E7%9A%84%E7%A7%98%E5%AF%86%E3%80%8B%E5%AE%8C%E6%95%B4%E7%89%88.pdf?attname=
diff --git "a/10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/12.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/12.md"
similarity index 100%
rename from "10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/12.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/12.md"
diff --git "a/10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/all.md"
similarity index 100%
rename from "10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/all.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/all.md"
diff --git "a/10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/\347\254\2543\347\253\240 \345\236\203\345\234\276\346\224\266\351\233\206\345\231\250\344\270\216\345\206\205\345\255\230\345\210\206\351\205\215\347\255\226\347\225\245.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/\347\254\2543\347\253\240 \345\236\203\345\234\276\346\224\266\351\233\206\345\231\250\344\270\216\345\206\205\345\255\230\345\210\206\351\205\215\347\255\226\347\225\245.md"
similarity index 99%
rename from "10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/\347\254\2543\347\253\240 \345\236\203\345\234\276\346\224\266\351\233\206\345\231\250\344\270\216\345\206\205\345\255\230\345\210\206\351\205\215\347\255\226\347\225\245.md"
rename to "10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/\347\254\2543\347\253\240 \345\236\203\345\234\276\346\224\266\351\233\206\345\231\250\344\270\216\345\206\205\345\255\230\345\210\206\351\205\215\347\255\226\347\225\245.md"
index 143fb0bf..6b413e0a 100644
--- "a/10 - Reading Notes/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/\347\254\2543\347\253\240 \345\236\203\345\234\276\346\224\266\351\233\206\345\231\250\344\270\216\345\206\205\345\255\230\345\210\206\351\205\215\347\255\226\347\225\245.md"	
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\346\267\261\345\205\245\347\220\206\350\247\243java\350\231\232\346\213\237\346\234\272/\347\254\2543\347\253\240 \345\236\203\345\234\276\346\224\266\351\233\206\345\231\250\344\270\216\345\206\205\345\255\230\345\210\206\351\205\215\347\255\226\347\225\245.md"	
@@ -1,135 +1,135 @@
-
-
-
-## 3.5
-  垃圾收集器是内存回收的具体实现。
-  以下讨论的收集器是基于JDK1.7Update14之后的HotSpot虚拟机。
-  这个虚拟机包含的所有收集器有：
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103037669-1460544075.png)
-  http://blogs.sun.com/jonthecollector/entry/our_collectors
-  Serial    ParNew    Parallel-Scavenge
-
-                                              G1
-
-  CMS       Serial-Old(MSC)    Parallel-Old           
-
-  如果有一种放之四海、任何场景下都适用的完美收集器存在，那HotSpot虚拟机就没必要实现那么多不同的收集器了。
-
-### 3.5.1 Serial 收集器
-  Serial收集器是最基本、发展历史最悠久的收集器，在JDK1.3.1之前是虚拟机新生代收集的唯一选择。
-
-  是 **单线程** 的收集器，进行垃圾收集时，必须 **暂停其他所有的工作线程**，直到它收集结束。用户停顿很长
-
-  运行过程
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103052513-504284596.png)
-    新生代采用 **复制算法** 暂停所有用户线程
-
-  从JDK1.3开始，HotSpot虚拟机开发团队为消除或者减少工作线程因内存回收而导致停顿的努力一直在进行着，从Serial收集器到Parallel收集器，
-  再到Concurrent Mark Sweep（CMS）乃至GC收集器的最前沿成果Garbage First(G1)收集器，用户停顿在不断缩短。
-
-  但是依然是虚拟机运行在Client模式下的默认新生代收集器。
-  优点：简单而高效，对于限定单个CPU的环境来说，Serial 收集器由于没有现成交互的开销，专心做垃圾收集自然获得最高的单线程收集效率。
-
-  在用户桌面应用场景中，分配给虚拟机管理的内存一般来说不会很大，收集几十M甚至一两百M的新生代，停顿时间完全可以控制在几十毫秒最多一百多毫秒以内，只要不频繁发生，这点停顿是可以接受的。
-  所以Serial收集器对于运行在Client模式下的虚拟机来说是一个很好的选择。
-
-### 3.5.2 ParNew 收集器
-  ParNew是Serial的多线程版本。**复制算法**
-  除了使用多条线程进行垃圾收集之外，其余行为包括Serial收集器可用的所有控制参数（例如：-XX：SurvivorRatio、-XX：PretenureSizeThreshold、-XX：HandlePromotionFailure等）、收集算法、Stop The World、对象分配规则、回收策略等都与Serial收集器完全一样，在实现上，这两种收集器也共用了相当多的代码。ParNew收集器的工作过程
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103100129-161732030.png)
-  它却是许多运行在Server模式下的虚拟机中首选的新生代收集器，其中有一个与性能无关但很重要的原因是，除了Serial收集器外，目前只有它 **能与CMS收集器配合工作**。
-
-  ParNew收集器也是使用-XX：+UseConcMarkSweepGC选项后的默认新生代收集器，也可以使用-XX：+UseParNewGC选项来强制指定它。
-
-  ParNew收集器在单CPU的环境中绝对不会有比Serial收集器更好的效果，甚至由于存在线程交互的开销，当然，随着可以使用的CPU的数量的增加，它对于GC时系统资源的有效利用还是很有好处的。它默认开启的收集线程数与CPU的数量相同，在CPU非常多（譬如32个，现在CPU动辄就4核加超线程，服务器超过32个逻辑CPU的情况越来越多了）的环境下，可以使用-XX：ParallelGCThreads参数来限制垃圾收集的线程数。
-
-P
-  并发和并行收集器 概念解释：
-  并行 Parallel：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
-  并发 Concurrent：指用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），用户程序在继续运行，而垃圾收集程序运行于另一个CPU上。
-
-### 3.5.3 Parallel-Scavenge 收集器
-  Parallel-Scavenge是一个新生代收集器，它也是使用 **复制算法** 的收集器,又是并行的 **多线程** 收集器。
-  Parallel Scavenge收集器的特点是它的关注点与其他收集器不同，CMS等收集器的关注点是尽可能地缩短垃圾收集时用户线程的 **停顿时间**，而Parallel Scavenge收集器的目标则是 **达到一个可控制的吞吐量**（Throughput）。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间/（运行用户代码时间+垃圾收集时间），虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，那吞吐量就是99%。
-
-  停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验，而高吞吐量则可以高效率地利用CPU时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。
-
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103109231-712191199.png)
-
-  Parallel Scavenge收集器提供了两个参数用于精确控制吞吐量，分别是控制最大垃圾收集停顿时间的-XX：MaxGCPauseMillis参数以及直接设置吞吐量大小的-XX：GCTimeRatio参数。
-
-  MaxGCPauseMillis参数允许的值是一个大于0的毫秒数，收集器将尽可能地保证内存回收花费的时间不超过设定值。不过大家不要认为如果把这个参数的值设置得稍小一点就能使得系统的垃圾收集速度变得更快，GC停顿时间缩短是以牺牲吞吐量和新生代空间来换取的：系统把新生代调小一些，收集300MB新生代肯定比收集500MB快吧，这也直接导致垃圾收集发生得更频繁一些，原来10秒收集一次、每次停顿100毫秒，现在变成5秒收集一次、每次停顿70毫秒。停顿时间的确在下降，但吞吐量也降下来了。
-
-  GCTimeRatio参数的值应当是一个大于0且小于100的整数，也就是垃圾收集时间占总时间的比率，相当于是吞吐量的倒数。如果把此参数设置为19，那允许的最大GC时间就占总时间的5%（即1/（1+19）），默认值为99，就是允许最大1%（即1/（1+99））的垃圾收集时间。
-
-  由于与吞吐量关系密切，Parallel Scavenge收集器也经常称为“**吞吐量优先**”收集器。除上述两个参数之外，Parallel Scavenge收集器还有一个参数-XX：+UseAdaptiveSizePolicy值得关注。这是一个开关参数，当这个参数打开之后，就不需要手工指定新生代的大小（-Xmn）、Eden与Survivor区的比例（-XX：SurvivorRatio）、晋升老年代对象年龄（-XX：PretenureSizeThreshold）等细节参数了，虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量，这种调节方式称为GC自适应的调节策略（GC Ergonomics）。如果读者对于收集器运作原来不太了解，手工优化存在困难的时候，使用Parallel Scavenge收集器配合自适应调节策略，把内存管理的调优任务交给虚拟机去完成将是一个不错的选择。只需要把基本的内存数据设置好（如-Xmx设置最大堆），然后使用MaxGCPauseMillis参数（更关注最大停顿时间）或GCTimeRatio（更关注吞吐量）参数给虚拟机设立一个优化目标，那具体细节参数的调节工作就由虚拟机完成了。自适应调节策略也是Parallel Scavenge收集器与ParNew收集器的一个重要区别。
-
-### 3.5.4 Serial Old收集器
-  Serial Old是Serial收集器的老年代版本，它同样是一个 **单线程** 收集器，使用“**标记-整理**”算法。
-  这个收集器的主要意义也是在于给Client模式下的虚拟机使用。
-  如果在Server模式下，那么它主要还有两大用途：一种用途是在JDK 1.5以及之前的版本中与Parallel Scavenge收集器搭配使用，另一种用途就是作为CMS收集器的后备预案，在并发收集发生Concurrent Mode Failure时使用。这两点都将在后面的内容中详细讲解。
-
-  Serial Old收集器的工作过程
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103123502-1092886872.png)
-
-### 3.5.5 Parallel Old收集器
-  Parallel Old是Parallel Scavenge收集器的老年代版本，使用 **多线程** 和“**标记-整理**”算法。
-
-  这个收集器是在JDK 1.6中才开始提供的，在此之前，新生代的Parallel Scavenge收集器一直处于比较尴尬的状态。原因是，如果新生代选择了Parallel Scavenge收集器，老年代除了Serial Old（PS MarkSweep）收集器外别无选择，由于老年代Serial Old收集器在服务端应用性能上的“拖累”，使用了Parallel Scavenge收集器也未必能在整体应用上获得吞吐量最大化的效果，由于单线程的老年代收集中无法充分利用服务器多CPU的处理能力，在老年代很大而且硬件比较高级的环境中，这种组合的吞吐量甚至还不一定有ParNew加CMS的组合“给力”。
-
-  直到Parallel Old收集器出现后，“吞吐量优先”收集器终于有了比较 **名副其实的应用组合**，在注重吞吐量以及CPU资源敏感的场合，都可以优先考虑Parallel Scavenge加Parallel Old收集器。
-  Parallel Old收集器的工作过程
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103134120-377437512.png)
-
-### 3.5.6 CMS收集器
-  CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。目前很大一部分的Java应用集中在互联网站或者B/S系统的服务端上，这类应用尤其重视服务的响应速度，希望系统停顿时间最短，以给用户带来较好的体验。CMS收集器就非常符合这类应用的需求。
-
-  从名字（包含“Mark Sweep”）上就可以看出，CMS收集器是基于“**标记—清除**”算法实现的，它的运作过程相对于前面几种收集器来说更复杂一些，整个过程分为4个步骤，包括：
-  1. 初始标记（CMS initial mark）
-  2. 并发标记（CMS concurrent mark）
-  3. 重新标记（CMS remark）
-  4. 并发清除（CMS concurrent sweep）
-
-  其中，**初始标记、重新标记** 这两个步骤仍然需要“Stop The World”。初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快，并发标记阶段就是进行GC RootsTracing的过程，而重新标记阶段则是为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短。
-
-  由于整个过程中耗时最长的 **并发标记和并发清除** 过程收集器线程都可以 **与用户线程一起工作**，所以，从总体上来说，CMS收集器的内存回收过程是与用户线程一起并发执行的。通过图3-10可以比较清楚地看到CMS收集器的运作步骤中并发和需要停顿的时间。
-  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103141677-323497299.png)
-
-  CMS是一款优秀的收集器，它的主要优点在名字上已经体现出来了：并发收集、低停顿，Sun公司的一些官方文档中也称之为并发低停顿收集器（Concurrent Low Pause Collector）。但是CMS还远达不到完美的程度，它有以下3个明显的缺点：
-  1. CMS收集器 **对CPU资源非常敏感** 。其实，面向并发设计的程序都对CPU资源比较敏感。在并发阶段，它虽然不会导致用户线程停顿，但是会因为占用了一部分线程（或者说CPU资源）而导致应用程序变慢，总吞吐量会降低。CMS默认启动的回收线程数是（CPU数量+3）/4，也就是当CPU在4个以上时，并发回收时垃圾收集线程不少于25%的CPU资源，并且随着CPU数量的增加而下降。但是当CPU不足4个（譬如2个）时，CMS对用户程序的影响就可能变得很大，如果本来CPU负载就比较大，还分出一半的运算能力去执行收集器线程，就可能导致用户程序的执行速度忽然降低了50%，其实也让人无法接受。为了应付这种情况，虚拟机提供了一种称为“增量式并发收集器”（Incremental Concurrent Mark Sweep/i-CMS）的CMS收集器变种，所做的事情和单CPU年代PC机操作系统使用抢占式来模拟多任务机制的思想一样，就是在并发标记、清理的时候让GC线程、用户线程交替运行，尽量减少GC线程的独占资源的时间，这样整个垃圾收集的过程会更长，但对用户程序的影响就会显得少一些，也就是速度下降没有那么明显。实践证明，增量时的CMS收集器效果很一般，在目前版本中，i-CMS已经被声明为“deprecated”，即不再提倡用户使用。
-  2. CMS收集器 **无法处理浮动垃圾** （Floating Garbage），可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生。由于CMS并发清理阶段用户线程还在运行着，伴随程序运行自然就还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们，只好留待下一次GC时再清理掉。这一部分垃圾就称为“浮动垃圾”。也是由于在垃圾收集阶段用户线程还需要运行，那也就还需要预留有足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分空间提供并发收集时的程序运作使用。在JDK 1.5的默认设置下，CMS收集器当老年代使用了68%的空间后就会被激活，这是一个偏保守的设置，如果在应用中老年代增长不是太快，可以适当调高参数-XX：CMSInitiatingOccupancyFraction的值来提高触发百分比，以便降低内存回收次数从而获取更好的性能，在JDK 1.6中，CMS收集器的启动阈值已经提升至92%。要是CMS运行期间预留的内存无法满足程序需要，就会出现一次“Concurrent Mode Failure”失败，这时虚拟机将启动后备预案：临时启用Serial Old收集器来重新进行老年代的垃圾收集，这样停顿时间就很长了。所以说参数-XX：CMSInitiatingOccupancyFraction设置得太高很容易导致大量“Concurrent Mode Failure”失败，性能反而降低。
-  3. 还有最后一个缺点，在本节开头说过，CMS是一款基于“标记—清除”算法实现的收集器，如果读者对前面这种算法介绍还有印象的话，就可能想到这意味着收集结束时 **会有大量空间碎片产生**。空间碎片过多时，将会给大对象分配带来很大麻烦，往往会出现老年代还有很大空间剩余，但是无法找到足够大的连续空间来分配当前对象，不得不提前触发一次Full GC。为了解决这个问题，CMS收集器提供了一个-XX：+UseCMSCompactAtFullCollection开关参数（默认就是开启的），用于在CMS收集器顶不住要进行FullGC时开启内存碎片的合并整理过程，内存整理的过程是无法并发的，空间碎片问题没有了，但停顿时间不得不变长。虚拟机设计者还提供了另外一个参数-XX：CMSFullGCsBeforeCompaction，这个参数是用于设置执行多少次不压缩的Full GC后，跟着来一次带压缩的（默认值为0，表示每次进入Full GC时都进行碎片整理）。
-
-### 3.5.7 G1收集器
-
-G1（Garbage-First）收集器是当今收集器技术发展的最前沿成果之一，早在JDK 1.7刚刚确立项目目标，Sun公司给出的JDK 1.7 RoadMap里面，它就被视为JDK 1.7中HotSpot虚拟机的一个重要进化特征。从JDK 6u14中开始就有Early Access版本的G1收集器供开发人员实验、试用，由此开始G1收集器的“Experimental”状态持续了数年时间，直至JDK 7u4，Sun公司才认为它达到足够成熟的商用程度，移除了“Experimental”的标识。
-
-G1是一款面向服务端应用的垃圾收集器。HotSpot开发团队赋予它的使命是（在比较长期的）未来可以替换掉JDK 1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点。
-
-**并行与并发**：G1能充分利用多CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短Stop-The-World停顿的时间，部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让Java程序继续执行。
-
-**分代收集**：与其他收集器一样，分代概念在G1中依然得以保留。虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但它能够采用不同的方式去处理新创建的对象和已经存活了一段时间、熬过多次GC的旧对象以获取更好的收集效果。
-
-**空间整合**：与CMS的“标记—清理”算法不同，G1从整体来看是基于“标记—整理”算法实现的收集器，从局部（两个Region之间）上来看是基于“复制”算法实现的，但无论如何，这两种算法都意味着G1运作期间不会产生内存空间碎片，收集后能提供规整的可用内存。这种特性有利于程序长时间运行，分配大对象时不会因为无法找到连续内存空间而提前触发下一次GC。
-
-**可预测的停顿**：这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒，这几乎已经是实时Java（RTSJ）的垃圾收集器的特征了。
-
-在G1之前的其他收集器进行收集的范围都是整个新生代或者老年代，而G1不再是这样。使用G1收集器时，Java堆的内存布局就与其他收集器有很大差别，它将整个Java堆划分为 **多个大小相等的独立区域（Region）**，虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。
-
-G1收集器之所以能建立可预测的停顿时间模型，是因为它可以有计划地避免在整个Java堆中进行全区域的垃圾收集。G1跟踪各个Region里面的垃圾堆积的价值大小（回收所获得的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据允许的收集时间，**优先回收价值最大Region**（这也就是Garbage-First名称的来由）。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了G1收集器在 **有限的时间内可以获取尽可能高的收集效率**。
-
-G1把内存“化整为零”的思路，理解起来似乎很容易，但其中的实现细节却远远没有想象中那样简单，否则也不会从2004年Sun实验室发表第一篇G1的论文开始直到今天（将近10年时间）才开发出G1的商用版。笔者以一个细节为例：把Java堆分为多个Region后，垃圾收集是否就真的能以Region为单位进行了？听起来顺理成章，再仔细想想就很容易发现问题所在：**Region不可能是孤立的。一个对象分配在某个Region中，它并非只能被本Region中的其他对象引用，而是可以与整个Java堆任意的对象发生引用关系**。那在做可达性判定确定对象是否存活的时候，岂不是还得扫描整个Java堆才能保证准确性？这个问题其实并非在G1中才有，只是在G1中更加突出而已。在以前的分代收集中，新生代的规模一般都比老年代要小许多，新生代的收集也比老年代要频繁许多，那回收新生代中的对象时也面临相同的问题，如果回收新生代时也不得不同时扫描老年代的话，那么Minor GC的效率可能下降不少。
-
-在G1收集器中，Region之间的对象引用以及其他收集器中的新生代与老年代之间的对象引用，虚拟机都是使用 **Remembered Set** 来避免全堆扫描的。G1中每个Region都有一个与之对应的Remembered Set，虚拟机发现程序在对Reference类型的数据进行写操作时，会产生一个Write Barrier暂时中断写操作，检查Reference引用的对象是否处于不同的Region之中（在分代的例子中就是检查是否老年代中的对象引用了新生代中的对象），如果是，便通过CardTable把相关引用信息记录到被引用对象所属的Region的Remembered Set之中。当进行内存回收时，在GC根节点的枚举范围中加入Remembered Set即可保证不对全堆扫描也不会有遗漏。
-
-如果不计算维护Remembered Set的操作，G1收集器的运作大致可划分为以下几个步骤：
-
-1. 初始标记（Initial Marking）
-2. 并发标记（Concurrent Marking）
-3. 最终标记（Final Marking）
-4. 筛选回收（Live Data Counting and Evacuation）
-
-对CMS收集器运作过程熟悉的读者，一定已经发现G1的前几个步骤的运作过程和CMS有很多相似之处。初始标记阶段仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS（Next Top at Mark Start）的值，让下一阶段用户程序并发运行时，能在正确可用的Region中创建新对象，这阶段需要停顿线程，但耗时很短。并发标记阶段是从GC Root开始对堆中对象进行可达性分析，找出存活的对象，这阶段耗时较长，但可与用户程序并发执行。而最终标记阶段则是为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线Remembered Set Logs里面，最终标记阶段需要把Remembered Set Logs的数据合并到Remembered Set中，这阶段需要停顿线程，但是可并行执行。最后在筛选回收阶段首先对各个Region的回收价值和成本进行排序，根据用户所期望的GC停顿时间来制定回收计划，从Sun公司透露出来的信息来看，这个阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分Region，时间是用户可控制的，而且停顿用户线程将大幅提高收集效率。通过图3-11可以比较清楚地看到G1收集器的运作步骤中并发和需要停顿的阶段。
-![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103153635-1312699250.png)
-
-关于G1收集器的性能部分，笔者引用了Sun实验室的论文《Garbage-First Garbage Collection》中的一段测试数据。
+
+
+
+## 3.5
+  垃圾收集器是内存回收的具体实现。
+  以下讨论的收集器是基于JDK1.7Update14之后的HotSpot虚拟机。
+  这个虚拟机包含的所有收集器有：
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103037669-1460544075.png)
+  http://blogs.sun.com/jonthecollector/entry/our_collectors
+  Serial    ParNew    Parallel-Scavenge
+
+                                              G1
+
+  CMS       Serial-Old(MSC)    Parallel-Old           
+
+  如果有一种放之四海、任何场景下都适用的完美收集器存在，那HotSpot虚拟机就没必要实现那么多不同的收集器了。
+
+### 3.5.1 Serial 收集器
+  Serial收集器是最基本、发展历史最悠久的收集器，在JDK1.3.1之前是虚拟机新生代收集的唯一选择。
+
+  是 **单线程** 的收集器，进行垃圾收集时，必须 **暂停其他所有的工作线程**，直到它收集结束。用户停顿很长
+
+  运行过程
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103052513-504284596.png)
+    新生代采用 **复制算法** 暂停所有用户线程
+
+  从JDK1.3开始，HotSpot虚拟机开发团队为消除或者减少工作线程因内存回收而导致停顿的努力一直在进行着，从Serial收集器到Parallel收集器，
+  再到Concurrent Mark Sweep（CMS）乃至GC收集器的最前沿成果Garbage First(G1)收集器，用户停顿在不断缩短。
+
+  但是依然是虚拟机运行在Client模式下的默认新生代收集器。
+  优点：简单而高效，对于限定单个CPU的环境来说，Serial 收集器由于没有现成交互的开销，专心做垃圾收集自然获得最高的单线程收集效率。
+
+  在用户桌面应用场景中，分配给虚拟机管理的内存一般来说不会很大，收集几十M甚至一两百M的新生代，停顿时间完全可以控制在几十毫秒最多一百多毫秒以内，只要不频繁发生，这点停顿是可以接受的。
+  所以Serial收集器对于运行在Client模式下的虚拟机来说是一个很好的选择。
+
+### 3.5.2 ParNew 收集器
+  ParNew是Serial的多线程版本。**复制算法**
+  除了使用多条线程进行垃圾收集之外，其余行为包括Serial收集器可用的所有控制参数（例如：-XX：SurvivorRatio、-XX：PretenureSizeThreshold、-XX：HandlePromotionFailure等）、收集算法、Stop The World、对象分配规则、回收策略等都与Serial收集器完全一样，在实现上，这两种收集器也共用了相当多的代码。ParNew收集器的工作过程
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103100129-161732030.png)
+  它却是许多运行在Server模式下的虚拟机中首选的新生代收集器，其中有一个与性能无关但很重要的原因是，除了Serial收集器外，目前只有它 **能与CMS收集器配合工作**。
+
+  ParNew收集器也是使用-XX：+UseConcMarkSweepGC选项后的默认新生代收集器，也可以使用-XX：+UseParNewGC选项来强制指定它。
+
+  ParNew收集器在单CPU的环境中绝对不会有比Serial收集器更好的效果，甚至由于存在线程交互的开销，当然，随着可以使用的CPU的数量的增加，它对于GC时系统资源的有效利用还是很有好处的。它默认开启的收集线程数与CPU的数量相同，在CPU非常多（譬如32个，现在CPU动辄就4核加超线程，服务器超过32个逻辑CPU的情况越来越多了）的环境下，可以使用-XX：ParallelGCThreads参数来限制垃圾收集的线程数。
+
+P
+  并发和并行收集器 概念解释：
+  并行 Parallel：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
+  并发 Concurrent：指用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），用户程序在继续运行，而垃圾收集程序运行于另一个CPU上。
+
+### 3.5.3 Parallel-Scavenge 收集器
+  Parallel-Scavenge是一个新生代收集器，它也是使用 **复制算法** 的收集器,又是并行的 **多线程** 收集器。
+  Parallel Scavenge收集器的特点是它的关注点与其他收集器不同，CMS等收集器的关注点是尽可能地缩短垃圾收集时用户线程的 **停顿时间**，而Parallel Scavenge收集器的目标则是 **达到一个可控制的吞吐量**（Throughput）。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间/（运行用户代码时间+垃圾收集时间），虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，那吞吐量就是99%。
+
+  停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验，而高吞吐量则可以高效率地利用CPU时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。
+
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103109231-712191199.png)
+
+  Parallel Scavenge收集器提供了两个参数用于精确控制吞吐量，分别是控制最大垃圾收集停顿时间的-XX：MaxGCPauseMillis参数以及直接设置吞吐量大小的-XX：GCTimeRatio参数。
+
+  MaxGCPauseMillis参数允许的值是一个大于0的毫秒数，收集器将尽可能地保证内存回收花费的时间不超过设定值。不过大家不要认为如果把这个参数的值设置得稍小一点就能使得系统的垃圾收集速度变得更快，GC停顿时间缩短是以牺牲吞吐量和新生代空间来换取的：系统把新生代调小一些，收集300MB新生代肯定比收集500MB快吧，这也直接导致垃圾收集发生得更频繁一些，原来10秒收集一次、每次停顿100毫秒，现在变成5秒收集一次、每次停顿70毫秒。停顿时间的确在下降，但吞吐量也降下来了。
+
+  GCTimeRatio参数的值应当是一个大于0且小于100的整数，也就是垃圾收集时间占总时间的比率，相当于是吞吐量的倒数。如果把此参数设置为19，那允许的最大GC时间就占总时间的5%（即1/（1+19）），默认值为99，就是允许最大1%（即1/（1+99））的垃圾收集时间。
+
+  由于与吞吐量关系密切，Parallel Scavenge收集器也经常称为“**吞吐量优先**”收集器。除上述两个参数之外，Parallel Scavenge收集器还有一个参数-XX：+UseAdaptiveSizePolicy值得关注。这是一个开关参数，当这个参数打开之后，就不需要手工指定新生代的大小（-Xmn）、Eden与Survivor区的比例（-XX：SurvivorRatio）、晋升老年代对象年龄（-XX：PretenureSizeThreshold）等细节参数了，虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量，这种调节方式称为GC自适应的调节策略（GC Ergonomics）。如果读者对于收集器运作原来不太了解，手工优化存在困难的时候，使用Parallel Scavenge收集器配合自适应调节策略，把内存管理的调优任务交给虚拟机去完成将是一个不错的选择。只需要把基本的内存数据设置好（如-Xmx设置最大堆），然后使用MaxGCPauseMillis参数（更关注最大停顿时间）或GCTimeRatio（更关注吞吐量）参数给虚拟机设立一个优化目标，那具体细节参数的调节工作就由虚拟机完成了。自适应调节策略也是Parallel Scavenge收集器与ParNew收集器的一个重要区别。
+
+### 3.5.4 Serial Old收集器
+  Serial Old是Serial收集器的老年代版本，它同样是一个 **单线程** 收集器，使用“**标记-整理**”算法。
+  这个收集器的主要意义也是在于给Client模式下的虚拟机使用。
+  如果在Server模式下，那么它主要还有两大用途：一种用途是在JDK 1.5以及之前的版本中与Parallel Scavenge收集器搭配使用，另一种用途就是作为CMS收集器的后备预案，在并发收集发生Concurrent Mode Failure时使用。这两点都将在后面的内容中详细讲解。
+
+  Serial Old收集器的工作过程
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103123502-1092886872.png)
+
+### 3.5.5 Parallel Old收集器
+  Parallel Old是Parallel Scavenge收集器的老年代版本，使用 **多线程** 和“**标记-整理**”算法。
+
+  这个收集器是在JDK 1.6中才开始提供的，在此之前，新生代的Parallel Scavenge收集器一直处于比较尴尬的状态。原因是，如果新生代选择了Parallel Scavenge收集器，老年代除了Serial Old（PS MarkSweep）收集器外别无选择，由于老年代Serial Old收集器在服务端应用性能上的“拖累”，使用了Parallel Scavenge收集器也未必能在整体应用上获得吞吐量最大化的效果，由于单线程的老年代收集中无法充分利用服务器多CPU的处理能力，在老年代很大而且硬件比较高级的环境中，这种组合的吞吐量甚至还不一定有ParNew加CMS的组合“给力”。
+
+  直到Parallel Old收集器出现后，“吞吐量优先”收集器终于有了比较 **名副其实的应用组合**，在注重吞吐量以及CPU资源敏感的场合，都可以优先考虑Parallel Scavenge加Parallel Old收集器。
+  Parallel Old收集器的工作过程
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103134120-377437512.png)
+
+### 3.5.6 CMS收集器
+  CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。目前很大一部分的Java应用集中在互联网站或者B/S系统的服务端上，这类应用尤其重视服务的响应速度，希望系统停顿时间最短，以给用户带来较好的体验。CMS收集器就非常符合这类应用的需求。
+
+  从名字（包含“Mark Sweep”）上就可以看出，CMS收集器是基于“**标记—清除**”算法实现的，它的运作过程相对于前面几种收集器来说更复杂一些，整个过程分为4个步骤，包括：
+  1. 初始标记（CMS initial mark）
+  2. 并发标记（CMS concurrent mark）
+  3. 重新标记（CMS remark）
+  4. 并发清除（CMS concurrent sweep）
+
+  其中，**初始标记、重新标记** 这两个步骤仍然需要“Stop The World”。初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快，并发标记阶段就是进行GC RootsTracing的过程，而重新标记阶段则是为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短。
+
+  由于整个过程中耗时最长的 **并发标记和并发清除** 过程收集器线程都可以 **与用户线程一起工作**，所以，从总体上来说，CMS收集器的内存回收过程是与用户线程一起并发执行的。通过图3-10可以比较清楚地看到CMS收集器的运作步骤中并发和需要停顿的时间。
+  ![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103141677-323497299.png)
+
+  CMS是一款优秀的收集器，它的主要优点在名字上已经体现出来了：并发收集、低停顿，Sun公司的一些官方文档中也称之为并发低停顿收集器（Concurrent Low Pause Collector）。但是CMS还远达不到完美的程度，它有以下3个明显的缺点：
+  1. CMS收集器 **对CPU资源非常敏感** 。其实，面向并发设计的程序都对CPU资源比较敏感。在并发阶段，它虽然不会导致用户线程停顿，但是会因为占用了一部分线程（或者说CPU资源）而导致应用程序变慢，总吞吐量会降低。CMS默认启动的回收线程数是（CPU数量+3）/4，也就是当CPU在4个以上时，并发回收时垃圾收集线程不少于25%的CPU资源，并且随着CPU数量的增加而下降。但是当CPU不足4个（譬如2个）时，CMS对用户程序的影响就可能变得很大，如果本来CPU负载就比较大，还分出一半的运算能力去执行收集器线程，就可能导致用户程序的执行速度忽然降低了50%，其实也让人无法接受。为了应付这种情况，虚拟机提供了一种称为“增量式并发收集器”（Incremental Concurrent Mark Sweep/i-CMS）的CMS收集器变种，所做的事情和单CPU年代PC机操作系统使用抢占式来模拟多任务机制的思想一样，就是在并发标记、清理的时候让GC线程、用户线程交替运行，尽量减少GC线程的独占资源的时间，这样整个垃圾收集的过程会更长，但对用户程序的影响就会显得少一些，也就是速度下降没有那么明显。实践证明，增量时的CMS收集器效果很一般，在目前版本中，i-CMS已经被声明为“deprecated”，即不再提倡用户使用。
+  2. CMS收集器 **无法处理浮动垃圾** （Floating Garbage），可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生。由于CMS并发清理阶段用户线程还在运行着，伴随程序运行自然就还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们，只好留待下一次GC时再清理掉。这一部分垃圾就称为“浮动垃圾”。也是由于在垃圾收集阶段用户线程还需要运行，那也就还需要预留有足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分空间提供并发收集时的程序运作使用。在JDK 1.5的默认设置下，CMS收集器当老年代使用了68%的空间后就会被激活，这是一个偏保守的设置，如果在应用中老年代增长不是太快，可以适当调高参数-XX：CMSInitiatingOccupancyFraction的值来提高触发百分比，以便降低内存回收次数从而获取更好的性能，在JDK 1.6中，CMS收集器的启动阈值已经提升至92%。要是CMS运行期间预留的内存无法满足程序需要，就会出现一次“Concurrent Mode Failure”失败，这时虚拟机将启动后备预案：临时启用Serial Old收集器来重新进行老年代的垃圾收集，这样停顿时间就很长了。所以说参数-XX：CMSInitiatingOccupancyFraction设置得太高很容易导致大量“Concurrent Mode Failure”失败，性能反而降低。
+  3. 还有最后一个缺点，在本节开头说过，CMS是一款基于“标记—清除”算法实现的收集器，如果读者对前面这种算法介绍还有印象的话，就可能想到这意味着收集结束时 **会有大量空间碎片产生**。空间碎片过多时，将会给大对象分配带来很大麻烦，往往会出现老年代还有很大空间剩余，但是无法找到足够大的连续空间来分配当前对象，不得不提前触发一次Full GC。为了解决这个问题，CMS收集器提供了一个-XX：+UseCMSCompactAtFullCollection开关参数（默认就是开启的），用于在CMS收集器顶不住要进行FullGC时开启内存碎片的合并整理过程，内存整理的过程是无法并发的，空间碎片问题没有了，但停顿时间不得不变长。虚拟机设计者还提供了另外一个参数-XX：CMSFullGCsBeforeCompaction，这个参数是用于设置执行多少次不压缩的Full GC后，跟着来一次带压缩的（默认值为0，表示每次进入Full GC时都进行碎片整理）。
+
+### 3.5.7 G1收集器
+
+G1（Garbage-First）收集器是当今收集器技术发展的最前沿成果之一，早在JDK 1.7刚刚确立项目目标，Sun公司给出的JDK 1.7 RoadMap里面，它就被视为JDK 1.7中HotSpot虚拟机的一个重要进化特征。从JDK 6u14中开始就有Early Access版本的G1收集器供开发人员实验、试用，由此开始G1收集器的“Experimental”状态持续了数年时间，直至JDK 7u4，Sun公司才认为它达到足够成熟的商用程度，移除了“Experimental”的标识。
+
+G1是一款面向服务端应用的垃圾收集器。HotSpot开发团队赋予它的使命是（在比较长期的）未来可以替换掉JDK 1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点。
+
+**并行与并发**：G1能充分利用多CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短Stop-The-World停顿的时间，部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让Java程序继续执行。
+
+**分代收集**：与其他收集器一样，分代概念在G1中依然得以保留。虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但它能够采用不同的方式去处理新创建的对象和已经存活了一段时间、熬过多次GC的旧对象以获取更好的收集效果。
+
+**空间整合**：与CMS的“标记—清理”算法不同，G1从整体来看是基于“标记—整理”算法实现的收集器，从局部（两个Region之间）上来看是基于“复制”算法实现的，但无论如何，这两种算法都意味着G1运作期间不会产生内存空间碎片，收集后能提供规整的可用内存。这种特性有利于程序长时间运行，分配大对象时不会因为无法找到连续内存空间而提前触发下一次GC。
+
+**可预测的停顿**：这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒，这几乎已经是实时Java（RTSJ）的垃圾收集器的特征了。
+
+在G1之前的其他收集器进行收集的范围都是整个新生代或者老年代，而G1不再是这样。使用G1收集器时，Java堆的内存布局就与其他收集器有很大差别，它将整个Java堆划分为 **多个大小相等的独立区域（Region）**，虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。
+
+G1收集器之所以能建立可预测的停顿时间模型，是因为它可以有计划地避免在整个Java堆中进行全区域的垃圾收集。G1跟踪各个Region里面的垃圾堆积的价值大小（回收所获得的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据允许的收集时间，**优先回收价值最大Region**（这也就是Garbage-First名称的来由）。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了G1收集器在 **有限的时间内可以获取尽可能高的收集效率**。
+
+G1把内存“化整为零”的思路，理解起来似乎很容易，但其中的实现细节却远远没有想象中那样简单，否则也不会从2004年Sun实验室发表第一篇G1的论文开始直到今天（将近10年时间）才开发出G1的商用版。笔者以一个细节为例：把Java堆分为多个Region后，垃圾收集是否就真的能以Region为单位进行了？听起来顺理成章，再仔细想想就很容易发现问题所在：**Region不可能是孤立的。一个对象分配在某个Region中，它并非只能被本Region中的其他对象引用，而是可以与整个Java堆任意的对象发生引用关系**。那在做可达性判定确定对象是否存活的时候，岂不是还得扫描整个Java堆才能保证准确性？这个问题其实并非在G1中才有，只是在G1中更加突出而已。在以前的分代收集中，新生代的规模一般都比老年代要小许多，新生代的收集也比老年代要频繁许多，那回收新生代中的对象时也面临相同的问题，如果回收新生代时也不得不同时扫描老年代的话，那么Minor GC的效率可能下降不少。
+
+在G1收集器中，Region之间的对象引用以及其他收集器中的新生代与老年代之间的对象引用，虚拟机都是使用 **Remembered Set** 来避免全堆扫描的。G1中每个Region都有一个与之对应的Remembered Set，虚拟机发现程序在对Reference类型的数据进行写操作时，会产生一个Write Barrier暂时中断写操作，检查Reference引用的对象是否处于不同的Region之中（在分代的例子中就是检查是否老年代中的对象引用了新生代中的对象），如果是，便通过CardTable把相关引用信息记录到被引用对象所属的Region的Remembered Set之中。当进行内存回收时，在GC根节点的枚举范围中加入Remembered Set即可保证不对全堆扫描也不会有遗漏。
+
+如果不计算维护Remembered Set的操作，G1收集器的运作大致可划分为以下几个步骤：
+
+1. 初始标记（Initial Marking）
+2. 并发标记（Concurrent Marking）
+3. 最终标记（Final Marking）
+4. 筛选回收（Live Data Counting and Evacuation）
+
+对CMS收集器运作过程熟悉的读者，一定已经发现G1的前几个步骤的运作过程和CMS有很多相似之处。初始标记阶段仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS（Next Top at Mark Start）的值，让下一阶段用户程序并发运行时，能在正确可用的Region中创建新对象，这阶段需要停顿线程，但耗时很短。并发标记阶段是从GC Root开始对堆中对象进行可达性分析，找出存活的对象，这阶段耗时较长，但可与用户程序并发执行。而最终标记阶段则是为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线Remembered Set Logs里面，最终标记阶段需要把Remembered Set Logs的数据合并到Remembered Set中，这阶段需要停顿线程，但是可并行执行。最后在筛选回收阶段首先对各个Region的回收价值和成本进行排序，根据用户所期望的GC停顿时间来制定回收计划，从Sun公司透露出来的信息来看，这个阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分Region，时间是用户可控制的，而且停顿用户线程将大幅提高收集效率。通过图3-11可以比较清楚地看到G1收集器的运作步骤中并发和需要停顿的阶段。
+![](https://images2018.cnblogs.com/blog/632650/201805/632650-20180526103153635-1312699250.png)
+
+关于G1收集器的性能部分，笔者引用了Sun实验室的论文《Garbage-First Garbage Collection》中的一段测试数据。
diff --git "a/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\351\207\215\346\236\204 \346\224\271\345\226\204\346\227\242\346\234\211\344\273\243\347\240\201\347\232\204\350\256\276\350\256\241/all.md" "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\351\207\215\346\236\204 \346\224\271\345\226\204\346\227\242\346\234\211\344\273\243\347\240\201\347\232\204\350\256\276\350\256\241/all.md"
new file mode 100644
index 00000000..29dad7a0
--- /dev/null
+++ "b/10 - Reading Notes \350\257\273\344\271\246\347\254\224\350\256\260/\351\207\215\346\236\204 \346\224\271\345\226\204\346\227\242\346\234\211\344\273\243\347\240\201\347\232\204\350\256\276\350\256\241/all.md"	
@@ -0,0 +1,123 @@
+http://wangvsa.github.io/refactoring-cheat-sheet/
+### 第1章 重构，### 第一个案例1
+1.1 起点1
+1.2 重构的### 第一步7
+1.3 分解并重组statement()8
+1.4 运用多态取代与价格相关的条件逻辑34
+1.5 结语52
+### 第2章 重构原则53
+2.1 何谓重构53
+2.2 为何重构55
+2.3 何时重构57
+2.4 怎么对经理说60
+2.5 重构的难题62
+2.6 重构与设计66
+2.7 重构与性能69
+2.8 重构起源何处71
+### 第3章 代码的坏味道75
+3.1 DuplicatedCode（重复代码）76
+3.2 LongMethod（过长函数）76
+3.3 LargeClass（过大的类）78
+3.4 LongParameterList（过长参数列）78
+3.5 DivergentChange（发散式变化）79
+3.6 ShotgunSurgery（霰弹式修改）80
+3.7 FeatureEnvy（依恋情结）80
+3.8 DataClumps（数据泥团）81
+3.9 PrimitiveObsession（基本类型偏执）81
+3.10 SwitchStatements（switch惊悚现身）82
+3.11 ParallelInheritanceHierarchies（平行继承体系）83
+3.12 LazyClass（冗赘类）83
+3.13 SpeculativeGenerality（夸夸其谈未来性）83
+3.14 TemporaryField（令人迷惑的暂时字段）84
+3.15 MessageChains（过度耦合的消息链）84
+3.16 MiddleMan（中间人）85
+3.17 InappropriateIntimacy（狎昵关系）85
+3.18 AlternativeClasseswithDifferentInterfaces（异曲同工的类）85
+3.19 IncompleteLibraryClass（不完美的库类）86
+3.20 DataClass（纯稚的数据类）86
+3.21 RefusedBequest（被拒绝的遗赠）87
+3.22 Comments（过多的注释）87
+### 第4章 构筑测试体系89
+4.1 自测试代码的价值89
+4.2 JUnit测试框架91
+4.3 添加更多测试97
+### 第5章 重构列表103
+5.1 重构的记录格式103
+5.2 寻找引用点105
+5.3 这些重构手法有多成熟106
+### 第6章 重新组织函数109
+6.1 ExtractMethod（提炼函数）110
+6.2 InlineMethod（内联函数）117
+6.3 InlineTemp（内联临时变量）119
+6.4 ReplaceTempwithQuery（以查询取代临时变量）120
+6.5 IntroduceExplainingVariable（引入解释性变量）124
+6.6 SplitTemporaryVariable（分解临时变量）128
+6.7 RemoveAssignmentstoParameters（移除对参数的赋值）131
+6.8 ReplaceMethodwithMethodObject（以函数对象取代函数）135
+6.9 SubstituteAlgorithm（替换算法）139
+### 第7章 在对象之间搬移特性141
+7.1 MoveMethod（搬移函数）142
+7.2 MoveField（搬移字段）146
+7.3 ExtractClass（提炼类）149
+7.4 InlineClass（将类内联化）154
+7.5 HideDelegate（隐藏“委托关系”）157
+7.6 RemoveMiddleMan（移除中间人）160
+7.7 IntroduceForeignMethod（引入外加函数）162
+7.8 IntroduceLocalExtension（引入本地扩展）164
+### 第8章 重新组织数据169
+8.1 SelfEncapsulateField（自封装字段）171
+8.2 ReplaceDataValuewithObject（以对象取代数据值）175
+8.3 ChangeValuetoReference（将值对象改为引用对象）179
+8.4 ChangeReferencetoValue（将引用对象改为值对象）183
+8.5 ReplaceArraywithObject（以对象取代数组）186
+8.6 DuplicateObservedData（复制“被监视数据”）189
+8.7 ChangeUnidirectionalAssociationtoBidirectional（将单向关联改为双向关联）197
+8.8 ChangeBidirectionalAssociationtoUnidirectional（将双向关联改为单向关联）200
+8.9 ReplaceMagicNumberwithSymbolicConstant（以字面常量取代魔法数）204
+8.10 EncapsulateField（封装字段）206
+8.11 EncapsulateCollection（封装集合）208
+8.12 ReplaceRecordwithDataClass（以数据类取代记录）217
+8.13 ReplaceTypeCodewithClass（以类取代类型码）218
+8.14 ReplaceTypeCodewithSubclasses（以子类取代类型码）223
+8.15 ReplaceTypeCodewithState/Strategy（以State/Strategy取代类型码）227
+8.16 ReplaceSubclasswithFields（以字段取代子类）232
+### 第9章 简化条件表达式237
+9.1 DecomposeConditional（分解条件表达式）238
+9.2 ConsolidateConditionalExpression（合并条件表达式）240
+9.3 ConsolidateDuplicateConditionalFragments（合并重复的条件片段）243
+9.4 RemoveControlFlag（移除控制标记）245
+9.5 ReplaceNestedConditionalwithGuardClauses（以卫语句取代嵌套条件表达式）250
+9.6 ReplaceConditionalwithPolymorphism（以多态取代条件表达式）255
+9.7 IntroduceNullObject（引入Null对象）260
+9.8 IntroduceAssertion（引入断言）267
+### 第10章 简化函数调用271
+10.1 RenameMethod（函数改名）273
+10.2 AddParameter（添加参数）275
+10.3 RemoveParameter（移除参数）277
+10.4 SeparateQueryfromModifier（将查询函数和修改函数分离）279
+10.5 ParameterizeMethod（令函数携带参数）283
+10.6 ReplaceParameterwithExplicitMethods（以明确函数取代参数）285
+10.7 PreserveWholeObject（保持对象完整）288
+10.8 ReplaceParameterwithMethods（以函数取代参数）292
+10.9 IntroduceParameterObject（引入参数对象）295
+10.10 RemoveSettingMethod（移除设值函数）300
+10.11 HideMethod（隐藏函数）303
+10.12 ReplaceConstructorwithFactoryMethod（以工厂函数取代构造函数）304
+10.13 EncapsulateDowncast（封装向下转型）308
+10.14 ReplaceErrorCodewithException（以异常取代错误码）310
+10.15 ReplaceExceptionwithTest（以测试取代异常）315
+### 第11章 处理概括关系319
+11.1 PullUpField（字段上移）320
+11.2 PullUpMethod（函数上移）322
+11.3 PullUpConstructorBody（构造函数本体上移）325
+11.4 PushDownMethod（函数下移）328
+11.5 PushDownField（字段下移）329
+11.6 ExtractSubclass（提炼子类）330
+……
+### 第12章 大型重构359
+### 第13章 重构，复用与现实379
+### 第14章 重构工具401
+### 第15章 总结409
+参考书目413
+要点列表417
+索引419
diff --git "a/10 - Reading Notes/Spring\345\256\236\346\210\230/all.md" "b/10 - Reading Notes/Spring\345\256\236\346\210\230/all.md"
deleted file mode 100644
index 7a38f911..00000000
--- "a/10 - Reading Notes/Spring\345\256\236\346\210\230/all.md"	
+++ /dev/null
@@ -1,49 +0,0 @@
-## 第一部分 Spring的核心
-
-第1章 Spring之旅
-
-第2章 装配Bean
-
-第3章 高级装配
-
-第4章 面向切面的Spring
-
-## 第二部分 Web中的Spring
-
-第5章 构建Spring Web应用程序
-
-第6章 渲染Web视图
-
-第7章 Spring MVC的高级技术
-
-第8章 使用Spring Web Flow
-
-第9章 保护Wen应用
-
-## 第三部分 后端中的Spring
-
-第10章 通过Spring和JDBC征服数据库
-
-第11章 使用对象-关系映射持久化数据
-
-第12章 使用NoSQL数据库
-
-第13章 缓存数据
-
-第14章 保护方法应用
-
-## 第四部分 Spring集成
-
-第15章 使用远程服务
-
-第16章 使用Spring MVC创建REST API
-
-第17章 Spring消息
-
-第18章 使用WebSocket和STOMP实现消息功能
-
-第19章 使用Spring发送Email
-
-第20章 使用JMX管理Spring bean
-
-第21章 借助 Spring Boot简化 Spring 开发
diff --git "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/all.md" "b/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/all.md"
deleted file mode 100644
index 8a4df087..00000000
--- "a/10 - Reading Notes/Spring\346\272\220\347\240\201\346\267\261\345\272\246\350\247\243\346\236\220/all.md"	
+++ /dev/null
@@ -1,30 +0,0 @@
-## 第一部分 核心实现
-
-第1章 Spring整体架构和环境搭建
-
-第2章 容器的基本实现
-
-第3章 默认标签的解析
-
-第4章 自定义标签的解析
-
-第5章 bean的加载
-
-第6章 容器的功能扩展
-
-第7章 AOP
-
-
-## 第二部分 企业应用
-
-第8章 数据库连接JDBC
-
-第9章 整合MyBatis
-
-第10章 事务
-
-第11章 SpringMVC
-
-第12章 远程服务
-
-第13章 Spring消息
diff --git "a/10 - Reading Notes/\351\207\215\346\236\204 \346\224\271\345\226\204\346\227\242\346\234\211\344\273\243\347\240\201\347\232\204\350\256\276\350\256\241/all.md" "b/10 - Reading Notes/\351\207\215\346\236\204 \346\224\271\345\226\204\346\227\242\346\234\211\344\273\243\347\240\201\347\232\204\350\256\276\350\256\241/all.md"
deleted file mode 100644
index 6b504c5b..00000000
--- "a/10 - Reading Notes/\351\207\215\346\236\204 \346\224\271\345\226\204\346\227\242\346\234\211\344\273\243\347\240\201\347\232\204\350\256\276\350\256\241/all.md"	
+++ /dev/null
@@ -1 +0,0 @@
-http://wangvsa.github.io/refactoring-cheat-sheet/
diff --git "a/11 - Server/nginx/Nginx\345\217\215\345\220\221\344\273\243\347\220\206WebSocket.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/Nginx\345\217\215\345\220\221\344\273\243\347\220\206WebSocket.md"
similarity index 100%
rename from "11 - Server/nginx/Nginx\345\217\215\345\220\221\344\273\243\347\220\206WebSocket.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/nginx/Nginx\345\217\215\345\220\221\344\273\243\347\220\206WebSocket.md"
diff --git "a/11 - Server/nginx/Nginx\350\264\237\350\275\275\345\235\207\350\241\241\351\205\215\347\275\256\345\256\236\344\276\213\350\257\246\350\247\243.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/Nginx\350\264\237\350\275\275\345\235\207\350\241\241\351\205\215\347\275\256\345\256\236\344\276\213\350\257\246\350\247\243.md"
similarity index 100%
rename from "11 - Server/nginx/Nginx\350\264\237\350\275\275\345\235\207\350\241\241\351\205\215\347\275\256\345\256\236\344\276\213\350\257\246\350\247\243.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/nginx/Nginx\350\264\237\350\275\275\345\235\207\350\241\241\351\205\215\347\275\256\345\256\236\344\276\213\350\257\246\350\247\243.md"
diff --git "a/11 - Server/nginx/Window\345\271\263\345\217\260\344\270\213Nginx\346\263\250\345\206\214\344\270\272\345\220\216\345\217\260\346\234\215\345\212\241.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/Window\345\271\263\345\217\260\344\270\213Nginx\346\263\250\345\206\214\344\270\272\345\220\216\345\217\260\346\234\215\345\212\241.md"
similarity index 100%
rename from "11 - Server/nginx/Window\345\271\263\345\217\260\344\270\213Nginx\346\263\250\345\206\214\344\270\272\345\220\216\345\217\260\346\234\215\345\212\241.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/nginx/Window\345\271\263\345\217\260\344\270\213Nginx\346\263\250\345\206\214\344\270\272\345\220\216\345\217\260\346\234\215\345\212\241.md"
diff --git a/11 - Server/nginx/nginx.pdf "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/nginx.pdf"
similarity index 100%
rename from 11 - Server/nginx/nginx.pdf
rename to "11 - Server \346\234\215\345\212\241\345\231\250/nginx/nginx.pdf"
diff --git a/11 - Server/nginx/winsw-1.8-bin.zip "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/winsw-1.8-bin.zip"
similarity index 100%
rename from 11 - Server/nginx/winsw-1.8-bin.zip
rename to "11 - Server \346\234\215\345\212\241\345\231\250/nginx/winsw-1.8-bin.zip"
diff --git "a/11 - Server/nginx/\345\256\211\350\243\205.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/\345\256\211\350\243\205.md"
similarity index 96%
rename from "11 - Server/nginx/\345\256\211\350\243\205.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/nginx/\345\256\211\350\243\205.md"
index 61202526..5005403a 100644
--- "a/11 - Server/nginx/\345\256\211\350\243\205.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/nginx/\345\256\211\350\243\205.md"	
@@ -1,26 +1,26 @@
-http://www.runoob.com/linux/nginx-install-setup.html
-
-一、安装编译工具及库文件
-```
-yum -y install make zlib zlib-devel gcc-c++ libtool  openssl openssl-devel
-```
-
-二、首先要安装 PCRE
-PCRE 作用是让 Nginx 支持 Rewrite 功能。
-
-1、下载 PCRE 安装包，下载地址： http://downloads.sourceforge.net/project/pcre/pcre/8.35/pcre-8.35.tar.gz
-
-[root@bogon src]# wget http://downloads.sourceforge.net/project/pcre/pcre/8.35/pcre-8.35.tar.gz
-2、解压安装包:
-
-[root@bogon src]# tar zxvf pcre-8.35.tar.gz
-3、进入安装包目录
-
-[root@bogon src]# cd pcre-8.35
-4、编译安装
-
-[root@bogon pcre-8.35]# ./configure
-[root@bogon pcre-8.35]# make && make install
-5、查看pcre版本
-
-[root@bogon pcre-8.35]# pcre-config --version
+http://www.runoob.com/linux/nginx-install-setup.html
+
+一、安装编译工具及库文件
+```
+yum -y install make zlib zlib-devel gcc-c++ libtool  openssl openssl-devel
+```
+
+二、首先要安装 PCRE
+PCRE 作用是让 Nginx 支持 Rewrite 功能。
+
+1、下载 PCRE 安装包，下载地址： http://downloads.sourceforge.net/project/pcre/pcre/8.35/pcre-8.35.tar.gz
+
+[root@bogon src]# wget http://downloads.sourceforge.net/project/pcre/pcre/8.35/pcre-8.35.tar.gz
+2、解压安装包:
+
+[root@bogon src]# tar zxvf pcre-8.35.tar.gz
+3、进入安装包目录
+
+[root@bogon src]# cd pcre-8.35
+4、编译安装
+
+[root@bogon pcre-8.35]# ./configure
+[root@bogon pcre-8.35]# make && make install
+5、查看pcre版本
+
+[root@bogon pcre-8.35]# pcre-config --version
diff --git "a/11 - Server/tomcat/Tomcat \345\244\204\347\220\206http\350\257\267\346\261\202\350\277\207\347\250\213.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/Tomcat \345\244\204\347\220\206http\350\257\267\346\261\202\350\277\207\347\250\213.md"
similarity index 98%
rename from "11 - Server/tomcat/Tomcat \345\244\204\347\220\206http\350\257\267\346\261\202\350\277\207\347\250\213.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/Tomcat \345\244\204\347\220\206http\350\257\267\346\261\202\350\277\207\347\250\213.md"
index fb4250ec..820140dd 100644
--- "a/11 - Server/tomcat/Tomcat \345\244\204\347\220\206http\350\257\267\346\261\202\350\277\207\347\250\213.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/Tomcat \345\244\204\347\220\206http\350\257\267\346\261\202\350\277\207\347\250\213.md"	
@@ -1,18 +1,18 @@
-Tomcat Server处理一个http请求的过程
-
-假设来自客户的请求为：
-http://localhost:8080/wsota/wsota_index.jsp
-
-1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
-2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
-3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
-4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
-5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
-6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
-7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
-8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
-9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
-10)Context把执行完了之后的HttpServletResponse对象返回给Host
-11)Host把HttpServletResponse对象返回给Engine
-12)Engine把HttpServletResponse对象返回给Connector
-13)Connector把HttpServletResponse对象返回给客户browser
+Tomcat Server处理一个http请求的过程
+
+假设来自客户的请求为：
+http://localhost:8080/wsota/wsota_index.jsp
+
+1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
+2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
+3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
+4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
+5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
+6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
+7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
+8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
+9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
+10)Context把执行完了之后的HttpServletResponse对象返回给Host
+11)Host把HttpServletResponse对象返回给Engine
+12)Engine把HttpServletResponse对象返回给Connector
+13)Connector把HttpServletResponse对象返回给客户browser
diff --git "a/11 - Server/tomcat/Tomcat \347\272\277\347\250\213\346\250\241\345\236\213.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/Tomcat \347\272\277\347\250\213\346\250\241\345\236\213.md"
similarity index 99%
rename from "11 - Server/tomcat/Tomcat \347\272\277\347\250\213\346\250\241\345\236\213.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/Tomcat \347\272\277\347\250\213\346\250\241\345\236\213.md"
index 4085ec5a..6a56853c 100644
--- "a/11 - Server/tomcat/Tomcat \347\272\277\347\250\213\346\250\241\345\236\213.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/Tomcat \347\272\277\347\250\213\346\250\241\345\236\213.md"	
@@ -1,44 +1,44 @@
-https://blog.csdn.net/qq_16681169/article/details/75003640
-
-## 一. tomcat支持的请求处理方式
-Tomcat支持三种接收请求的处理方式：BIO、NIO、APR
-
-**BIO模式**：阻塞式I/O操作，表示Tomcat使用的是传统Java I/O操作(即Java.io包及其子包)。Tomcat7以下版本默认情况下是以bio模式运行的，由于每个请求都要创建一个线程来处理，线程开销较大，不能处理高并发的场景，在三种模式中性能也最低。启动tomcat看到如下日志，表示使用的是BIO模式：
-这里写图片描述
-
-**NIO模式**：是java SE 1.4及后续版本提供的一种新的I/O操作方式(即java.nio包及其子包)。是一个基于缓冲区、并能提供非阻塞I/O操作的Java API，它拥有比传统I/O操作(bio)更好的并发运行性能。在tomcat 8之前要让Tomcat以nio模式来运行比较简单，只需要在Tomcat安装目录/conf/server.xml文件中将如下配置：
-
-
-```
-<Connector port="8080" protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443" />
-修改成
-<Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"connectionTimeout="20000"redirectPort="8443" />
-```
-Tomcat8以上版本，默认使用的就是NIO模式，不需要额外修改
-
-**APR模式**：简单理解，就是从操作系统级别解决异步IO问题，大幅度的提高服务器的处理和响应性能， 也是Tomcat运行高并发应用的首选模式。
-启用这种模式稍微麻烦一些，需要安装一些依赖库，下面以在CentOS7 mini版环境下Tomcat-8.0.35为例，介绍安装步聚：
-```
-APR 1.2+ development headers (libapr1-dev package)
-OpenSSL 0.9.7+ development headers (libssl-dev package)
-JNI headers from Java compatible JDK 1.4+
-GNU development environment (gcc, make)
-```
-## 二. tomcat的 **NioEndpoint**
-
-我们先来简单回顾下目前一般的NIO服务器端的大致实现，借鉴infoq上的一篇文章Netty系列之Netty线程模型中的一张图
-
-一个或多个Acceptor线程，每个线程都有自己的Selector，Acceptor只负责accept新的连接，一旦连接建立之后就将连接注册到其他Worker线程中。
-多个Worker线程，有时候也叫IO线程，就是专门负责IO读写的。一种实现方式就是像Netty一样，每个Worker线程都有自己的Selector，可以负责多个连接的IO读写事件，每个连接归属于某个线程。另一种方式实现方式就是有专门的线程负责IO事件监听，这些线程有自己的Selector，一旦监听到有IO读写事件，并不是像第一种实现方式那样（自己去执行IO操作），而是将IO操作封装成一个Runnable交给Worker线程池来执行，这种情况每个连接可能会被多个线程同时操作，相比第一种并发性提高了，但是也可能引来多线程问题，在处理上要更加谨慎些。tomcat的NIO模型就是第二种。
-
-图中Acceptor及Worker分别是以线程池形式存在，Poller是一个单线程。注意，与BIO的实现一样，缺省状态下，在server.xml中没有配置<Executor>，则以Worker线程池运行，如果配置了<Executor>，则以基于java concurrent 系列的java.util.concurrent.ThreadPoolExecutor线程池运行。
-
-**Acceptor**
-接收socket线程，这里虽然是基于NIO的connector，但是在接收socket方面还是传统的serverSocket.accept()方式，获得SocketChannel对象，然后封装在一个tomcat的实现类org.apache.tomcat.util.net.NioChannel对象中。然后将NioChannel对象封装在一个PollerEvent对象中，并将PollerEvent对象压入events queue里。这里是个典型的生产者-消费者模式，Acceptor与Poller线程之间通过queue通信，Acceptor是events queue的生产者，Poller是events queue的消费者。
-
-**Poller**
-Poller线程中维护了一个Selector对象，NIO就是基于Selector来完成逻辑的。在connector中并不止一个Selector，在socket的读写数据时，为了控制timeout也有一个Selector，在后面的BlockSelector中介绍。可以先把Poller线程中维护的这个Selector标为主Selector。
-Poller是NIO实现的主要线程。首先作为events queue的消费者，从queue中取出PollerEvent对象，然后将此对象中的channel以OP_READ事件注册到主Selector中，然后主Selector执行select操作，遍历出可以读数据的socket，并从Worker线程池中拿到可用的Worker线程，然后将socket传递给Worker。整个过程是典型的NIO实现。
-
-**Worker**
-Worker线程拿到Poller传过来的socket后，将socket封装在SocketProcessor对象中。然后从Http11ConnectionHandler中取出Http11NioProcessor对象，从Http11NioProcessor中调用CoyoteAdapter的逻辑，跟BIO实现一样。在Worker线程中，会完成从socket中读取http request，解析成HttpServletRequest对象，分派到相应的servlet并完成逻辑，然后将response通过socket发回client。在从socket中读数据和往socket中写数据的过程，并没有像典型的非阻塞的NIO的那样，注册OP_READ或OP_WRITE事件到主Selector，而是直接通过socket完成读写，这时是阻塞完成的，但是在timeout控制上，使用了NIO的Selector机制，但是这个Selector并不是Poller线程维护的主Selector，而是BlockPoller线程中维护的Selector，称之为辅Selector。
+https://blog.csdn.net/qq_16681169/article/details/75003640
+
+## 一. tomcat支持的请求处理方式
+Tomcat支持三种接收请求的处理方式：BIO、NIO、APR
+
+**BIO模式**：阻塞式I/O操作，表示Tomcat使用的是传统Java I/O操作(即Java.io包及其子包)。Tomcat7以下版本默认情况下是以bio模式运行的，由于每个请求都要创建一个线程来处理，线程开销较大，不能处理高并发的场景，在三种模式中性能也最低。启动tomcat看到如下日志，表示使用的是BIO模式：
+这里写图片描述
+
+**NIO模式**：是java SE 1.4及后续版本提供的一种新的I/O操作方式(即java.nio包及其子包)。是一个基于缓冲区、并能提供非阻塞I/O操作的Java API，它拥有比传统I/O操作(bio)更好的并发运行性能。在tomcat 8之前要让Tomcat以nio模式来运行比较简单，只需要在Tomcat安装目录/conf/server.xml文件中将如下配置：
+
+
+```
+<Connector port="8080" protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443" />
+修改成
+<Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"connectionTimeout="20000"redirectPort="8443" />
+```
+Tomcat8以上版本，默认使用的就是NIO模式，不需要额外修改
+
+**APR模式**：简单理解，就是从操作系统级别解决异步IO问题，大幅度的提高服务器的处理和响应性能， 也是Tomcat运行高并发应用的首选模式。
+启用这种模式稍微麻烦一些，需要安装一些依赖库，下面以在CentOS7 mini版环境下Tomcat-8.0.35为例，介绍安装步聚：
+```
+APR 1.2+ development headers (libapr1-dev package)
+OpenSSL 0.9.7+ development headers (libssl-dev package)
+JNI headers from Java compatible JDK 1.4+
+GNU development environment (gcc, make)
+```
+## 二. tomcat的 **NioEndpoint**
+
+我们先来简单回顾下目前一般的NIO服务器端的大致实现，借鉴infoq上的一篇文章Netty系列之Netty线程模型中的一张图
+
+一个或多个Acceptor线程，每个线程都有自己的Selector，Acceptor只负责accept新的连接，一旦连接建立之后就将连接注册到其他Worker线程中。
+多个Worker线程，有时候也叫IO线程，就是专门负责IO读写的。一种实现方式就是像Netty一样，每个Worker线程都有自己的Selector，可以负责多个连接的IO读写事件，每个连接归属于某个线程。另一种方式实现方式就是有专门的线程负责IO事件监听，这些线程有自己的Selector，一旦监听到有IO读写事件，并不是像第一种实现方式那样（自己去执行IO操作），而是将IO操作封装成一个Runnable交给Worker线程池来执行，这种情况每个连接可能会被多个线程同时操作，相比第一种并发性提高了，但是也可能引来多线程问题，在处理上要更加谨慎些。tomcat的NIO模型就是第二种。
+
+图中Acceptor及Worker分别是以线程池形式存在，Poller是一个单线程。注意，与BIO的实现一样，缺省状态下，在server.xml中没有配置<Executor>，则以Worker线程池运行，如果配置了<Executor>，则以基于java concurrent 系列的java.util.concurrent.ThreadPoolExecutor线程池运行。
+
+**Acceptor**
+接收socket线程，这里虽然是基于NIO的connector，但是在接收socket方面还是传统的serverSocket.accept()方式，获得SocketChannel对象，然后封装在一个tomcat的实现类org.apache.tomcat.util.net.NioChannel对象中。然后将NioChannel对象封装在一个PollerEvent对象中，并将PollerEvent对象压入events queue里。这里是个典型的生产者-消费者模式，Acceptor与Poller线程之间通过queue通信，Acceptor是events queue的生产者，Poller是events queue的消费者。
+
+**Poller**
+Poller线程中维护了一个Selector对象，NIO就是基于Selector来完成逻辑的。在connector中并不止一个Selector，在socket的读写数据时，为了控制timeout也有一个Selector，在后面的BlockSelector中介绍。可以先把Poller线程中维护的这个Selector标为主Selector。
+Poller是NIO实现的主要线程。首先作为events queue的消费者，从queue中取出PollerEvent对象，然后将此对象中的channel以OP_READ事件注册到主Selector中，然后主Selector执行select操作，遍历出可以读数据的socket，并从Worker线程池中拿到可用的Worker线程，然后将socket传递给Worker。整个过程是典型的NIO实现。
+
+**Worker**
+Worker线程拿到Poller传过来的socket后，将socket封装在SocketProcessor对象中。然后从Http11ConnectionHandler中取出Http11NioProcessor对象，从Http11NioProcessor中调用CoyoteAdapter的逻辑，跟BIO实现一样。在Worker线程中，会完成从socket中读取http request，解析成HttpServletRequest对象，分派到相应的servlet并完成逻辑，然后将response通过socket发回client。在从socket中读数据和往socket中写数据的过程，并没有像典型的非阻塞的NIO的那样，注册OP_READ或OP_WRITE事件到主Selector，而是直接通过socket完成读写，这时是阻塞完成的，但是在timeout控制上，使用了NIO的Selector机制，但是这个Selector并不是Poller线程维护的主Selector，而是BlockPoller线程中维护的Selector，称之为辅Selector。
diff --git a/11 - Server/tomcat/[SetPropertiesRule]{ServerServiceEngineHostContext} Setting property 'debug' to '0' did not find a matching property..txt "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/[SetPropertiesRule]{ServerServiceEngineHostContext} Setting property 'debug' to '0' did not find a matching property..txt"
similarity index 100%
rename from 11 - Server/tomcat/[SetPropertiesRule]{ServerServiceEngineHostContext} Setting property 'debug' to '0' did not find a matching property..txt
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/[SetPropertiesRule]{ServerServiceEngineHostContext} Setting property 'debug' to '0' did not find a matching property..txt"
diff --git a/11 - Server/tomcat/all.md "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/all.md"
similarity index 98%
rename from 11 - Server/tomcat/all.md
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/all.md"
index 3c80a314..6a005b0b 100644
--- a/11 - Server/tomcat/all.md	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/all.md"	
@@ -1,22 +1,22 @@
-《How Tomcat works》
-
-
-Tomcat整体架构浅析 https://blog.csdn.net/cx520forever/article/details/52743166
-
-
-Tomcat原理总结
-
-1. Tomcat需要main方法启动。
-2. Tomcat需要监听本机上的某个端口。
-3. Tomcat需要抓取此端口上来自客户端的链接并获得请求调用的方法与参数。
-4. Tomcat需要根据请求调用的方法，动态地加载方法所在的类，完成累的实例化并通过该实例获得需要的方法最终将请求传入方法执行。
-5. 将结果返回给客户端（jsp/html页面、json/xml字符串）。
-
-Tomcat的体系结构
-Tomcat服务器的启动是基于一个server.xml文件的，Tomcat启动的时候首先会启动一个Server，
-Server里面就会启动Service，
-Service里面就会启动多个"Connector(连接器)"，每一个连接器都在等待客户机的连接，当有用户使用浏览器去访问服务器上面的web资源时，首先是连接到Connector(连接器)，
-Connector(连接器)是不处理用户的请求的，而是将用户的请求交给一个Engine(引擎)去处理，
-Engine(引擎)接收到请求后就会解析用户想要访问的Host，然后将请求交给相应的Host，
-Host收到请求后就会解析出用户想要访问这个Host下面的哪一个Web应用,
-一个web应用对应一个Context。
+《How Tomcat works》
+
+
+Tomcat整体架构浅析 https://blog.csdn.net/cx520forever/article/details/52743166
+
+
+Tomcat原理总结
+
+1. Tomcat需要main方法启动。
+2. Tomcat需要监听本机上的某个端口。
+3. Tomcat需要抓取此端口上来自客户端的链接并获得请求调用的方法与参数。
+4. Tomcat需要根据请求调用的方法，动态地加载方法所在的类，完成累的实例化并通过该实例获得需要的方法最终将请求传入方法执行。
+5. 将结果返回给客户端（jsp/html页面、json/xml字符串）。
+
+Tomcat的体系结构
+Tomcat服务器的启动是基于一个server.xml文件的，Tomcat启动的时候首先会启动一个Server，
+Server里面就会启动Service，
+Service里面就会启动多个"Connector(连接器)"，每一个连接器都在等待客户机的连接，当有用户使用浏览器去访问服务器上面的web资源时，首先是连接到Connector(连接器)，
+Connector(连接器)是不处理用户的请求的，而是将用户的请求交给一个Engine(引擎)去处理，
+Engine(引擎)接收到请求后就会解析用户想要访问的Host，然后将请求交给相应的Host，
+Host收到请求后就会解析出用户想要访问这个Host下面的哪一个Web应用,
+一个web应用对应一个Context。
diff --git a/11 - Server/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesJdbc.txt "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesJdbc.txt"
similarity index 100%
rename from 11 - Server/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesJdbc.txt
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesJdbc.txt"
diff --git a/11 - Server/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads.txt "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads.txt"
similarity index 100%
rename from 11 - Server/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads.txt
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads.txt"
diff --git "a/11 - Server/tomcat/server.xml \351\205\215\347\275\256\347\256\200\344\273\213.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/server.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"
similarity index 98%
rename from "11 - Server/tomcat/server.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/server.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"
index 2291b796..f603de17 100644
--- "a/11 - Server/tomcat/server.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/server.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"	
@@ -1,52 +1,52 @@
-https://www.cnblogs.com/zhouyuqin/p/5143121.html
-```
-<Server>                                                //顶层类元素，可以包括多个Service   
-    <Service>                                           //顶层类元素，可包含一个Engine，多个Connecter
-        <Connector>                                     //连接器类元素，代表通信接口
-                <Engine>                                //容器类元素，为特定的Service组件处理客户请求，要包含多个Host
-                        <Host>                          //容器类元素，为特定的虚拟主机组件处理客户请求，可包含多个Context
-                                <Context>               //容器类元素，为特定的Web应用处理所有的客户请求
-                                </Context>
-                        </Host>
-                </Engine>
-        </Connector>
-    </Service>
-</Server>
-```
-### server      
-    1. port 指定一个端口，这个端口负责监听关闭tomcat的请求
-    2. shutdown 指定向端口发送的命令字符串
-
-### service        
-    1. name 指定service的名字
-
-### Connector (表示客户端和service之间的连接)：
-    1. **port** 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
-    2. minProcessors 服务器启动时创建的处理请求的线程数
-    3. maxProcessors 最大可以创建的处理请求的线程数
-    4. enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址
-    5. **redirectPort** 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号
-    6. acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
-    7. **connectionTimeout** 指定超时的时间数(以毫秒为单位)
-
-### Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)：
-    1. defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的
-### Context (表示一个web应用程序)：
-    1. docBase 应用程序的路径或者是WAR文件存放的路径
-    2. path 表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****
-    3. reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序
-### host (表示一个虚拟主机)：
-    1. name 指定主机名
-    2. appBase 应用程序基本目录，即存放应用程序的目录
-    3. unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序
-### Logger (表示日志，调试和错误信息)：
-    1. className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口
-    2. prefix 指定log文件的前缀
-    3. suffix 指定log文件的后缀
-    4. timestamp 如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
-### Realm (表示存放用户名，密码及role的数据库)：
-    1. className 指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
-### Valve (功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)：
-    1. className 指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息
-### directory（指定log文件存放的位置）：
-    1. pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多
+https://www.cnblogs.com/zhouyuqin/p/5143121.html
+```
+<Server>                                                //顶层类元素，可以包括多个Service   
+    <Service>                                           //顶层类元素，可包含一个Engine，多个Connecter
+        <Connector>                                     //连接器类元素，代表通信接口
+                <Engine>                                //容器类元素，为特定的Service组件处理客户请求，要包含多个Host
+                        <Host>                          //容器类元素，为特定的虚拟主机组件处理客户请求，可包含多个Context
+                                <Context>               //容器类元素，为特定的Web应用处理所有的客户请求
+                                </Context>
+                        </Host>
+                </Engine>
+        </Connector>
+    </Service>
+</Server>
+```
+### server      
+    1. port 指定一个端口，这个端口负责监听关闭tomcat的请求
+    2. shutdown 指定向端口发送的命令字符串
+
+### service        
+    1. name 指定service的名字
+
+### Connector (表示客户端和service之间的连接)：
+    1. **port** 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
+    2. minProcessors 服务器启动时创建的处理请求的线程数
+    3. maxProcessors 最大可以创建的处理请求的线程数
+    4. enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址
+    5. **redirectPort** 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号
+    6. acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
+    7. **connectionTimeout** 指定超时的时间数(以毫秒为单位)
+
+### Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)：
+    1. defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的
+### Context (表示一个web应用程序)：
+    1. docBase 应用程序的路径或者是WAR文件存放的路径
+    2. path 表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****
+    3. reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序
+### host (表示一个虚拟主机)：
+    1. name 指定主机名
+    2. appBase 应用程序基本目录，即存放应用程序的目录
+    3. unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序
+### Logger (表示日志，调试和错误信息)：
+    1. className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口
+    2. prefix 指定log文件的前缀
+    3. suffix 指定log文件的后缀
+    4. timestamp 如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
+### Realm (表示存放用户名，密码及role的数据库)：
+    1. className 指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
+### Valve (功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)：
+    1. className 指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息
+### directory（指定log文件存放的位置）：
+    1. pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多
diff --git a/11 - Server/tomcat/server.xml.md "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/server.xml.md"
similarity index 97%
rename from 11 - Server/tomcat/server.xml.md
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/server.xml.md"
index 3a58334c..754b2a72 100644
--- a/11 - Server/tomcat/server.xml.md	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/server.xml.md"	
@@ -1,42 +1,42 @@
-```xml
-<?xml version='1.0' encoding='utf-8'?>
-<Server port="8005" shutdown="SHUTDOWN">
-  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
-  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
-  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
-  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
-  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
-
-  <GlobalNamingResources>
-    <Resource name="UserDatabase" auth="Container"
-              type="org.apache.catalina.UserDatabase"
-              description="User database that can be updated and saved"
-              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
-              pathname="conf/tomcat-users.xml" />
-  </GlobalNamingResources>
-
-  <Service name="Catalina">
-
-    <Connector port="8080" protocol="HTTP/1.1"
-               connectionTimeout="20000"
-               redirectPort="8443" />
-
-    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
-
-    <Engine name="Catalina" defaultHost="localhost">
-      <Realm className="org.apache.catalina.realm.LockOutRealm">
-        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
-               resourceName="UserDatabase"/>
-      </Realm>
-
-      <Host name="localhost"  appBase="webapps"
-            unpackWARs="true" autoDeploy="true">
-        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
-               prefix="localhost_access_log" suffix=".txt"
-               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
-
-      </Host>
-    </Engine>
-  </Service>
-</Server>
-```
+```xml
+<?xml version='1.0' encoding='utf-8'?>
+<Server port="8005" shutdown="SHUTDOWN">
+  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
+  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
+  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
+  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
+  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
+
+  <GlobalNamingResources>
+    <Resource name="UserDatabase" auth="Container"
+              type="org.apache.catalina.UserDatabase"
+              description="User database that can be updated and saved"
+              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
+              pathname="conf/tomcat-users.xml" />
+  </GlobalNamingResources>
+
+  <Service name="Catalina">
+
+    <Connector port="8080" protocol="HTTP/1.1"
+               connectionTimeout="20000"
+               redirectPort="8443" />
+
+    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
+
+    <Engine name="Catalina" defaultHost="localhost">
+      <Realm className="org.apache.catalina.realm.LockOutRealm">
+        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
+               resourceName="UserDatabase"/>
+      </Realm>
+
+      <Host name="localhost"  appBase="webapps"
+            unpackWARs="true" autoDeploy="true">
+        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
+               prefix="localhost_access_log" suffix=".txt"
+               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
+
+      </Host>
+    </Engine>
+  </Service>
+</Server>
+```
diff --git "a/11 - Server/tomcat/web.xml \351\205\215\347\275\256\347\256\200\344\273\213.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/web.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"
similarity index 96%
rename from "11 - Server/tomcat/web.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/web.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"
index 24aa06a4..c552139a 100644
--- "a/11 - Server/tomcat/web.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/web.xml \351\205\215\347\275\256\347\256\200\344\273\213.md"	
@@ -1,60 +1,60 @@
-## 1、默认(欢迎)文件的设置
-
- 在tomcat4\conf\web.xml中，<welcome-file-list>与IIS中的默认文件意思相同。
-
- ```
-   <welcome-file-list>
-      <welcome-file>index.html</welcome-file>
-      <welcome-file>index.htm</welcome-file>
-      <welcome-file>index.jsp</welcome-file>
-   </welcome-file-list>
- ```
-
-## 2、报错文件的设置
-```
-  <error-page>
-    <error-code>404</error-code>
-    <location>/notFileFound.jsp</location>
-  </error-page>
-  <error-page>
-    <exception-type>java.lang.NullPointerException</exception-type>
-    <location>/null.jsp</location>
-  </error-page>
-```
-如果某文件资源没有找到，服务器要报404错误，按上述配置则会调用\webapps\ROOT\notFileFound.jsp。
-如果执行的某个JSP文件产生NullPointException ，则会调用\webapps\ROOT\null.jsp
-
-## 3、会话超时的设置
-
-设置session 的过期时间，单位是分钟；
-```
-  <session-config>
-    <session-timeout>30</session-timeout>
-  </session-config>
-```
-
-## 4、过滤器的设置
-```
-  <filter>
-    <filter-name>FilterSource</filter-name>
-    <filter-class>project4. FilterSource</filter-class>
-  </filter>
-
-  <filter-mapping>
-    <filter-name>FilterSource</filter-name>
-    <url-pattern>/WwwServlet</url-pattern>
-    (<url-pattern>/haha/*</url-pattern>)
-  </filter-mapping>
-```
-
-过滤：
-
-1. 身份验证的过滤Authentication Filters
-2. 日志和审核的过滤Logging and AuditingFilters
-3. 图片转化的过滤Image conversionFilters
-4. 数据压缩的过滤Data compressionFilters
-5. 加密过滤Encryption Filters
-6. Tokenizing Filters
-7. 资源访问事件触发的过滤Filters that triggerresource access events XSL/T 过滤XSL/T filters
-9. 内容类型的过滤Mime-type chain Filter 注意监听器的顺序，如：先安全过滤，然后资源，
-然后内容类型等，这个顺序可以自己定。
+## 1、默认(欢迎)文件的设置
+
+ 在tomcat4\conf\web.xml中，<welcome-file-list>与IIS中的默认文件意思相同。
+
+ ```
+   <welcome-file-list>
+      <welcome-file>index.html</welcome-file>
+      <welcome-file>index.htm</welcome-file>
+      <welcome-file>index.jsp</welcome-file>
+   </welcome-file-list>
+ ```
+
+## 2、报错文件的设置
+```
+  <error-page>
+    <error-code>404</error-code>
+    <location>/notFileFound.jsp</location>
+  </error-page>
+  <error-page>
+    <exception-type>java.lang.NullPointerException</exception-type>
+    <location>/null.jsp</location>
+  </error-page>
+```
+如果某文件资源没有找到，服务器要报404错误，按上述配置则会调用\webapps\ROOT\notFileFound.jsp。
+如果执行的某个JSP文件产生NullPointException ，则会调用\webapps\ROOT\null.jsp
+
+## 3、会话超时的设置
+
+设置session 的过期时间，单位是分钟；
+```
+  <session-config>
+    <session-timeout>30</session-timeout>
+  </session-config>
+```
+
+## 4、过滤器的设置
+```
+  <filter>
+    <filter-name>FilterSource</filter-name>
+    <filter-class>project4. FilterSource</filter-class>
+  </filter>
+
+  <filter-mapping>
+    <filter-name>FilterSource</filter-name>
+    <url-pattern>/WwwServlet</url-pattern>
+    (<url-pattern>/haha/*</url-pattern>)
+  </filter-mapping>
+```
+
+过滤：
+
+1. 身份验证的过滤Authentication Filters
+2. 日志和审核的过滤Logging and AuditingFilters
+3. 图片转化的过滤Image conversionFilters
+4. 数据压缩的过滤Data compressionFilters
+5. 加密过滤Encryption Filters
+6. Tokenizing Filters
+7. 资源访问事件触发的过滤Filters that triggerresource access events XSL/T 过滤XSL/T filters
+9. 内容类型的过滤Mime-type chain Filter 注意监听器的顺序，如：先安全过滤，然后资源，
+然后内容类型等，这个顺序可以自己定。
diff --git "a/11 - Server/tomcat/\344\274\230\345\214\226\345\217\202\346\225\260.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\344\274\230\345\214\226\345\217\202\346\225\260.md"
similarity index 98%
rename from "11 - Server/tomcat/\344\274\230\345\214\226\345\217\202\346\225\260.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\344\274\230\345\214\226\345\217\202\346\225\260.md"
index 01dc4db7..8d51952c 100644
--- "a/11 - Server/tomcat/\344\274\230\345\214\226\345\217\202\346\225\260.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\344\274\230\345\214\226\345\217\202\346\225\260.md"	
@@ -1,98 +1,98 @@
-##  1、内存优化：
-优化内存，主要是在bin/catalina.bat/sh 配置文件中进行。linux上，在catalina.sh中添加：
-```
-JAVA_OPTS="-server -Xms1G -Xmx2G -Xss256K -Djava.awt.headless=true -Dfile.encoding=utf-8 -XX:MaxPermSize=256m -XX:PermSize=128M -XX:MaxPermSize=256M"
-```
-• -server：启用jdk的server版本。
-• -Xms：虚拟机初始化时的最小堆内存。
-• -Xmx：虚拟机可使用的最大堆内存。 #-Xms与-Xmx设成一样的值，避免JVM因为频繁的GC导致性能大起大落
-• -XX:PermSize：设置非堆内存初始值,默认是物理内存的1/64。
-• -XX:MaxNewSize：新生代占整个堆内存的最大值。
-• -XX:MaxPermSize：Perm（俗称方法区）占整个堆内存的最大值，也称内存最大永久保留区域。
-1）错误提示：`java.lang.OutOfMemoryError:Java heap space`
-Tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，有可能导致系统无法运行。常见的问题是报Tomcat内存溢出错误，Outof Memory(系统内存不足)的异常，从而导致客户端显示500错误，一般调整Tomcat的-Xms和-Xmx即可解决问题，通常将-Xms和-Xmx设置成一样，堆的最大值设置为物理可用内存的最大值的80%。
-```
-set JAVA_OPTS=-Xms512m-Xmx512m
-```
-2）错误提示：`java.lang.OutOfMemoryError: PermGenspace`
-PermGenspace的全称是Permanent Generationspace,是指内存的永久保存区域，这块内存主要是被JVM存放Class和Meta信息的,Class在被Loader时就会被放到PermGenspace中，它和存放类实例(Instance)的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGenspace进行清理，所以如果你的应用中有很CLASS的话,就很可能出现PermGen space错误，这种错误常见在web服务器对JSP进行precompile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。解决方法：
-```
-setJAVA_OPTS=-XX:PermSize=128M
-```
-3）在使用-Xms和-Xmx调整tomcat的堆大小时，还需要考虑垃圾回收机制。如果系统花费很多的时间收集垃圾，请减小堆大小。一次完全的垃圾收集应该不超过3-5 秒。如果垃圾收集成为瓶颈，那么需要指定代的大小，检查垃圾收集的详细输出，研究垃圾收集参数对性能的影响。一般说来，你应该使用物理内存的 80% 作为堆大小。当增加处理器时，记得增加内存，因为分配可以并行进行，而垃圾收集不是并行的。
-
-## 2、连接数优化：
-优化连接数，主要是在conf/server.xml配置文件中进行修改。
-### 2.1、优化线程数
-找到Connectorport="8080" protocol="HTTP/1.1"，增加maxThreads和acceptCount属性（使acceptCount大于等于maxThreads），如下:
-```
-<Connectorport="8080" protocol="HTTP/1.1"connectionTimeout="20000" redirectPort="8443"acceptCount="500" maxThreads="400" />
-```
-• maxThreads：tomcat可用于请求处理的最大线程数，默认是200
-• minSpareThreads：tomcat初始线程数，即最小空闲线程数
-• maxSpareThreads：tomcat最大空闲线程数，超过的会被关闭
-• acceptCount：当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理.默认100
-
-### 2.2、使用线程池
-在server.xml中增加executor节点，然后配置connector的executor属性，如下：
-```
-<Executorname="tomcatThreadPool" namePrefix="req-exec-"maxThreads="1000" minSpareThreads="50"maxIdleTime="60000"/>
-<Connectorport="8080" protocol="HTTP/1.1"executor="tomcatThreadPool"/>
-```
-• namePrefix：线程池中线程的命名前缀
-• maxThreads：线程池的最大线程数
-• minSpareThreads：线程池的最小空闲线程数
-• maxIdleTime：超过最小空闲线程数时，多的线程会等待这个时间长度，然后关闭
-• threadPriority：线程优先级
-注：当tomcat并发用户量大的时候，单个jvm进程确实可能打开过多的文件句柄，这时会报java.net.SocketException:Too many open files错误。可使用下面步骤检查：
-• ps -ef |grep tomcat 查看tomcat的进程ID，记录ID号，假设进程ID为10001
-• lsof -p 10001|wc -l 查看当前进程id为10001的 文件操作数
-• 使用命令：ulimit -a 查看每个用户允许打开的最大文件数
-
-### 3、Tomcat Connector三种运行模式（BIO, NIO, APR）
-### 3.1、三种模式比较：
-1）BIO：一个线程处理一个请求。缺点：并发量高时，线程数较多，浪费资源。Tomcat7或以下在Linux系统中默认使用这种方式。
-
-2）NIO：利用Java的异步IO处理，可以通过少量的线程处理大量的请求。Tomcat8在Linux系统中默认使用这种方式。Tomcat7必须修改Connector配置来启动（conf/server.xml配置文件）：
-```
-<Connectorport="8080"protocol="org.apache.coyote.http11.Http11NioProtocol" connectionTimeout="20000"redirectPort="8443"/>
-```
-3）APR(Apache Portable Runtime)：从操作系统层面解决io阻塞问题。Linux如果安装了apr和native，Tomcat直接启动就支持apr。
-
-### 3.2、apr模式
-安装apr以及tomcat-native
-
-yum -y install apr apr-devel
-进入tomcat/bin目录，比如：
-
-cd /opt/local/tomcat/bin/
-tar xzfv tomcat-native.tar.gz
-cd tomcat-native-1.1.32-src/jni/native
-./configure --with-apr=/usr/bin/apr-1-config
-make && make install
-注意最新版本的tomcat自带tomcat-native.war.gz，不过其版本相对于yum安装的apr过高，configure的时候会报错。
-
-解决：yum remove apr apr-devel –y,卸载yum安装的apr和apr-devel,下载最新版本的apr源码包，编译安装;或者下载低版本的tomcat-native编译安装
-
-安装成功后还需要对tomcat设置环境变量，方法是在catalina.sh文件中增加1行：
-
-CATALINA_OPTS="-Djava.library.path=/usr/local/apr/lib"
-apr下载地址：http://apr.apache.org/download.cgi
-
-tomcat-native下载地址：http://tomcat.apache.org/download-native.cgi
-
-修改8080端对应的conf/server.xml
-
-protocol="org.apache.coyote.http11.Http11AprProtocol"
-
-<Connector executor="tomcatThreadPool"
-port="8080"
-protocol="org.apache.coyote.http11.Http11AprProtocol"
-connectionTimeout="20000"
-enableLookups="false"
-redirectPort="8443"
-URIEncoding="UTF-8" />
-PS:启动以后查看日志 显示如下表示开启 apr 模式
-
-Sep 19, 2016 3:46:21 PM org.apache.coyote.AbstractProtocol start
-INFO: Starting ProtocolHandler ["http-apr-8081"]
+##  1、内存优化：
+优化内存，主要是在bin/catalina.bat/sh 配置文件中进行。linux上，在catalina.sh中添加：
+```
+JAVA_OPTS="-server -Xms1G -Xmx2G -Xss256K -Djava.awt.headless=true -Dfile.encoding=utf-8 -XX:MaxPermSize=256m -XX:PermSize=128M -XX:MaxPermSize=256M"
+```
+• -server：启用jdk的server版本。
+• -Xms：虚拟机初始化时的最小堆内存。
+• -Xmx：虚拟机可使用的最大堆内存。 #-Xms与-Xmx设成一样的值，避免JVM因为频繁的GC导致性能大起大落
+• -XX:PermSize：设置非堆内存初始值,默认是物理内存的1/64。
+• -XX:MaxNewSize：新生代占整个堆内存的最大值。
+• -XX:MaxPermSize：Perm（俗称方法区）占整个堆内存的最大值，也称内存最大永久保留区域。
+1）错误提示：`java.lang.OutOfMemoryError:Java heap space`
+Tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，有可能导致系统无法运行。常见的问题是报Tomcat内存溢出错误，Outof Memory(系统内存不足)的异常，从而导致客户端显示500错误，一般调整Tomcat的-Xms和-Xmx即可解决问题，通常将-Xms和-Xmx设置成一样，堆的最大值设置为物理可用内存的最大值的80%。
+```
+set JAVA_OPTS=-Xms512m-Xmx512m
+```
+2）错误提示：`java.lang.OutOfMemoryError: PermGenspace`
+PermGenspace的全称是Permanent Generationspace,是指内存的永久保存区域，这块内存主要是被JVM存放Class和Meta信息的,Class在被Loader时就会被放到PermGenspace中，它和存放类实例(Instance)的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGenspace进行清理，所以如果你的应用中有很CLASS的话,就很可能出现PermGen space错误，这种错误常见在web服务器对JSP进行precompile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。解决方法：
+```
+setJAVA_OPTS=-XX:PermSize=128M
+```
+3）在使用-Xms和-Xmx调整tomcat的堆大小时，还需要考虑垃圾回收机制。如果系统花费很多的时间收集垃圾，请减小堆大小。一次完全的垃圾收集应该不超过3-5 秒。如果垃圾收集成为瓶颈，那么需要指定代的大小，检查垃圾收集的详细输出，研究垃圾收集参数对性能的影响。一般说来，你应该使用物理内存的 80% 作为堆大小。当增加处理器时，记得增加内存，因为分配可以并行进行，而垃圾收集不是并行的。
+
+## 2、连接数优化：
+优化连接数，主要是在conf/server.xml配置文件中进行修改。
+### 2.1、优化线程数
+找到Connectorport="8080" protocol="HTTP/1.1"，增加maxThreads和acceptCount属性（使acceptCount大于等于maxThreads），如下:
+```
+<Connectorport="8080" protocol="HTTP/1.1"connectionTimeout="20000" redirectPort="8443"acceptCount="500" maxThreads="400" />
+```
+• maxThreads：tomcat可用于请求处理的最大线程数，默认是200
+• minSpareThreads：tomcat初始线程数，即最小空闲线程数
+• maxSpareThreads：tomcat最大空闲线程数，超过的会被关闭
+• acceptCount：当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理.默认100
+
+### 2.2、使用线程池
+在server.xml中增加executor节点，然后配置connector的executor属性，如下：
+```
+<Executorname="tomcatThreadPool" namePrefix="req-exec-"maxThreads="1000" minSpareThreads="50"maxIdleTime="60000"/>
+<Connectorport="8080" protocol="HTTP/1.1"executor="tomcatThreadPool"/>
+```
+• namePrefix：线程池中线程的命名前缀
+• maxThreads：线程池的最大线程数
+• minSpareThreads：线程池的最小空闲线程数
+• maxIdleTime：超过最小空闲线程数时，多的线程会等待这个时间长度，然后关闭
+• threadPriority：线程优先级
+注：当tomcat并发用户量大的时候，单个jvm进程确实可能打开过多的文件句柄，这时会报java.net.SocketException:Too many open files错误。可使用下面步骤检查：
+• ps -ef |grep tomcat 查看tomcat的进程ID，记录ID号，假设进程ID为10001
+• lsof -p 10001|wc -l 查看当前进程id为10001的 文件操作数
+• 使用命令：ulimit -a 查看每个用户允许打开的最大文件数
+
+### 3、Tomcat Connector三种运行模式（BIO, NIO, APR）
+### 3.1、三种模式比较：
+1）BIO：一个线程处理一个请求。缺点：并发量高时，线程数较多，浪费资源。Tomcat7或以下在Linux系统中默认使用这种方式。
+
+2）NIO：利用Java的异步IO处理，可以通过少量的线程处理大量的请求。Tomcat8在Linux系统中默认使用这种方式。Tomcat7必须修改Connector配置来启动（conf/server.xml配置文件）：
+```
+<Connectorport="8080"protocol="org.apache.coyote.http11.Http11NioProtocol" connectionTimeout="20000"redirectPort="8443"/>
+```
+3）APR(Apache Portable Runtime)：从操作系统层面解决io阻塞问题。Linux如果安装了apr和native，Tomcat直接启动就支持apr。
+
+### 3.2、apr模式
+安装apr以及tomcat-native
+
+yum -y install apr apr-devel
+进入tomcat/bin目录，比如：
+
+cd /opt/local/tomcat/bin/
+tar xzfv tomcat-native.tar.gz
+cd tomcat-native-1.1.32-src/jni/native
+./configure --with-apr=/usr/bin/apr-1-config
+make && make install
+注意最新版本的tomcat自带tomcat-native.war.gz，不过其版本相对于yum安装的apr过高，configure的时候会报错。
+
+解决：yum remove apr apr-devel –y,卸载yum安装的apr和apr-devel,下载最新版本的apr源码包，编译安装;或者下载低版本的tomcat-native编译安装
+
+安装成功后还需要对tomcat设置环境变量，方法是在catalina.sh文件中增加1行：
+
+CATALINA_OPTS="-Djava.library.path=/usr/local/apr/lib"
+apr下载地址：http://apr.apache.org/download.cgi
+
+tomcat-native下载地址：http://tomcat.apache.org/download-native.cgi
+
+修改8080端对应的conf/server.xml
+
+protocol="org.apache.coyote.http11.Http11AprProtocol"
+
+<Connector executor="tomcatThreadPool"
+port="8080"
+protocol="org.apache.coyote.http11.Http11AprProtocol"
+connectionTimeout="20000"
+enableLookups="false"
+redirectPort="8443"
+URIEncoding="UTF-8" />
+PS:启动以后查看日志 显示如下表示开启 apr 模式
+
+Sep 19, 2016 3:46:21 PM org.apache.coyote.AbstractProtocol start
+INFO: Starting ProtocolHandler ["http-apr-8081"]
diff --git "a/11 - Server/tomcat/\345\220\257\345\212\250\344\274\230\345\205\210\347\272\247.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\345\220\257\345\212\250\344\274\230\345\205\210\347\272\247.md"
similarity index 100%
rename from "11 - Server/tomcat/\345\220\257\345\212\250\344\274\230\345\205\210\347\272\247.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\345\220\257\345\212\250\344\274\230\345\205\210\347\272\247.md"
diff --git "a/11 - Server/tomcat/\345\233\233\345\274\240\345\233\276\345\270\246\344\275\240\344\272\206\350\247\243Tomcat\347\263\273\347\273\237\346\236\266\346\236\204.md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\345\233\233\345\274\240\345\233\276\345\270\246\344\275\240\344\272\206\350\247\243Tomcat\347\263\273\347\273\237\346\236\266\346\236\204.md"
similarity index 98%
rename from "11 - Server/tomcat/\345\233\233\345\274\240\345\233\276\345\270\246\344\275\240\344\272\206\350\247\243Tomcat\347\263\273\347\273\237\346\236\266\346\236\204.md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\345\233\233\345\274\240\345\233\276\345\270\246\344\275\240\344\272\206\350\247\243Tomcat\347\263\273\347\273\237\346\236\266\346\236\204.md"
index 6a5eaac5..d17c8126 100644
--- "a/11 - Server/tomcat/\345\233\233\345\274\240\345\233\276\345\270\246\344\275\240\344\272\206\350\247\243Tomcat\347\263\273\347\273\237\346\236\266\346\236\204.md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\345\233\233\345\274\240\345\233\276\345\270\246\344\275\240\344\272\206\350\247\243Tomcat\347\263\273\347\273\237\346\236\266\346\236\204.md"	
@@ -1 +1 @@
-https://blog.csdn.net/xlgen157387/article/details/79006434
+https://blog.csdn.net/xlgen157387/article/details/79006434
diff --git "a/11 - Server/tomcat/\350\260\210\350\260\210 Tomcat \346\236\266\346\236\204\345\217\212\345\220\257\345\212\250\350\277\207\347\250\213[\345\220\253\351\203\250\347\275\262].md" "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\350\260\210\350\260\210 Tomcat \346\236\266\346\236\204\345\217\212\345\220\257\345\212\250\350\277\207\347\250\213[\345\220\253\351\203\250\347\275\262].md"
similarity index 99%
rename from "11 - Server/tomcat/\350\260\210\350\260\210 Tomcat \346\236\266\346\236\204\345\217\212\345\220\257\345\212\250\350\277\207\347\250\213[\345\220\253\351\203\250\347\275\262].md"
rename to "11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\350\260\210\350\260\210 Tomcat \346\236\266\346\236\204\345\217\212\345\220\257\345\212\250\350\277\207\347\250\213[\345\220\253\351\203\250\347\275\262].md"
index ca652538..4b254e6c 100644
--- "a/11 - Server/tomcat/\350\260\210\350\260\210 Tomcat \346\236\266\346\236\204\345\217\212\345\220\257\345\212\250\350\277\207\347\250\213[\345\220\253\351\203\250\347\275\262].md"	
+++ "b/11 - Server \346\234\215\345\212\241\345\231\250/tomcat/\350\260\210\350\260\210 Tomcat \346\236\266\346\236\204\345\217\212\345\220\257\345\212\250\350\277\207\347\250\213[\345\220\253\351\203\250\347\275\262].md"	
@@ -1,135 +1,135 @@
-https://github.com/c-rainstorm/blog/blob/master/tomcat/%E8%B0%88%E8%B0%88%20Tomcat%20%E6%9E%B6%E6%9E%84%E5%8F%8A%E5%90%AF%E5%8A%A8%E8%BF%87%E7%A8%8B%5B%E5%90%AB%E9%83%A8%E7%BD%B2%5D.md#overview
-
-# 谈谈 Tomcat 架构及启动过程[含部署]
-
-这个题目命的其实是很大的，写的时候还是很忐忑的，但我尽可能把这个过程描述清楚。因为这是读过源码以后写的总结，在写的过程中可能会忽略一些前提条件，如果有哪些比较突兀就出现，或不好理解的地方可以给我提 Issue，我会尽快补充修订相关内容。
-
-很多东西在时序图中体现的已经非常清楚了，没有必要再一步一步的作介绍，所以本文以图为主，然后对部分内容加以简单解释。
-
-- 绘制图形使用的工具是 [PlantUML](http://plantuml.com/) + [Visual Studio Code](https://code.visualstudio.com/) + [PlantUML Extension](https://marketplace.visualstudio.com/items?itemName=jebbs.plantuml)
-- 图形 `PlantUML` 源文件：
-    1. [tomcat-architecture.pu](../res/tomcat-architecture.pu)
-    1. [tomcat-init.pu](../res/tomcat-init.pu)
-    1. [tomcat-start.pu](../res/start.pu)
-    1. [tomcat-context-start.pu](../res/tomcat-context-start.pu)
-    1. [tomcat-background-thread.pu](../res/tomcat-background-thread.pu)
-
-本文对 Tomcat 的介绍以 `Tomcat-9.0.0.M22` 为标准。
-
-`Tomcat-9.0.0.M22` 是 Tomcat 目前最新的版本，但尚未发布，它实现了 `Servlet4.0` 及 `JSP2.3` 并提供了很多新特性，需要 1.8 及以上的 JDK 支持等等，详情请查阅 [Tomcat-9.0-doc](https://tomcat.apache.org/tomcat-9.0-doc/index.html)
-
-<!-- TOC -->
-
-- [Overview](#overview)
-- [Tomcat init](#tomcat-init)
-- [Tomcat Start[Deployment]](#tomcat-startdeployment)
-    - [Context Start](#context-start)
-- [Background process](#background-process)
-- [How to read excellent open source projects](#how-to-read-excellent-open-source-projects)
-- [At last](#at-last)
-- [Reference](#reference)
-
-<!-- /TOC -->
-
----
-
-## Overview
-
-![](../res/tomcat-architecture.png)
-
-1. `Bootstrap` 作为 Tomcat 对外界的启动类,在 `$CATALINA_BASE/bin` 目录下，它通过反射创建 `Catalina` 的实例并对其进行初始化及启动。
-1. `Catalina` 解析 `$CATALINA_BASE/conf/server.xml` 文件并创建 `StandardServer`、`StandardService`、`StandardEngine`、`StandardHost` 等
-1. `StandardServer` 代表的是整个 Servlet 容器，他包含一个或多个 `StandardService`
-1. `StandardService` 包含一个或多个 `Connector`，和一个 `Engine`，`Connector` 和 `Engine` 都是在解析 `conf/server.xml` 文件时创建的，`Engine` 在 Tomcat 的标准实现是 `StandardEngine`
-1. `MapperListener` 实现了 `LifecycleListener` 和 `ContainerListener` 接口用于监听容器事件和生命周期事件。该监听器实例监听所有的容器，包括 `StandardEngine`、`StandardHost`、`StandardContext`、`StandardWrapper`，当容器有变动时，注册容器到 `Mapper`。
-1. `Mapper` 维护了 URL 到容器的映射关系。当请求到来时会根据 `Mapper` 中的映射信息决定将请求映射到哪一个 `Host`、`Context`、`Wrapper`。
-1. `Http11NioProtocol` 用于处理 HTTP/1.1 的请求
-1. `NioEndpoint` 是连接的端点，在请求处理流程中该类是核心类，会重点介绍。
-1. `CoyoteAdapter` 用于将请求从 Connctor 交给 Container 处理。使 Connctor 和 Container 解耦。
-1. `StandardEngine` 代表的是 Servlet 引擎，用于处理 `Connector` 接受的 Request。包含一个或多个 `Host`（虚拟主机）, `Host` 的标准实现是 `StandardHost`。
-1. `StandardHost` 代表的是虚拟主机，用于部署该虚拟主机上的应用程序。通常包含多个 `Context` (Context 在 Tomcat 中代表应用程序)。`Context` 在 Tomcat 中的标准实现是 `StandardContext`。
-1. `StandardContext` 代表一个独立的应用程序，通常包含多个 `Wrapper`，一个 `Wrapper` 容器封装了一个 Servlet，`Wrapper` 的标准实现是 `StandardWrapper`。
-1. `StandardPipeline` 组件代表一个流水线，与 `Valve`（阀）结合，用于处理请求。 `StandardPipeline` 中含有多个 `Valve`， 当需要处理请求时，会逐一调用 `Valve` 的 `invoke` 方法对 Request 和 Response 进行处理。特别的，其中有一个特殊的 `Valve` 叫 `basicValve`,每一个标准容器都有一个指定的 `BasicValve`，他们做的是最核心的工作。
-    - `StandardEngine` 的是 `StandardEngineValve`，他用来将 Request 映射到指定的 `Host`;
-    - `StandardHost` 的是 `StandardHostValve`, 他用来将 Request 映射到指定的 `Context`;
-    - `StandardContext` 的是 `StandardContextValve`，它用来将 Request 映射到指定的 `Wrapper`；
-    - `StandardWrapper` 的是 `StandardWrapperValve`，他用来加载 Rquest 所指定的 Servlet,并调用 Servlet 的 `Service` 方法。
-
-## Tomcat init
-
-![](../res/tomcat-start.png)
-
-- 当通过 `./startup.sh` 脚本或直接通过 `java` 命令来启动 `Bootstrap` 时，Tomcat 的启动过程就正式开始了，启动的入口点就是 `Bootstrap` 类的 `main` 方法。
-- 启动的过程分为两步，分别是 `init` 和 `start`，本节主要介绍 `init`;
-1. 初始化类加载器。[关于 Tomcat 类加载机制，可以参考我之前写的一片文章：[谈谈Java类加载机制](谈谈Java类加载机制.md)]
-    1. 通过从 `CatalinaProperties` 类中获取 `common.loader` 等属性，获得类加载器的扫描仓库。`CatalinaProperties` 类在的静态块中调用了 `loadProperties()` 方法，从 `conf/catalina.properties` 文件中加载了属性.(即在类创建的时候属性就已经加载好了)。
-    1. 通过 `ClassLoaderFactory` 创建 `URLClassLoader` 的实例
-1. 通过反射创建 `Catalina` 的实例并设置 `parentClassLoader`
-1. `setAwait(true)`。设置 `Catalina` 的 `await` 属性为 `true`。在 Start 阶段尾部，若该属性为 `true`，Tomcat 会在 main 线程中监听 `SHUTDOWN` 命令，默认端口是 8005.当收到该命令后执行 `Catalina` 的 `stop()` 方法关闭 Tomcat 服务器。
-1. `createStartDigester()`。`Catalina` 的该方法用于创建一个 Digester 实例，并添加解析 `conf/server.xml` 的 `RuleSet`。Digester 原本是 Apache 的一个开源项目，专门解析 XML 文件的，但我看 Tomcat-9.0.0.M22 中直接将这些类整合到 Tomcat 内部了，而不是引入 jar 文件。Digester 工具的原理不在本文的介绍范围，有兴趣的话可以参考 [The Digester Component - Apache](http://commons.apache.org/proper/commons-digester/index.html) 或 [《How Tomcat works》- Digester [推荐]](https://www.amazon.com/How-Tomcat-Works-Budi-Kurniawan/dp/097521280X) 一章
-1. `parse()` 方法就是 Digester 处理 `conf/server.xml` 创建各个组件的过程。值的一提的是这些组件都是使用反射的方式来创建的。特别的，在创建 Digester 的时候，添加了一些特别的 `rule Set`，用于创建一些十分核心的组件，这些组件在 `conf/server.xml` 中没有但是其作用都比较大，这里做下简单介绍，当 Start 时用到了再详细说明：
-    1. `EngineConfig`。`LifecycleListener` 的实现类,触发 Engine 的生命周期事件后调用，这个监听器没有特别大的作用，就是打印一下日志
-    1. `HostConfig`。`LifecycleListener` 的实现类，触发 Host 的生命周期事件后调用。这个监听器的作用就是部署应用程序，这包括 `conf/<Engine>/<Host>/` 目录下所有的 Context xml 文件 和 `webapps` 目录下的应用程序，不管是 war 文件还是已解压的目录。
-    另外后台进程对应用程序的热部署也是由该监听器负责的。
-    1. `ContextConfig`。`LifecycleListener` 的实现类，触发 Context 的生命周期事件时调用。这个监听器的作用是配置应用程序，它会读取并合并 `conf/web.xml` 和 应用程序的 `web.xml`，分析 `/WEB-INF/classes/` 和 `/WEB-INF/lib/*.jar` 中的 Class 文件的注解，将其中所有的 Servlet、ServletMapping、Filter、FilterMapping、Listener 都配置到 `StandardContext` 中，以备后期使用。当然了 `web.xml` 中还有一些其他的应用程序参数，最后都会一并配置到 `StandardContext` 中。
-1. `reconfigureStartStopExecutor()` 用于重新配置启动和停止子容器的 `Executor`。默认是 1 个线程。我们可以配置 `conf/server.xml` 中 `Engine` 的 `startStopThreads`，来指定用于启动和停止子容器的线程数量，如果配置 0 的话会使用 `Runtime.getRuntime().availableProcessors()` 作为线程数，若配置为负数的话会使用 `Runtime.getRuntime().availableProcessors() + 配置值`，若和小与 1 的话，使用 1 作为线程数。当线程数是 1 时，使用 `InlineExecutorService` 它直接使用当前线程来执行启动停止操作，否则使用 `ThreadPoolExecutor` 来执行，其最大线程数为我们配置的值。
-1. 需要注意的是 Host 的 `init` 操作是在 Start 阶段来做的， `StardardHost` 创建好后其 `state` 属性的默认值是 `LifecycleState.NEW`，所以在其调用 `startInternal()` 之前会进行一次初始化。
-
-## Tomcat Start[Deployment]
-
-![](../res/tomcat-start.png)
-
-1. 图中从 `StandardHost` Start `StandardContext` 的这步其实在真正的执行流程中会直接跳过，因为 `conf/server.xml` 文件中并没有配置任何的 `Context`，所以在 `findChildren()` 查找子容器时会返回空数组，所以之后遍历子容器来启动子容器的 `for` 循环就直接跳过了。
-1. 触发 Host 的 `BEFORE_START_EVENT` 生命周期事件，`HostConfig` 调用其 `beforeStart()` 方法创建 `$CATALINA_BASE/webapps` & `$CATALINA_BASE/conf/<Engine>/<Host>/` 目录。
-1. 触发 Host 的 `START_EVENT` 生命周期事件，`HostConfig` 调用其 `start()` 方法开始部署已在 `$CATALINA_BASE/webapps` & `$CATALINA_BASE/conf/<Engine>/<Host>/` 目录下的应用程序。
-    1. 解析 `$CATALINA_BASE/conf/<Engine>/<Host>/` 目录下所有定义 `Context` 的 XML 文件，并添加到 `StandardHost`。这些 XML 文件称为应用程序描述符。正因为如此，我们可以配置一个虚拟路径来保存应用程序中用到的图片，详细的配置过程请参考 [开发环境配置指南 - 6.3. 配置图片存放目录](https://github.com/c-rainstorm/OnlineShoppingSystem-Documents/blob/master/%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA%E4%B8%8E%E6%8A%80%E6%9C%AF%E8%AF%B4%E6%98%8E/%E5%BC%80%E5%8F%91%E7%8E%AF%E5%A2%83%E9%85%8D%E7%BD%AE%E6%8C%87%E5%8D%97.md#63-%E9%85%8D%E7%BD%AE%E5%9B%BE%E7%89%87%E5%AD%98%E6%94%BE%E7%9B%AE%E5%BD%95)
-    1. 部署 `$CATALINA_BASE/webapps` 下所有的 WAR 文件，并添加到 `StandardHost`。
-    1. 部署 `$CATALINA_BASE/webapps` 下所有已解压的目录，并添加到 `StandardHost`。
-    - 特别的，添加到 `StandardHost` 时，会直接调用 `StandardContext` 的 `start()` 方法来启动应用程序。启动应用程序步骤请看 Context Start 一节。
-1. 在 `StandardEngine` 和 `StandardContext` 启动时都会调用各自的 `threadStart()` 方法，该方法会创建一个新的后台线程来处理该该容器和子容器及容器内各组件的后台事件。`StandardEngine` 会直接创建一个后台线程，`StandardContext` 默认是不创建的，和 `StandardEngine` 共用同一个。后台线程处理机制是周期调用组件的 `backgroundProcess()` 方法。详情请看 Background process 一节。
-1. `MapperListener`
-    - `addListeners(engine)` 方法会将该监听器添加到 `StandardEngine` 和它的所有子容器中
-    - `registerHost()` 会注册所有的 `Host` 和他们的子容器到 `Mapper` 中，方便后期请求处理时使用。
-    - 当有新的应用(`StandardContext`)添加进来后，会触发 Host 的容器事件，然后通过 `MapperListener` 将新应用的映射注册到 `Mapper` 中。
-1. Start 工作都做完以后 `Catalina` 会创建一个 `CatalinaShutdownHook` 并注册到 JVM。`CatalinaShutdownHook` 继承了 `Thread`,是 `Catalina` 的内部类。其 `run` 方法中直接调用了 `Catalina` 的 `stop()` 方法来关闭整个服务器。注册该 Thread 到 JVM 的原因是防止用户非正常终止 Tomcat，比如直接关闭命令窗口之类的。当直接关闭命令窗口时，操作系统会向 JVM 发送一个终止信号，然后 JVM 在退出前会逐一启动已注册的 ShutdownHook 来关闭相应资源。
-
-### Context Start
-
-![](../res/tomcat-context-start.png)
-1. `StandRoot` 类实现了 `WebResourceRoot` 接口，它容纳了一个应用程序的所有资源，通俗的来说就是部署到 `webapps` 目录下对应 `Context` 的目录里的所有资源。因为我对 Tomcat 的资源管理部分暂时不是很感兴趣，所以资源管理相关类只是做了简单了解，并没有深入研究源代码。
-1. `resourceStart()` 方法会对 `StandardRoot` 进行初始配置
-1. `postWorkDirectory()` 用于创建对应的工作目录 `$CATALINA_BASE/work/<Engine>/<Host>/<Context>`, 该目录用于存放临时文件。
-1. `StardardContext` 只是一个容器，而 `ApplicationContext` 则是一个应用程序真正的运行环境，相关类及操作会在请求处理流程看完以后进行补充。
-1. `StardardContext` 触发 `CONFIGURE_START_EVENT` 生命周期事件，`ContextConfig` 开始调用 `configureStart()` 对应用程序进行配置。
-    1. 这个过程会解析并合并 `conf/web.xml` & `conf/<Engine>/<Host>/web.xml.default` & `webapps/<Context>/WEB-INF/web.xml` 中的配置。
-    1. 配置配置文件中的参数到 `StandardContext`, 其中主要的包括 Servlet、Filter、Listener。
-    1. 因为从 Servlet3.0 以后是直接支持注解的，所以服务器必须能够处理加了注解的类。Tomcat 通过分析 `WEB-INF/classes/` 中的 Class 文件和 `WEB-INF/lib/` 下的 jar 包将扫描到的 Servlet、Filter、Listerner 注册到 `StandardContext`。
-    1. `setConfigured(true)`，是非常关键的一个操作，它标识了 Context 的成功配置，若未设置该值为 true 的话，Context 会启动失败。
-
-## Background process
-
-![](../res/tomcat-background-thread.png)
-
-1. 后台进程的作用就是处理一下 Servlet 引擎中的周期性事件，处理周期默认是 10s。
-1. 特别的 `StandardHost` 的 `backgroundProcess()` 方法会触发 Host 的 `PERIODIC_EVENT` 生命周期事件。然后 `HostConfig` 会调用其 `check()` 方法对已加载并进行过重新部署的应用程序进行 `reload` 或对新部署的应用程序进行热部署。热部署跟之前介绍的部署步骤一致， `reload()` 过程只是简单的顺序调用 `setPause(true)、stop()、start()、setPause(false)`，其中 `setPause(true)` 的作用是暂时停止接受请求。
-
-## How to read excellent open source projects
-
-真正的第一次阅读开源项目源代码，收获还是很大的。让我在架构设计、面向对象思想、设计模式、Clean Code等等各个方面都有了进步。阅读优秀的开源项目其实是一件很爽的事，因为时不时的会发现一个新的设计思路，然后不由自主的感叹一声居然还可以这样！当然了，读的时候还是会有一些痛点的，比如说碰到一个变量，但是死活就是找不到初始化的位置，有时通过 Find Usage 工具可以找到，但有些找不到的只能从头开始再过一边源码。有时碰到一个设计思路死活都想不明白为什么这样设计等等，这种情况就只能通过分析更高一层的架构来解决了等等。
-
-下面我简单分享一下我是如何阅读开源项目源码的。
-
-1. 先找一些介绍该项目架构的书籍来看，项目架构是项目核心中的核心，读架构读的是高层次的设计思路，读源码读的是低层次的实现细节。有了高层次的设计思路做指导，源码读起来才会得心应手，因为读的时候心里很清楚现在在读的源码在整个项目架构中处于什么位置。我在读 Tomcat 源码之前先把 《How Tomcat works》 一书过了一边，然后又看了一下 《Tomcat 架构解析》 的第二章，对 Tomcat 的架构有了初步了解。（PS:《How Tomcat works》一书是全英文的，但读起来非常流畅，虽然它是基于 Tomcat 4 和 5 的，但 Tomcat 架构没有非常大的变化，新版的 Tomcat 只是增加了一些组件，如果你要学习 Tomcat 的话，首推这本书！）
-1. 如果实在找不到讲架构的书，那就自己动手画类图吧！一般来说，开源项目都是为了提供服务的，我们把提供服务的流程作为主线来分析源代码，这样目的性会更强一些，将该流程中涉及到的类画到类图中，最后得到的类图就是架构！不过分析之前你要先找到流程的入口点，否则分析就无从开始。以 Tomcat 为例，他的主线流程大致可以分为 3 个：启动、部署、请求处理。他们的入口点就是 `Bootstrap` 类和 接受请求的 `Acceptor` 类！
-1. 有了阅读思路我们下面来说说工具吧。我使用的阅读工具是 IntelliJ IDEA，一款十分强大的 IDE，可能比较重量级，如果你有其他更加轻量级的 Linux 平台源码阅读工具，可以推荐给我～
-    1. Structure 栏目可以自定义列出类中的域、方法，然后还可以按照继承结构对域和方法进行分组，这样就可以直接看出来域和方法是在继承结构中哪个类里定义的。当你点击方法和域时，还可以自动滚动到源代码等等。
-    1. 在源代码中 `点击右键 -> Diagrams -> show Diagram` 可以显示类的继承结构，图中包含了该类所有的祖先和所有的接口。在该图中选择指定的父类和接口，`点击右键 -> show Implementations`， IDEA 会列出接口的实现类或该类的子类。
-    1. FindUsage、Go To Declaration 等等就不再多说了。
-    1. 目前想到的就这么多，如果你发现了我没有提到的功能，欢迎跟我邮件交流～
-
-## Reference
-
-1. [《How Tomcat works》](https://www.amazon.com/How-Tomcat-Works-Budi-Kurniawan/dp/097521280X)
-1. [《Tomcat 架构解析》-- 刘光瑞](http://product.dangdang.com/25084132.html)
-1. [Tomcat-9.0-doc](https://tomcat.apache.org/tomcat-9.0-doc/index.html)
-1. [apache-tomcat-9.0.0.M22-src](http://www-eu.apache.org/dist/tomcat/tomcat-9/v9.0.0.M22/src/)
+https://github.com/c-rainstorm/blog/blob/master/tomcat/%E8%B0%88%E8%B0%88%20Tomcat%20%E6%9E%B6%E6%9E%84%E5%8F%8A%E5%90%AF%E5%8A%A8%E8%BF%87%E7%A8%8B%5B%E5%90%AB%E9%83%A8%E7%BD%B2%5D.md#overview
+
+# 谈谈 Tomcat 架构及启动过程[含部署]
+
+这个题目命的其实是很大的，写的时候还是很忐忑的，但我尽可能把这个过程描述清楚。因为这是读过源码以后写的总结，在写的过程中可能会忽略一些前提条件，如果有哪些比较突兀就出现，或不好理解的地方可以给我提 Issue，我会尽快补充修订相关内容。
+
+很多东西在时序图中体现的已经非常清楚了，没有必要再一步一步的作介绍，所以本文以图为主，然后对部分内容加以简单解释。
+
+- 绘制图形使用的工具是 [PlantUML](http://plantuml.com/) + [Visual Studio Code](https://code.visualstudio.com/) + [PlantUML Extension](https://marketplace.visualstudio.com/items?itemName=jebbs.plantuml)
+- 图形 `PlantUML` 源文件：
+    1. [tomcat-architecture.pu](../res/tomcat-architecture.pu)
+    1. [tomcat-init.pu](../res/tomcat-init.pu)
+    1. [tomcat-start.pu](../res/start.pu)
+    1. [tomcat-context-start.pu](../res/tomcat-context-start.pu)
+    1. [tomcat-background-thread.pu](../res/tomcat-background-thread.pu)
+
+本文对 Tomcat 的介绍以 `Tomcat-9.0.0.M22` 为标准。
+
+`Tomcat-9.0.0.M22` 是 Tomcat 目前最新的版本，但尚未发布，它实现了 `Servlet4.0` 及 `JSP2.3` 并提供了很多新特性，需要 1.8 及以上的 JDK 支持等等，详情请查阅 [Tomcat-9.0-doc](https://tomcat.apache.org/tomcat-9.0-doc/index.html)
+
+<!-- TOC -->
+
+- [Overview](#overview)
+- [Tomcat init](#tomcat-init)
+- [Tomcat Start[Deployment]](#tomcat-startdeployment)
+    - [Context Start](#context-start)
+- [Background process](#background-process)
+- [How to read excellent open source projects](#how-to-read-excellent-open-source-projects)
+- [At last](#at-last)
+- [Reference](#reference)
+
+<!-- /TOC -->
+
+---
+
+## Overview
+
+![](../res/tomcat-architecture.png)
+
+1. `Bootstrap` 作为 Tomcat 对外界的启动类,在 `$CATALINA_BASE/bin` 目录下，它通过反射创建 `Catalina` 的实例并对其进行初始化及启动。
+1. `Catalina` 解析 `$CATALINA_BASE/conf/server.xml` 文件并创建 `StandardServer`、`StandardService`、`StandardEngine`、`StandardHost` 等
+1. `StandardServer` 代表的是整个 Servlet 容器，他包含一个或多个 `StandardService`
+1. `StandardService` 包含一个或多个 `Connector`，和一个 `Engine`，`Connector` 和 `Engine` 都是在解析 `conf/server.xml` 文件时创建的，`Engine` 在 Tomcat 的标准实现是 `StandardEngine`
+1. `MapperListener` 实现了 `LifecycleListener` 和 `ContainerListener` 接口用于监听容器事件和生命周期事件。该监听器实例监听所有的容器，包括 `StandardEngine`、`StandardHost`、`StandardContext`、`StandardWrapper`，当容器有变动时，注册容器到 `Mapper`。
+1. `Mapper` 维护了 URL 到容器的映射关系。当请求到来时会根据 `Mapper` 中的映射信息决定将请求映射到哪一个 `Host`、`Context`、`Wrapper`。
+1. `Http11NioProtocol` 用于处理 HTTP/1.1 的请求
+1. `NioEndpoint` 是连接的端点，在请求处理流程中该类是核心类，会重点介绍。
+1. `CoyoteAdapter` 用于将请求从 Connctor 交给 Container 处理。使 Connctor 和 Container 解耦。
+1. `StandardEngine` 代表的是 Servlet 引擎，用于处理 `Connector` 接受的 Request。包含一个或多个 `Host`（虚拟主机）, `Host` 的标准实现是 `StandardHost`。
+1. `StandardHost` 代表的是虚拟主机，用于部署该虚拟主机上的应用程序。通常包含多个 `Context` (Context 在 Tomcat 中代表应用程序)。`Context` 在 Tomcat 中的标准实现是 `StandardContext`。
+1. `StandardContext` 代表一个独立的应用程序，通常包含多个 `Wrapper`，一个 `Wrapper` 容器封装了一个 Servlet，`Wrapper` 的标准实现是 `StandardWrapper`。
+1. `StandardPipeline` 组件代表一个流水线，与 `Valve`（阀）结合，用于处理请求。 `StandardPipeline` 中含有多个 `Valve`， 当需要处理请求时，会逐一调用 `Valve` 的 `invoke` 方法对 Request 和 Response 进行处理。特别的，其中有一个特殊的 `Valve` 叫 `basicValve`,每一个标准容器都有一个指定的 `BasicValve`，他们做的是最核心的工作。
+    - `StandardEngine` 的是 `StandardEngineValve`，他用来将 Request 映射到指定的 `Host`;
+    - `StandardHost` 的是 `StandardHostValve`, 他用来将 Request 映射到指定的 `Context`;
+    - `StandardContext` 的是 `StandardContextValve`，它用来将 Request 映射到指定的 `Wrapper`；
+    - `StandardWrapper` 的是 `StandardWrapperValve`，他用来加载 Rquest 所指定的 Servlet,并调用 Servlet 的 `Service` 方法。
+
+## Tomcat init
+
+![](../res/tomcat-start.png)
+
+- 当通过 `./startup.sh` 脚本或直接通过 `java` 命令来启动 `Bootstrap` 时，Tomcat 的启动过程就正式开始了，启动的入口点就是 `Bootstrap` 类的 `main` 方法。
+- 启动的过程分为两步，分别是 `init` 和 `start`，本节主要介绍 `init`;
+1. 初始化类加载器。[关于 Tomcat 类加载机制，可以参考我之前写的一片文章：[谈谈Java类加载机制](谈谈Java类加载机制.md)]
+    1. 通过从 `CatalinaProperties` 类中获取 `common.loader` 等属性，获得类加载器的扫描仓库。`CatalinaProperties` 类在的静态块中调用了 `loadProperties()` 方法，从 `conf/catalina.properties` 文件中加载了属性.(即在类创建的时候属性就已经加载好了)。
+    1. 通过 `ClassLoaderFactory` 创建 `URLClassLoader` 的实例
+1. 通过反射创建 `Catalina` 的实例并设置 `parentClassLoader`
+1. `setAwait(true)`。设置 `Catalina` 的 `await` 属性为 `true`。在 Start 阶段尾部，若该属性为 `true`，Tomcat 会在 main 线程中监听 `SHUTDOWN` 命令，默认端口是 8005.当收到该命令后执行 `Catalina` 的 `stop()` 方法关闭 Tomcat 服务器。
+1. `createStartDigester()`。`Catalina` 的该方法用于创建一个 Digester 实例，并添加解析 `conf/server.xml` 的 `RuleSet`。Digester 原本是 Apache 的一个开源项目，专门解析 XML 文件的，但我看 Tomcat-9.0.0.M22 中直接将这些类整合到 Tomcat 内部了，而不是引入 jar 文件。Digester 工具的原理不在本文的介绍范围，有兴趣的话可以参考 [The Digester Component - Apache](http://commons.apache.org/proper/commons-digester/index.html) 或 [《How Tomcat works》- Digester [推荐]](https://www.amazon.com/How-Tomcat-Works-Budi-Kurniawan/dp/097521280X) 一章
+1. `parse()` 方法就是 Digester 处理 `conf/server.xml` 创建各个组件的过程。值的一提的是这些组件都是使用反射的方式来创建的。特别的，在创建 Digester 的时候，添加了一些特别的 `rule Set`，用于创建一些十分核心的组件，这些组件在 `conf/server.xml` 中没有但是其作用都比较大，这里做下简单介绍，当 Start 时用到了再详细说明：
+    1. `EngineConfig`。`LifecycleListener` 的实现类,触发 Engine 的生命周期事件后调用，这个监听器没有特别大的作用，就是打印一下日志
+    1. `HostConfig`。`LifecycleListener` 的实现类，触发 Host 的生命周期事件后调用。这个监听器的作用就是部署应用程序，这包括 `conf/<Engine>/<Host>/` 目录下所有的 Context xml 文件 和 `webapps` 目录下的应用程序，不管是 war 文件还是已解压的目录。
+    另外后台进程对应用程序的热部署也是由该监听器负责的。
+    1. `ContextConfig`。`LifecycleListener` 的实现类，触发 Context 的生命周期事件时调用。这个监听器的作用是配置应用程序，它会读取并合并 `conf/web.xml` 和 应用程序的 `web.xml`，分析 `/WEB-INF/classes/` 和 `/WEB-INF/lib/*.jar` 中的 Class 文件的注解，将其中所有的 Servlet、ServletMapping、Filter、FilterMapping、Listener 都配置到 `StandardContext` 中，以备后期使用。当然了 `web.xml` 中还有一些其他的应用程序参数，最后都会一并配置到 `StandardContext` 中。
+1. `reconfigureStartStopExecutor()` 用于重新配置启动和停止子容器的 `Executor`。默认是 1 个线程。我们可以配置 `conf/server.xml` 中 `Engine` 的 `startStopThreads`，来指定用于启动和停止子容器的线程数量，如果配置 0 的话会使用 `Runtime.getRuntime().availableProcessors()` 作为线程数，若配置为负数的话会使用 `Runtime.getRuntime().availableProcessors() + 配置值`，若和小与 1 的话，使用 1 作为线程数。当线程数是 1 时，使用 `InlineExecutorService` 它直接使用当前线程来执行启动停止操作，否则使用 `ThreadPoolExecutor` 来执行，其最大线程数为我们配置的值。
+1. 需要注意的是 Host 的 `init` 操作是在 Start 阶段来做的， `StardardHost` 创建好后其 `state` 属性的默认值是 `LifecycleState.NEW`，所以在其调用 `startInternal()` 之前会进行一次初始化。
+
+## Tomcat Start[Deployment]
+
+![](../res/tomcat-start.png)
+
+1. 图中从 `StandardHost` Start `StandardContext` 的这步其实在真正的执行流程中会直接跳过，因为 `conf/server.xml` 文件中并没有配置任何的 `Context`，所以在 `findChildren()` 查找子容器时会返回空数组，所以之后遍历子容器来启动子容器的 `for` 循环就直接跳过了。
+1. 触发 Host 的 `BEFORE_START_EVENT` 生命周期事件，`HostConfig` 调用其 `beforeStart()` 方法创建 `$CATALINA_BASE/webapps` & `$CATALINA_BASE/conf/<Engine>/<Host>/` 目录。
+1. 触发 Host 的 `START_EVENT` 生命周期事件，`HostConfig` 调用其 `start()` 方法开始部署已在 `$CATALINA_BASE/webapps` & `$CATALINA_BASE/conf/<Engine>/<Host>/` 目录下的应用程序。
+    1. 解析 `$CATALINA_BASE/conf/<Engine>/<Host>/` 目录下所有定义 `Context` 的 XML 文件，并添加到 `StandardHost`。这些 XML 文件称为应用程序描述符。正因为如此，我们可以配置一个虚拟路径来保存应用程序中用到的图片，详细的配置过程请参考 [开发环境配置指南 - 6.3. 配置图片存放目录](https://github.com/c-rainstorm/OnlineShoppingSystem-Documents/blob/master/%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA%E4%B8%8E%E6%8A%80%E6%9C%AF%E8%AF%B4%E6%98%8E/%E5%BC%80%E5%8F%91%E7%8E%AF%E5%A2%83%E9%85%8D%E7%BD%AE%E6%8C%87%E5%8D%97.md#63-%E9%85%8D%E7%BD%AE%E5%9B%BE%E7%89%87%E5%AD%98%E6%94%BE%E7%9B%AE%E5%BD%95)
+    1. 部署 `$CATALINA_BASE/webapps` 下所有的 WAR 文件，并添加到 `StandardHost`。
+    1. 部署 `$CATALINA_BASE/webapps` 下所有已解压的目录，并添加到 `StandardHost`。
+    - 特别的，添加到 `StandardHost` 时，会直接调用 `StandardContext` 的 `start()` 方法来启动应用程序。启动应用程序步骤请看 Context Start 一节。
+1. 在 `StandardEngine` 和 `StandardContext` 启动时都会调用各自的 `threadStart()` 方法，该方法会创建一个新的后台线程来处理该该容器和子容器及容器内各组件的后台事件。`StandardEngine` 会直接创建一个后台线程，`StandardContext` 默认是不创建的，和 `StandardEngine` 共用同一个。后台线程处理机制是周期调用组件的 `backgroundProcess()` 方法。详情请看 Background process 一节。
+1. `MapperListener`
+    - `addListeners(engine)` 方法会将该监听器添加到 `StandardEngine` 和它的所有子容器中
+    - `registerHost()` 会注册所有的 `Host` 和他们的子容器到 `Mapper` 中，方便后期请求处理时使用。
+    - 当有新的应用(`StandardContext`)添加进来后，会触发 Host 的容器事件，然后通过 `MapperListener` 将新应用的映射注册到 `Mapper` 中。
+1. Start 工作都做完以后 `Catalina` 会创建一个 `CatalinaShutdownHook` 并注册到 JVM。`CatalinaShutdownHook` 继承了 `Thread`,是 `Catalina` 的内部类。其 `run` 方法中直接调用了 `Catalina` 的 `stop()` 方法来关闭整个服务器。注册该 Thread 到 JVM 的原因是防止用户非正常终止 Tomcat，比如直接关闭命令窗口之类的。当直接关闭命令窗口时，操作系统会向 JVM 发送一个终止信号，然后 JVM 在退出前会逐一启动已注册的 ShutdownHook 来关闭相应资源。
+
+### Context Start
+
+![](../res/tomcat-context-start.png)
+1. `StandRoot` 类实现了 `WebResourceRoot` 接口，它容纳了一个应用程序的所有资源，通俗的来说就是部署到 `webapps` 目录下对应 `Context` 的目录里的所有资源。因为我对 Tomcat 的资源管理部分暂时不是很感兴趣，所以资源管理相关类只是做了简单了解，并没有深入研究源代码。
+1. `resourceStart()` 方法会对 `StandardRoot` 进行初始配置
+1. `postWorkDirectory()` 用于创建对应的工作目录 `$CATALINA_BASE/work/<Engine>/<Host>/<Context>`, 该目录用于存放临时文件。
+1. `StardardContext` 只是一个容器，而 `ApplicationContext` 则是一个应用程序真正的运行环境，相关类及操作会在请求处理流程看完以后进行补充。
+1. `StardardContext` 触发 `CONFIGURE_START_EVENT` 生命周期事件，`ContextConfig` 开始调用 `configureStart()` 对应用程序进行配置。
+    1. 这个过程会解析并合并 `conf/web.xml` & `conf/<Engine>/<Host>/web.xml.default` & `webapps/<Context>/WEB-INF/web.xml` 中的配置。
+    1. 配置配置文件中的参数到 `StandardContext`, 其中主要的包括 Servlet、Filter、Listener。
+    1. 因为从 Servlet3.0 以后是直接支持注解的，所以服务器必须能够处理加了注解的类。Tomcat 通过分析 `WEB-INF/classes/` 中的 Class 文件和 `WEB-INF/lib/` 下的 jar 包将扫描到的 Servlet、Filter、Listerner 注册到 `StandardContext`。
+    1. `setConfigured(true)`，是非常关键的一个操作，它标识了 Context 的成功配置，若未设置该值为 true 的话，Context 会启动失败。
+
+## Background process
+
+![](../res/tomcat-background-thread.png)
+
+1. 后台进程的作用就是处理一下 Servlet 引擎中的周期性事件，处理周期默认是 10s。
+1. 特别的 `StandardHost` 的 `backgroundProcess()` 方法会触发 Host 的 `PERIODIC_EVENT` 生命周期事件。然后 `HostConfig` 会调用其 `check()` 方法对已加载并进行过重新部署的应用程序进行 `reload` 或对新部署的应用程序进行热部署。热部署跟之前介绍的部署步骤一致， `reload()` 过程只是简单的顺序调用 `setPause(true)、stop()、start()、setPause(false)`，其中 `setPause(true)` 的作用是暂时停止接受请求。
+
+## How to read excellent open source projects
+
+真正的第一次阅读开源项目源代码，收获还是很大的。让我在架构设计、面向对象思想、设计模式、Clean Code等等各个方面都有了进步。阅读优秀的开源项目其实是一件很爽的事，因为时不时的会发现一个新的设计思路，然后不由自主的感叹一声居然还可以这样！当然了，读的时候还是会有一些痛点的，比如说碰到一个变量，但是死活就是找不到初始化的位置，有时通过 Find Usage 工具可以找到，但有些找不到的只能从头开始再过一边源码。有时碰到一个设计思路死活都想不明白为什么这样设计等等，这种情况就只能通过分析更高一层的架构来解决了等等。
+
+下面我简单分享一下我是如何阅读开源项目源码的。
+
+1. 先找一些介绍该项目架构的书籍来看，项目架构是项目核心中的核心，读架构读的是高层次的设计思路，读源码读的是低层次的实现细节。有了高层次的设计思路做指导，源码读起来才会得心应手，因为读的时候心里很清楚现在在读的源码在整个项目架构中处于什么位置。我在读 Tomcat 源码之前先把 《How Tomcat works》 一书过了一边，然后又看了一下 《Tomcat 架构解析》 的第二章，对 Tomcat 的架构有了初步了解。（PS:《How Tomcat works》一书是全英文的，但读起来非常流畅，虽然它是基于 Tomcat 4 和 5 的，但 Tomcat 架构没有非常大的变化，新版的 Tomcat 只是增加了一些组件，如果你要学习 Tomcat 的话，首推这本书！）
+1. 如果实在找不到讲架构的书，那就自己动手画类图吧！一般来说，开源项目都是为了提供服务的，我们把提供服务的流程作为主线来分析源代码，这样目的性会更强一些，将该流程中涉及到的类画到类图中，最后得到的类图就是架构！不过分析之前你要先找到流程的入口点，否则分析就无从开始。以 Tomcat 为例，他的主线流程大致可以分为 3 个：启动、部署、请求处理。他们的入口点就是 `Bootstrap` 类和 接受请求的 `Acceptor` 类！
+1. 有了阅读思路我们下面来说说工具吧。我使用的阅读工具是 IntelliJ IDEA，一款十分强大的 IDE，可能比较重量级，如果你有其他更加轻量级的 Linux 平台源码阅读工具，可以推荐给我～
+    1. Structure 栏目可以自定义列出类中的域、方法，然后还可以按照继承结构对域和方法进行分组，这样就可以直接看出来域和方法是在继承结构中哪个类里定义的。当你点击方法和域时，还可以自动滚动到源代码等等。
+    1. 在源代码中 `点击右键 -> Diagrams -> show Diagram` 可以显示类的继承结构，图中包含了该类所有的祖先和所有的接口。在该图中选择指定的父类和接口，`点击右键 -> show Implementations`， IDEA 会列出接口的实现类或该类的子类。
+    1. FindUsage、Go To Declaration 等等就不再多说了。
+    1. 目前想到的就这么多，如果你发现了我没有提到的功能，欢迎跟我邮件交流～
+
+## Reference
+
+1. [《How Tomcat works》](https://www.amazon.com/How-Tomcat-Works-Budi-Kurniawan/dp/097521280X)
+1. [《Tomcat 架构解析》-- 刘光瑞](http://product.dangdang.com/25084132.html)
+1. [Tomcat-9.0-doc](https://tomcat.apache.org/tomcat-9.0-doc/index.html)
+1. [apache-tomcat-9.0.0.M22-src](http://www-eu.apache.org/dist/tomcat/tomcat-9/v9.0.0.M22/src/)
diff --git "a/12 - Practice (problems encountered during development)/CROS\350\267\250\345\237\237/README.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CROS\350\267\250\345\237\237/README.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/CROS\350\267\250\345\237\237/README.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CROS\350\267\250\345\237\237/README.md"
diff --git "a/12 - Practice (problems encountered during development)/CROS\350\267\250\345\237\237/\350\267\250\345\237\237CROS.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CROS\350\267\250\345\237\237/\350\267\250\345\237\237CROS.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/CROS\350\267\250\345\237\237/\350\267\250\345\237\237CROS.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CROS\350\267\250\345\237\237/\350\267\250\345\237\237CROS.md"
diff --git "a/12 - Practice (problems encountered during development)/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.md"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.md"
index 0aabd642..ab0a4364 100644
--- "a/12 - Practice (problems encountered during development)/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.md"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.md"	
@@ -1,412 +1,412 @@
-### 常见代码问题
-
-常见的潜在代码问题是当前直接会导致BUG、故障或者产品功能不能正常工作的类别。
-
-#### 空值
-  空值恐怕是最容易出现的地方之一。 常见错误有：
-  1. 值为NULL导致空指针异常；
-  2. 参数字符串含有前导或后缀空格没有Trim导致查询为空。
-
-  导致以上结果的原因主要有： **无此记录、有此记录但由于SQL访问异常而没查到、网络调用失败、记录中有脏数据、参数没传。**
-
-  原则上，对于任何异常， 希望能够打印出具体的错误信息，根据错误信息很快明白是什么原因， 而不是一个 null ，还要在代码里去推敲为什么为空。
-
-  这样我们必须识别出程序中可能的null， 并及时检测、捕获和抛出异常。
-
-  对于空值，最好的防护是 **防御式编程**。当获取到对象之后， 使用之前总是判断是否为空，并适当抛出异常、打错误日志或做其它处理。
-  有的人嫌检测为空的 if 语句充斥在代码里会破坏代码的可维护性， 对此我的建议是：
-
-  1. 空值检测一定要有， 有胜于无。
-  2. 在空值检测总是存在的前提下， 可以优化空值检测的方法和存在形式。 比如集中于一个类 NullChecker 中管理，并与系统的整体错误处理设计保持一致。集中管理和处理一致性原则可以作为系统设计的一个准则。 这样主流程中只要增加一行调用即可， 既可以天网恢恢疏而不漏地检测对象为空， 也不会让代码显得难看。
-  ```java
-  class NullChecker {
-     public static void checkNull(Object obj, Error error) {
-         if (obj == null)  { throw new BizException(error); }
-     }
-  }
-  ```
-  3. 在参数入口处统一做 trim。 如果在业务逻辑里做 trim ， 就会导致有的业务逻辑做了 trim ， 有的没做， 体现在产品上就会有令用户困惑的事情发生。 比如搜索和导出业务， 搜索能搜索出来， 导出却没有。
-
-#### 未捕获潜在的异常
-
-  第二个容易出错的地方是未捕获潜在的异常。
-  调用API接口、库函数或系统服务等，只顾着享受便利却不做防护，常导致因为局部失败而影响整体的功能。
-  最好的防护依然是 **防御式编程**。 要么在当前方法捕获异常并返回合适的空值或空对象，要么抛给高层处理。
-
-  切不可默默”吞掉错误和异常”。 如果这样做了， 出问题了等着加班和耗费大量脑细胞吧！
-  在CodeReview的时候一定要仔细询问：这里是否可能会抛出异常？如果抛异常会怎么处理？是否会影响整体服务和返回结果？
-
-#### 低性能
-
-  低性能会导致产品功能不好用、不可用，甚至导致产品失败。
-
-  常见情况有：
-  1. 循环地逐个调用单个接口获取数据或访问数据库;
-  2. 重复创建几乎完全相同的(开销大的)对象；
-  3. 数据库访问、网络调用等服务未处理超时的情况；
-  4. 多重循环对于大数据量处理的算法性能低；
-  5. 大量字符串拼接时使用了String而非StringBuilder.
-
-  对于 1，最好提供批量接口或批量并发获取数据；
-  对于 2, 将可复用对象抽离出循环，一次创建多次使用；
-  对于 3，设置合理的超时时间并捕获超时异常处理；
-  对于 4，使用预排序或预处理， 构造合适的数据结构， 使得算法平均性能在 O(n) 或 O(nlogn) ；
-  对于 5, 记住： 少量字符串拼接使用String, 大量字符串拼接使用 StringBuilder， 通常不会使用到 StringBuffer.
-
-#### 影响范围过大
-
-  对多个模块依赖的公共函数的修改，容易造成影响范围超过当前业务改动，无意识地破坏依赖于该公共函数的其他业务。要特别慎重。
-  可靠的方式是：先查看该公共函数的调用， 如果只有自己的业务用，可适当大胆一些； 如果有多个地方依赖，抽离一个新的函数，抽离原函数里的可复用部分，然后基于可复用部分构建新的函数。
-  修改原则遵循 **“开闭”原则**，才能尽可能使改动影响降低到最小化。
-
-  基类及实例字段和方法也属于公共函数的范畴。 尽量不要修改基类的东西。
-
-#### 单测问题
-
-  单测是保证工程质量的第一道重要防线。单测问题一般包括：
-  1. 单测未全部通过；
-  2. 重要业务逻辑缺乏单测；
-  3. 缺乏异常单测；
-  4. 代码变更或BUG修复缺乏单测。
-
-  单测全部通过应当是提交代码到代码库以及代码Review的前提条件。
-  代码提交者应当保证单测全部通过。没有捷径可走。仅当单测全部通过才提交到代码库， 可以通过工具自动化实现。
-  对于 maven 管理的工程， 只需一个命令： mvn test && git push origin branch_name 。
-  单测应当更注重质，而非单纯追求覆盖率。
-
-  缺乏单测的重要业务逻辑就像裸露在空气中的电线一样，虽然能跑起来，却是很容易“触电”的。 方法： 增加覆盖比较全面的单测。
-
-  缺乏异常单测也是代码提交者常忽略的问题。 异常也是一种实际的业务场景，反映系统的健壮性和友好性。异常应该有相应的单元测试覆盖。创建条件使之抛出异常，并判断异常是否是指定异常；若没有抛出异常或者不是指定异常，则应该 AssertFailed 而不是通过。
-
-  对于代码变更和BUG修复，如果当时由于时间紧而没有写，后续应当补上。对于每个代码变更和BUG，都可以抽离出相应的代码部分， 并有相应单测覆盖，并注明原因。
-
-#### 与原有业务逻辑不兼容
-
-  改动针对当前需求是合理的，却与原有业务逻辑不兼容，也是常见的问题。比如增加一个搜索条件， 却不能与原有条件联合查询。
-  与原有业务不兼容， 一般出现在：
-
-  1. 一对一与一对多的变化。 比如原来的关系是一个订单对应一个物流信息， 后来变化为一个订单可能对应多个物流信息； 原来的逻辑是一个订单显示多个物流信息可以更改，后来要求一个订单只展示最近一次的物流信息可以修改。
-  2. 多个业务组合。 业务 A 与业务 B 原来是分开发展的， 后来开展一种活动，将业务A与业务B进行一种组合营销。 此时，多半会出现很多 if-else 语句。
-  业务逻辑的兼容问题一般体现在系统的复用性和可扩展机制上。良好的系统可复用性和可扩展性可以更容易地做到业务逻辑兼容。
-
-  主要有如下几种级别：
-
-  1. 自动兼容。 增加一种类型， 只是 biz_type 的值多了一种， 系统自动将已有功能适配给新的 biz_type；
-  2. 一点改动。增加一个分支语句， 对 biz_type 的某个特性进行扩展；
-  3. 一些改动。 需要见缝插针地增加一个单独的分支判断和逻辑处理模块， 对整体可扩展性没有影响， 但会造成局部的复杂化；
-  4. 一部分功能改动。 只需要对其中一个功能模块做个扩展；
-  5. 多处改动。 需要对多个功能模块做相应的改造，不过更多是新增而不是修改；
-  6. 难以改动。 需要深入到功能模块内部做艰难的修改， 并要保证原有功能不受影响。
-
-  如何应对呢？
-
-  1. 针对关联关系， 在项目之初， 可以询问清楚： 将来在产品上是否有可扩展的变化？ 及早预留空间， 或者确定产品上的对策； 在代码实现上， 兼顾考虑一对一到一对多，或一对多到一对一的关联变化。比如使用列表来表达单个信息， 使用索引从列表中获取单个信息。
-  2. 针对业务组合， 明确各业务的核心部分， 抽离出业务的可复用的部分，形成 API ； 考虑组合模式和装饰器模式来进行扩展。
-  核心不变， 外围定制化。
-
-#### 缺乏必要日志
-
-  对于重要而关键的实例状态、代码路径及API调用，应当添加适当的`INFO`日志；
-  对于异常，应当捕获并添加`Error`日志。
-  缺乏日志并不会影响业务功能，但出现问题排查时，就会非常不方便，甚至错失极宝贵的机会(不易重现的情况尤其如此)。
-  此外，缺乏日志也会导致可控性差，难以做数据统计和分析。
-
-#### 错误码不符合规范
-
-  错误码本身不算是代码问题，不过基于整个组织和工程的可维护性来说，可以将错误码不符合规范作为一种错误加以避免。
-  方法：
-  对错误码进行可控的管理和遵循规范使用。
-  可以使用公共文档维护， 也可以开发错误码管理系统来避免相同的错误码。
-
-#### 参数检测缺乏或不足
-
-  参数检测是对业务处理的第一层重要过滤。
-  如果参数检测不足够，就会导致脏数据进入服务处理，轻则导致异常，重则插入脏数据到数据库，对后续维护都会造成很多维护成本。
-  方法： 采用 **“契约式编程”**，规定前置条件，并使用单测进行覆盖。
-
-  对于复杂的业务应用， 优雅的参数检测处理尤为重要。 根据 “集中管理和处理一致性原则”， 可以建立一个 paramchecker 包， 设计一个可复用的微框架来对应用中所有的参数进行统一集中化检测。
-  参数检测主要包括：
-  1. 参数的值类型， 可以根据不同值类型做基础的检测；
-  2. 参数的业务类型， 有基础非业务参数， 基础业务参数和具体业务参数。 不同的参数业务类型有不同的处理。 将参数值类型与参数业务类型结合起来， 结合一致性的异常捕获处理， 就可以实现一个可复用的参数检测框架。参数检测既可以采用普通的分支语句，也可以采用注解方式。采用注解方式更可读，不过单测编写更具技巧。
-
-#### 引用错误
-
-  对于动态语言， 由于缺乏强大的静态代码检测，修改了类引用的地方尤其要注意，很可能导致依赖的其他业务出错； 尤其是修改重名引用时。
-  有线上故障教训。PHP工程中含有两个 Format 类， 一个基础的一个业务相关的， 被改动的类文件里开始没有指明引用，默认采用了基础 Format 类的实现， 然后提交者在改动文件头增加了对业务 Format 的引用， 导致依赖于基础Format类的其他业务不能正常工作。
-  避免引用错误的方法：
-  当要在文件里增加新的类引用时， 先在文件里搜索是否有重名类的引用。如果有， 就要格外小心了。
-
-#### 细节错误
-
-  比如数组越界、JSON解析出错、函数参数传递出错、API 版本不对、使用网上拷贝的未经测试的代码、不成熟的算法、传值与传引用、相等性比较等。
-
-  对于数组越界错误， 通常要对空数组、针对数组大小的边界值+1和-1写单测来避免；
-  使用网上拷贝的代码，诚然可节省时间，也一定要加工一下并用单测覆盖；
-  传值和传引用可通过单测来避免错误；
-  对象的相等性比较切忌使用等号=。
-
-#### 多重条件
-
-  类似 if ((!A || !B) && C || (D && E)) 的多重条件要仔细推敲。
-  方法：
-  最好拆分成多个有含义变量。
-  ```
-  isNotDelay = !A || !B ;
-  isNormal = C ;
-  isAllow = D && E ;
-  cond = isNotDelay && isNormal || isAllow 。
-  ```
-
-#### 文不符实
-
-  文不符实是一种可能导致线上故障的错误。
-  比如一个 getXXX 的函数，结果里面还做了 add, update 的操作。
-  对问题排查、产品运维等都有非常大的杀伤力。因此命名一定要用实质内容相符，除非是故意搞破坏。
-
-#### 跨语言或跨系统交互
-
-  稍具规模的互联网创业公司通常会采用多语言开发，比如PHP作为前端，Java作为后台服务。
-  当动态类型语言与静态类型语言交互时，会有一些问题产生。
-  比如PHP的对象通常是一个Map, 如果是空对象就会写成 [], 然而 [] 会被 Java 解析成列表。
-  这样， 如果数据库的值是通过 PHP 写入，那么这个值既有可能是JSON对象字符串，也可能是空数组字符串， Java 来解析就有点尴尬了。
-  同样，当 Java 调用 PHP 接口时， 不规范的PHP接口既可能返回列表，也可能返回 true or false ， Java 解析返回结果也会比较尴尬。
-  因此， 在跨语言交互的边界处，要特别注意这些类型转换的差异。
-
-  跨系统交互则主要是接口设计与约定的问题。同一个项目里不同业务团队之间的业务接口设计与约定， 不同企业里开放接口的设计与约定， 要在最初深思熟虑，一旦开放，在后期很少有接口设计改动的空间。
-  开放接口设计要符合小而美、正交的特性， 命名要贴切一致， 参数取值要指明约束，枚举参数要给出列表， 结果返回要规范一致，可以采用通用的 {“code”:200, “msg”: “success”, “data”: xxx} 。
-  跨系统交互也要统一对术语和接口的理解的一致。
-
-#### 可维护性问题
-
-  可维护性问题是“在当前业务变更的范围内通常不会导致BUG、故障，却会在日后埋下地雷，引发BUG、故障、维护成本大幅增加”的类别。
-
-#### 硬编码
-
-  硬编码主要有三种情况：
-  1. “魔数”；
-  2. 写死的配置；
-  3. 临时加的逻辑和文案。
-
-  “魔数”与重复代码类似，当前或许不会引发问题，时间一长，为了弄清楚其代表的含义，增加很多沟通维护成本，且分散在各处很容易导致修改的时候遗漏不一致。务必清清除。
-  方法也比较简单：定义含义明显的枚举或常量，代表这个魔数在代码中发言。
-
-  “写死的配置”不会影响业务功能， 不过在环境变更或系统调优的时候，就显得很不方便了。 方法： 尽量将配置抽离出来做成配置项放到配置文件里。
-
-  “临时加的逻辑和文案”也是一种破坏系统可维护性的做法。方法： 抽离出来放在单独的函数或方法里，并特别加以注释。
-
-#### 重复代码
-
-  重复代码在当前可能不会造成 BUG，但上线后，需要维护多处的事实一致性；时间一长，后续修改的时候就特别容易遗漏或处理不一致导致 BUG；重复代码是公认的“代码坏味”，必当尽力清除。
-  方法： **抽离通用的部分，定制差异。** 重复代码还有一种情况出现，即创造新函数时，先看看是否既有方法已经实现过。
-
-  通用逻辑与定制业务逻辑耦合
-  这大概是每个媛猿们在开发生涯中遇到的最恶心的事情之一了。通用逻辑与具体的各种业务逻辑混杂交错，想插根针都难。遇到这种情况，只能先祈福，然后抽离一个新的函数，严格判断相应条件满足后去调用它。
-
-  如果是新创建逻辑，可以使用函数式编程或基于接口的编程，将通用处理流程抽离出来，而将具体业务逻辑以回调函数的形式传入处理。
-
-  不要让不同的业务共用相同的函数，然后在函数里一堆 if-else plus switch ， 而是每个业务都有各自的函数， 并可复用相同的通用逻辑和流程处理； 或者各个业务可以覆写同样命名的函数。
-
-  复用，而非混杂。
-
-#### 直接在原方法里加逻辑
-
-  有业务改动时，猿媛们图方便倾向于直接在原方法里加判断和逻辑。这样做是很不好的习惯。
-  一方面，增加了原方法的长度，破坏了其可维护性；
-  另一方面，有可能对原方法的既有逻辑造成破坏。
-  可靠的方式是： **新增一个函数，然后在原方法中调用并说明原因。**
-
-#### 多业务耦合
-
-  在业务边界未仔细划分清晰的情况下出现，一个业务过多深入和掺杂另一个非相关业务的实现细节。
-  在项目和系统设计之初，特别要注意先划分业务边界，定义好接口设计和服务依赖关系，
-  再着手开发；否则，延迟到后期做这些工作，很可能会导致重复的工作量，含糊复杂的交互、增加后期系统维护和问题排查的许多成本。磨刀不误砍柴工。
-  划分清晰的业务、服务、接口边界就属于磨刀的功夫。
-
-#### 代码层次不合理
-
-  代码改动逻辑是正确的，然而代码的放置位置不符合当前架构设计约定，导致后续维护成本增加。
-
-  代码层次不合理可能导致重复代码。
-  比如获取操作人和操作记录，如果写在类 XController 里， 那么类 YController 就面临尴尬局面： 如果写在 YController ， 就会导致重复代码；
-  如果跨层去调用 XController 方法，又是非常不推荐的做法。
-  因此， 获取操作人和操作记录，最好写在 Service 层，
-  Controller 层只负责参数传入、检测和结果转译、返回。
-
-#### 不用多余的代码
-
-  工程中常常会有一些不用的代码。
-  或者是一些暂时未用到的Util工具或库函数，或者是由于业务变更导致已经废弃不用的代码，或者是由于一时写出后来又重写的代码。
-  尽量清除掉不用多余的代码，对系统可维护性是一种很好的改善，同时也有利于CodeReview。
-
-#### 使用全局变量
-
-  使用全局变量并没有“错”，错的是，一旦出现问题，排查和调试问题起来，真的会让人“一夜之间白了头”，耗费数个小时是轻微惩罚。
-  此外，全局变量还能“顺手牵羊”地破坏函数的通用性，导致可维护性变差。
-  务必消除全局变量的使用。当然，全局常量是可以的。
-
-#### 缺乏必要的注释
-
-  对重要和关键点的代码缺乏必要的注释，使用到的重要算法缺乏必要的引用出处，对特别的处理缺乏必要的说明。
-
-  原则上， 每个方法至少要用一个简短的单行注释， 适宜地描述了方法的用途、业务逻辑、作者及日期。对于特殊甚至奇葩的需求的特别实现，要加一些注释。 这样后续维护时有个基础。
-
-#### 更难发现的错误
-
-  更难发现的错误是指“复杂并发场景下的有一定技术难度的、需要丰富开发与设计经验才能看出来的错误”。
-
-#### 并发
-
-  并发的问题更难检测、复现和调试。常见的问题有：
-  1. 在可能由多线程并发访问的对象中含有共享变量却没有同步保护；
-  2. 在代码中手动创建缺乏控制的线程或线程池；
-  3. 并发访问数据库时没有做任何同步措施；
-  4. 多个线程对同一对象的互斥操作没有同步保护。
-
-  对于 1, 在大部分Java应用中，通常由Spring框架来控制和创建请求和服务实例，因此，保证 **“Controller, Service 类中的实例变量只允许 Service, DAO 的单例，不允许业务变量实例”** 基本确保没有并发不正确更新的问题；不过，包含缓存策略的对象要特别注意多线程并发访问的问题，出于性能考量， 尽量只对共享实例部分加锁。
-
-  对于 2, 禁止在应用中手动创建线程或线程池，失控的线程池很容易导致应用崩溃(有线上应用崩溃的教训)。
-
-  对于 3, 并发访问数据库时，要特别注意时序和状态同步。如果时序控制不对，会导致状态同步和更新出错。
-
-  对于 4, 对同一对象的互斥操作需要加分布式锁同步。
-
-  使用线程池、并发库、并发类、同步工具而不是线程对象、并发原语。在复杂并发场景下，还需注意多个同步对象上的锁是否按合适的顺序获得和释放以避免死锁，相应的错误处理代码是否合理。
-
-#### 事务
-
-  事务方面常出现的问题是：多个紧密关联的业务操作和 SQL 语句没有事务保证。 在资金业务操作或数据强一致性要求的业务操作中，要注意使用事务，保证数据更新的一致性和完整性。
-
-#### SQL问题
-
-  SQL的正确性通常可以通过 DAO 测试来保证。 SQL问题主要是指潜在的性能问题和安全问题。
-
-  要避免SQL性能问题， 在表设计的时候就要做好索引工作。
-
-  在表数据量非常大的情况下，SQL语句编写要非常小心。
-
-  查询SQL需要添加必要索引，添加合适的查询条件和查询顺序，加快查询效率， 避免慢查； 尽量避免使用 Join, 子查询；避免SQL注入。
-
-  SQL优秀书籍推荐： 《SQL语言艺术》
-
-#### 安全问题
-
-  安全问题一向是互联网产品研发中极容易被忽视、而在爆发后又极引发热议的议题。安全和隐私是用户的心理红线之一。应用、数据、资金的安全性应当仅次于产品功能的准确性和使用体验。
-
-  安全问题的CodeReview可参见检查点清单：信息安全 。主要是如下措施：
-  1. 严格检查和屏蔽非法输入；
-  2. 对含敏感信息的请求加密通信；
-  3. 业务处理后消除任何敏感私密信息的任何痕迹；
-  4. 结果返回前在反序列化中清除敏感私密信息；
-  5. 敏感私密信息在数据存储设备中应当加密存储；
-  6. 应用有严格的角色、权限、操作、数据访问分级和控制；
-  7. 切忌暴露服务器的重要的安全性信息，防止服务器被攻击影响正常服务运行。
-
-#### 设计问题
-
-  设计问题通常体现在：
-  1. 是否有潜在的性能问题；
-  2. 是否有安全问题；
-  3. 业务变化时是否容易扩展；
-  4. 是否有遗漏的点。
-
-### 较轻微的问题
-
-  较轻微问题是指“没有技术难度、通过良好习惯即可避免的问题”。
-
-  较轻微问题一般不会造成负面影响的BUG或故障，不过建立一些好的习惯，主动使用代码检测工具，消除这些较轻微错误，也是一种修行。
-
-#### 命名不贴切
-
-  命名不贴切不会影响功能实现，却会误导理解或增加理解难度。
-
-  方法：先查查字典，找个通俗易懂而且比较贴近的名字。可以参考 jdk 的命名、通用词汇和行业词汇； 作用域小的采用短命名，作用域大的采用长命名。取名字是一种重要技能，—— 多少父母为此愁灰了头！
-
-#### 声明时未初始化
-
-  声明时未初始化通常情况下都不会是问题，因为后面会进行赋值。不过，如果赋值的过程中出现异常，那么可能会返回空值，从而导致空值异常。通常，变量声明时赋予默认初始值是个好习惯。
-
-#### 风格与整体有不一致
-
-  工程通常求稳，一致性能更好地维护。在工程项目中，最好能够遵循工程约定的风格，在个人项目中可以凸显个性风格。
-  Java编程一般要遵循《Java编程规范》，有追求的程序猿媛还会追求更高层次的，比如《Google Java 规范》等。
-
-#### 类型转换错误
-
-  编程语言的类型系统是非常重要的。如何在不同类型之间可靠地互转，尤其是在父子类型之间相互赋值，也是一个微技能。滥用类型转换，也会导致BUG 。
-
-  Java 中容易出现的错误是：
-  1. 字符串转数值，字符串含有非数字部分；
-  2. JSON字符串转对象，某个字段含有不兼容的值类型导致解析出错；
-  3. 子类型转不兼容的父类型，滋生运行时异常 ClassCastException；
-  4. 相同特质的类型不兼容。比如 Long 与 Integer 都是数值型，却不能互转。
-
-  类型转换中最容易出BUG的地方是非布尔类型取反。受C语言的影响，很多高级语言支持各种数据类型转布尔类型，比如 PHP 字符串、数组、数字等都可以转布尔类型，相应的就喜欢写 if (!notBoolVar) 这种表达式， 容易隐藏看不出的BUG甚至错误。
-
-#### 否定式风格
-
-  变量含义、表达式语句倾向于使用否定式风格，可能不知不觉耗费大量脑细胞，因为每次理解的时候都要绕个弯子。
-  比如 isNoExpress 是否无需物流， 就有点绕。 为什么呢？ 无需物流是针对快递发货的， 如果快递发货占发货的90%， 无需物流只占10%，那么, isNoExpress = false 几乎总为真。
-  涉及到判断的时候，可能不得不写 if (!isNoExpress) ， 双重否定足够弄晕你。
-
-#### 容器遍历的结构变更
-
-  绝大多数语言都承袭了 C 语言的 for(int i=0;i<N;i++) 循环形式。不过，现代编程语言通常都提供了迭代器遍历、或 foreach 遍历。
-  foreach 遍历通常基于迭代器遍历实现。 **只要对容器结构不做变更，推荐使用 foreach ；**
-  若要遍历的同时做修改或更新，**推荐迭代器模式**。
-  遍历容器的时候同时做删除元素操作，要特别留意，很可能导致越界错误。更可靠的方式时，直接生成新的容器，如果不涉及空间效率的话。
-
-#### API参数传递错误
-
-  如果API参数有多个，而且相邻参数的类型相同，那么要特别留意是否参数顺序是正确的，而不会张冠李戴。
-
-  当然，在设计API参数的时候，就可以仔细用更精准类型进行区分，并将相同类型的参数错开。
-  比如 calc(int accountNo, int pay, int timestamp) ， 就容易传错，比较可靠的是 calc(int accountNo, Currency pay, Timestamp now) ，这样是不可能将参数传递错误的。
-
-#### 单行调用括号过多
-
-  为了简便，常常会写出 wapper(calc(now, String.format(“%s\n”, new BufferedFileReader(filename, “UTF-8″).readLines() ))) 的语句 , 嗯，你得好好瞧瞧和算算右边的括号数量是否正确了。
-  更糟糕的时候，结合API参数传递错误，IDE 可能没有报错， 而你很可能没有意识到自己的参数传递错误了。
-  可靠的方式是， 拆出一部分变量，并将调用之间的括号用空格隔开，显示出层次感。
-  ``` java
-  String fileContent = new BufferedFileReader(filename, "UTF-8").readLines();
-  wapper( calc( now,  String.format("%s\n", fileContent) ) )
-  ```
-
-#### 修改方法签名
-
-  对某个方法有业务改动时，程序猿媛们倾向直接修改原方法的签名。这时，要特别注意：
-  1. 不要修改原方法的参数顺序；
-  2. 在最后面增加可选参数。
-
-  从另一个角度来看，复杂的业务方法应当分两层： 最外层负责调度，方法参数具有包容性，里面包含的字段比较多 ； 内层方法负责特定业务逻辑的实现，方法参数少而精。
-
-  修改原方法签名本身就是容易产生问题的习惯， 篡改原方法的参数顺序更是大忌。 最好的方法是新建一个方法去复用原方法， 然后调用新的方法。代码变更始终铭记“开闭”原则。
-
-#### 打印日志太多
-
-  打印过多的日志并不好。一方面遮掩真正需要的信息，导致排查耗费时间， 另一方面造成服务器空间浪费、影响性能。
-  生产环境日志一般只开放 INFO及以上级别的日志； Debug 日志只在调试或排错的时候使用，生产环境可以禁止debug日志。
-
-#### 多级数据结构
-
-  使用多级数据结构时，要确定父级数据一定有值，或者进行检测。
-  比如 $order['baole']['ump']['money']，必须确保 $order['baole'], $order['baole']['money'] 一定有值或做非空检测。
-
-#### 作用域过大
-
-  由于C语言的影响，猿媛们会在开头就定义好一些变量或要返回的对象，在很靠后的地方才使用到。
-  不必要的过大的作用域对变量和对象的变化产生不可测的影响，并增大理解的成本。可靠的方法是，仅当在使用时才定义，并尽快返回结果。
-
-  另一种情况是，暴露的访问域过大，比如 public 字段。 尽可能地缩小可访问的范围，可以增大变更和重构的空间； 减少可变性，则可以自然地获得并发安全性，降低CodeReview的理解成本。
-
-  比如，不可变的类和字段定义成 final ,
-  最小化包，类，接口，方法和域的可访问性，默认为 private ,
-  若需要继承，可定义为 protected , 仅当需要作为 API 服务暴露出去时，使用 public.
-
-#### 分支与循环
-
-  条件与循环偶尔也会导致错误， 不过通常错误可以在发布前解决掉。
-
-  对于 if-else 嵌套条件， 需要仔细检查是否符合业务逻辑； 如果嵌套太深，是否可以使用另一种方式“解结” ；
-  对于 switch 语句， 大多数语言的 case 有 fall through 问题， 要注意加上 break ； 最好加上 default 的处理。
-  对于 for 循环， 编写合理的结束条件避免死循环； 对于循环变量的控制， 避免出现 -1或 +1 错误， 消除越界错误； for 循环也要特别注意对空值和空容器的处理，避免抛出空值异常。可以通过单测来确保 for 循环的准确性。
+### 常见代码问题
+
+常见的潜在代码问题是当前直接会导致BUG、故障或者产品功能不能正常工作的类别。
+
+#### 空值
+  空值恐怕是最容易出现的地方之一。 常见错误有：
+  1. 值为NULL导致空指针异常；
+  2. 参数字符串含有前导或后缀空格没有Trim导致查询为空。
+
+  导致以上结果的原因主要有： **无此记录、有此记录但由于SQL访问异常而没查到、网络调用失败、记录中有脏数据、参数没传。**
+
+  原则上，对于任何异常， 希望能够打印出具体的错误信息，根据错误信息很快明白是什么原因， 而不是一个 null ，还要在代码里去推敲为什么为空。
+
+  这样我们必须识别出程序中可能的null， 并及时检测、捕获和抛出异常。
+
+  对于空值，最好的防护是 **防御式编程**。当获取到对象之后， 使用之前总是判断是否为空，并适当抛出异常、打错误日志或做其它处理。
+  有的人嫌检测为空的 if 语句充斥在代码里会破坏代码的可维护性， 对此我的建议是：
+
+  1. 空值检测一定要有， 有胜于无。
+  2. 在空值检测总是存在的前提下， 可以优化空值检测的方法和存在形式。 比如集中于一个类 NullChecker 中管理，并与系统的整体错误处理设计保持一致。集中管理和处理一致性原则可以作为系统设计的一个准则。 这样主流程中只要增加一行调用即可， 既可以天网恢恢疏而不漏地检测对象为空， 也不会让代码显得难看。
+  ```java
+  class NullChecker {
+     public static void checkNull(Object obj, Error error) {
+         if (obj == null)  { throw new BizException(error); }
+     }
+  }
+  ```
+  3. 在参数入口处统一做 trim。 如果在业务逻辑里做 trim ， 就会导致有的业务逻辑做了 trim ， 有的没做， 体现在产品上就会有令用户困惑的事情发生。 比如搜索和导出业务， 搜索能搜索出来， 导出却没有。
+
+#### 未捕获潜在的异常
+
+  第二个容易出错的地方是未捕获潜在的异常。
+  调用API接口、库函数或系统服务等，只顾着享受便利却不做防护，常导致因为局部失败而影响整体的功能。
+  最好的防护依然是 **防御式编程**。 要么在当前方法捕获异常并返回合适的空值或空对象，要么抛给高层处理。
+
+  切不可默默”吞掉错误和异常”。 如果这样做了， 出问题了等着加班和耗费大量脑细胞吧！
+  在CodeReview的时候一定要仔细询问：这里是否可能会抛出异常？如果抛异常会怎么处理？是否会影响整体服务和返回结果？
+
+#### 低性能
+
+  低性能会导致产品功能不好用、不可用，甚至导致产品失败。
+
+  常见情况有：
+  1. 循环地逐个调用单个接口获取数据或访问数据库;
+  2. 重复创建几乎完全相同的(开销大的)对象；
+  3. 数据库访问、网络调用等服务未处理超时的情况；
+  4. 多重循环对于大数据量处理的算法性能低；
+  5. 大量字符串拼接时使用了String而非StringBuilder.
+
+  对于 1，最好提供批量接口或批量并发获取数据；
+  对于 2, 将可复用对象抽离出循环，一次创建多次使用；
+  对于 3，设置合理的超时时间并捕获超时异常处理；
+  对于 4，使用预排序或预处理， 构造合适的数据结构， 使得算法平均性能在 O(n) 或 O(nlogn) ；
+  对于 5, 记住： 少量字符串拼接使用String, 大量字符串拼接使用 StringBuilder， 通常不会使用到 StringBuffer.
+
+#### 影响范围过大
+
+  对多个模块依赖的公共函数的修改，容易造成影响范围超过当前业务改动，无意识地破坏依赖于该公共函数的其他业务。要特别慎重。
+  可靠的方式是：先查看该公共函数的调用， 如果只有自己的业务用，可适当大胆一些； 如果有多个地方依赖，抽离一个新的函数，抽离原函数里的可复用部分，然后基于可复用部分构建新的函数。
+  修改原则遵循 **“开闭”原则**，才能尽可能使改动影响降低到最小化。
+
+  基类及实例字段和方法也属于公共函数的范畴。 尽量不要修改基类的东西。
+
+#### 单测问题
+
+  单测是保证工程质量的第一道重要防线。单测问题一般包括：
+  1. 单测未全部通过；
+  2. 重要业务逻辑缺乏单测；
+  3. 缺乏异常单测；
+  4. 代码变更或BUG修复缺乏单测。
+
+  单测全部通过应当是提交代码到代码库以及代码Review的前提条件。
+  代码提交者应当保证单测全部通过。没有捷径可走。仅当单测全部通过才提交到代码库， 可以通过工具自动化实现。
+  对于 maven 管理的工程， 只需一个命令： mvn test && git push origin branch_name 。
+  单测应当更注重质，而非单纯追求覆盖率。
+
+  缺乏单测的重要业务逻辑就像裸露在空气中的电线一样，虽然能跑起来，却是很容易“触电”的。 方法： 增加覆盖比较全面的单测。
+
+  缺乏异常单测也是代码提交者常忽略的问题。 异常也是一种实际的业务场景，反映系统的健壮性和友好性。异常应该有相应的单元测试覆盖。创建条件使之抛出异常，并判断异常是否是指定异常；若没有抛出异常或者不是指定异常，则应该 AssertFailed 而不是通过。
+
+  对于代码变更和BUG修复，如果当时由于时间紧而没有写，后续应当补上。对于每个代码变更和BUG，都可以抽离出相应的代码部分， 并有相应单测覆盖，并注明原因。
+
+#### 与原有业务逻辑不兼容
+
+  改动针对当前需求是合理的，却与原有业务逻辑不兼容，也是常见的问题。比如增加一个搜索条件， 却不能与原有条件联合查询。
+  与原有业务不兼容， 一般出现在：
+
+  1. 一对一与一对多的变化。 比如原来的关系是一个订单对应一个物流信息， 后来变化为一个订单可能对应多个物流信息； 原来的逻辑是一个订单显示多个物流信息可以更改，后来要求一个订单只展示最近一次的物流信息可以修改。
+  2. 多个业务组合。 业务 A 与业务 B 原来是分开发展的， 后来开展一种活动，将业务A与业务B进行一种组合营销。 此时，多半会出现很多 if-else 语句。
+  业务逻辑的兼容问题一般体现在系统的复用性和可扩展机制上。良好的系统可复用性和可扩展性可以更容易地做到业务逻辑兼容。
+
+  主要有如下几种级别：
+
+  1. 自动兼容。 增加一种类型， 只是 biz_type 的值多了一种， 系统自动将已有功能适配给新的 biz_type；
+  2. 一点改动。增加一个分支语句， 对 biz_type 的某个特性进行扩展；
+  3. 一些改动。 需要见缝插针地增加一个单独的分支判断和逻辑处理模块， 对整体可扩展性没有影响， 但会造成局部的复杂化；
+  4. 一部分功能改动。 只需要对其中一个功能模块做个扩展；
+  5. 多处改动。 需要对多个功能模块做相应的改造，不过更多是新增而不是修改；
+  6. 难以改动。 需要深入到功能模块内部做艰难的修改， 并要保证原有功能不受影响。
+
+  如何应对呢？
+
+  1. 针对关联关系， 在项目之初， 可以询问清楚： 将来在产品上是否有可扩展的变化？ 及早预留空间， 或者确定产品上的对策； 在代码实现上， 兼顾考虑一对一到一对多，或一对多到一对一的关联变化。比如使用列表来表达单个信息， 使用索引从列表中获取单个信息。
+  2. 针对业务组合， 明确各业务的核心部分， 抽离出业务的可复用的部分，形成 API ； 考虑组合模式和装饰器模式来进行扩展。
+  核心不变， 外围定制化。
+
+#### 缺乏必要日志
+
+  对于重要而关键的实例状态、代码路径及API调用，应当添加适当的`INFO`日志；
+  对于异常，应当捕获并添加`Error`日志。
+  缺乏日志并不会影响业务功能，但出现问题排查时，就会非常不方便，甚至错失极宝贵的机会(不易重现的情况尤其如此)。
+  此外，缺乏日志也会导致可控性差，难以做数据统计和分析。
+
+#### 错误码不符合规范
+
+  错误码本身不算是代码问题，不过基于整个组织和工程的可维护性来说，可以将错误码不符合规范作为一种错误加以避免。
+  方法：
+  对错误码进行可控的管理和遵循规范使用。
+  可以使用公共文档维护， 也可以开发错误码管理系统来避免相同的错误码。
+
+#### 参数检测缺乏或不足
+
+  参数检测是对业务处理的第一层重要过滤。
+  如果参数检测不足够，就会导致脏数据进入服务处理，轻则导致异常，重则插入脏数据到数据库，对后续维护都会造成很多维护成本。
+  方法： 采用 **“契约式编程”**，规定前置条件，并使用单测进行覆盖。
+
+  对于复杂的业务应用， 优雅的参数检测处理尤为重要。 根据 “集中管理和处理一致性原则”， 可以建立一个 paramchecker 包， 设计一个可复用的微框架来对应用中所有的参数进行统一集中化检测。
+  参数检测主要包括：
+  1. 参数的值类型， 可以根据不同值类型做基础的检测；
+  2. 参数的业务类型， 有基础非业务参数， 基础业务参数和具体业务参数。 不同的参数业务类型有不同的处理。 将参数值类型与参数业务类型结合起来， 结合一致性的异常捕获处理， 就可以实现一个可复用的参数检测框架。参数检测既可以采用普通的分支语句，也可以采用注解方式。采用注解方式更可读，不过单测编写更具技巧。
+
+#### 引用错误
+
+  对于动态语言， 由于缺乏强大的静态代码检测，修改了类引用的地方尤其要注意，很可能导致依赖的其他业务出错； 尤其是修改重名引用时。
+  有线上故障教训。PHP工程中含有两个 Format 类， 一个基础的一个业务相关的， 被改动的类文件里开始没有指明引用，默认采用了基础 Format 类的实现， 然后提交者在改动文件头增加了对业务 Format 的引用， 导致依赖于基础Format类的其他业务不能正常工作。
+  避免引用错误的方法：
+  当要在文件里增加新的类引用时， 先在文件里搜索是否有重名类的引用。如果有， 就要格外小心了。
+
+#### 细节错误
+
+  比如数组越界、JSON解析出错、函数参数传递出错、API 版本不对、使用网上拷贝的未经测试的代码、不成熟的算法、传值与传引用、相等性比较等。
+
+  对于数组越界错误， 通常要对空数组、针对数组大小的边界值+1和-1写单测来避免；
+  使用网上拷贝的代码，诚然可节省时间，也一定要加工一下并用单测覆盖；
+  传值和传引用可通过单测来避免错误；
+  对象的相等性比较切忌使用等号=。
+
+#### 多重条件
+
+  类似 if ((!A || !B) && C || (D && E)) 的多重条件要仔细推敲。
+  方法：
+  最好拆分成多个有含义变量。
+  ```
+  isNotDelay = !A || !B ;
+  isNormal = C ;
+  isAllow = D && E ;
+  cond = isNotDelay && isNormal || isAllow 。
+  ```
+
+#### 文不符实
+
+  文不符实是一种可能导致线上故障的错误。
+  比如一个 getXXX 的函数，结果里面还做了 add, update 的操作。
+  对问题排查、产品运维等都有非常大的杀伤力。因此命名一定要用实质内容相符，除非是故意搞破坏。
+
+#### 跨语言或跨系统交互
+
+  稍具规模的互联网创业公司通常会采用多语言开发，比如PHP作为前端，Java作为后台服务。
+  当动态类型语言与静态类型语言交互时，会有一些问题产生。
+  比如PHP的对象通常是一个Map, 如果是空对象就会写成 [], 然而 [] 会被 Java 解析成列表。
+  这样， 如果数据库的值是通过 PHP 写入，那么这个值既有可能是JSON对象字符串，也可能是空数组字符串， Java 来解析就有点尴尬了。
+  同样，当 Java 调用 PHP 接口时， 不规范的PHP接口既可能返回列表，也可能返回 true or false ， Java 解析返回结果也会比较尴尬。
+  因此， 在跨语言交互的边界处，要特别注意这些类型转换的差异。
+
+  跨系统交互则主要是接口设计与约定的问题。同一个项目里不同业务团队之间的业务接口设计与约定， 不同企业里开放接口的设计与约定， 要在最初深思熟虑，一旦开放，在后期很少有接口设计改动的空间。
+  开放接口设计要符合小而美、正交的特性， 命名要贴切一致， 参数取值要指明约束，枚举参数要给出列表， 结果返回要规范一致，可以采用通用的 {“code”:200, “msg”: “success”, “data”: xxx} 。
+  跨系统交互也要统一对术语和接口的理解的一致。
+
+#### 可维护性问题
+
+  可维护性问题是“在当前业务变更的范围内通常不会导致BUG、故障，却会在日后埋下地雷，引发BUG、故障、维护成本大幅增加”的类别。
+
+#### 硬编码
+
+  硬编码主要有三种情况：
+  1. “魔数”；
+  2. 写死的配置；
+  3. 临时加的逻辑和文案。
+
+  “魔数”与重复代码类似，当前或许不会引发问题，时间一长，为了弄清楚其代表的含义，增加很多沟通维护成本，且分散在各处很容易导致修改的时候遗漏不一致。务必清清除。
+  方法也比较简单：定义含义明显的枚举或常量，代表这个魔数在代码中发言。
+
+  “写死的配置”不会影响业务功能， 不过在环境变更或系统调优的时候，就显得很不方便了。 方法： 尽量将配置抽离出来做成配置项放到配置文件里。
+
+  “临时加的逻辑和文案”也是一种破坏系统可维护性的做法。方法： 抽离出来放在单独的函数或方法里，并特别加以注释。
+
+#### 重复代码
+
+  重复代码在当前可能不会造成 BUG，但上线后，需要维护多处的事实一致性；时间一长，后续修改的时候就特别容易遗漏或处理不一致导致 BUG；重复代码是公认的“代码坏味”，必当尽力清除。
+  方法： **抽离通用的部分，定制差异。** 重复代码还有一种情况出现，即创造新函数时，先看看是否既有方法已经实现过。
+
+  通用逻辑与定制业务逻辑耦合
+  这大概是每个媛猿们在开发生涯中遇到的最恶心的事情之一了。通用逻辑与具体的各种业务逻辑混杂交错，想插根针都难。遇到这种情况，只能先祈福，然后抽离一个新的函数，严格判断相应条件满足后去调用它。
+
+  如果是新创建逻辑，可以使用函数式编程或基于接口的编程，将通用处理流程抽离出来，而将具体业务逻辑以回调函数的形式传入处理。
+
+  不要让不同的业务共用相同的函数，然后在函数里一堆 if-else plus switch ， 而是每个业务都有各自的函数， 并可复用相同的通用逻辑和流程处理； 或者各个业务可以覆写同样命名的函数。
+
+  复用，而非混杂。
+
+#### 直接在原方法里加逻辑
+
+  有业务改动时，猿媛们图方便倾向于直接在原方法里加判断和逻辑。这样做是很不好的习惯。
+  一方面，增加了原方法的长度，破坏了其可维护性；
+  另一方面，有可能对原方法的既有逻辑造成破坏。
+  可靠的方式是： **新增一个函数，然后在原方法中调用并说明原因。**
+
+#### 多业务耦合
+
+  在业务边界未仔细划分清晰的情况下出现，一个业务过多深入和掺杂另一个非相关业务的实现细节。
+  在项目和系统设计之初，特别要注意先划分业务边界，定义好接口设计和服务依赖关系，
+  再着手开发；否则，延迟到后期做这些工作，很可能会导致重复的工作量，含糊复杂的交互、增加后期系统维护和问题排查的许多成本。磨刀不误砍柴工。
+  划分清晰的业务、服务、接口边界就属于磨刀的功夫。
+
+#### 代码层次不合理
+
+  代码改动逻辑是正确的，然而代码的放置位置不符合当前架构设计约定，导致后续维护成本增加。
+
+  代码层次不合理可能导致重复代码。
+  比如获取操作人和操作记录，如果写在类 XController 里， 那么类 YController 就面临尴尬局面： 如果写在 YController ， 就会导致重复代码；
+  如果跨层去调用 XController 方法，又是非常不推荐的做法。
+  因此， 获取操作人和操作记录，最好写在 Service 层，
+  Controller 层只负责参数传入、检测和结果转译、返回。
+
+#### 不用多余的代码
+
+  工程中常常会有一些不用的代码。
+  或者是一些暂时未用到的Util工具或库函数，或者是由于业务变更导致已经废弃不用的代码，或者是由于一时写出后来又重写的代码。
+  尽量清除掉不用多余的代码，对系统可维护性是一种很好的改善，同时也有利于CodeReview。
+
+#### 使用全局变量
+
+  使用全局变量并没有“错”，错的是，一旦出现问题，排查和调试问题起来，真的会让人“一夜之间白了头”，耗费数个小时是轻微惩罚。
+  此外，全局变量还能“顺手牵羊”地破坏函数的通用性，导致可维护性变差。
+  务必消除全局变量的使用。当然，全局常量是可以的。
+
+#### 缺乏必要的注释
+
+  对重要和关键点的代码缺乏必要的注释，使用到的重要算法缺乏必要的引用出处，对特别的处理缺乏必要的说明。
+
+  原则上， 每个方法至少要用一个简短的单行注释， 适宜地描述了方法的用途、业务逻辑、作者及日期。对于特殊甚至奇葩的需求的特别实现，要加一些注释。 这样后续维护时有个基础。
+
+#### 更难发现的错误
+
+  更难发现的错误是指“复杂并发场景下的有一定技术难度的、需要丰富开发与设计经验才能看出来的错误”。
+
+#### 并发
+
+  并发的问题更难检测、复现和调试。常见的问题有：
+  1. 在可能由多线程并发访问的对象中含有共享变量却没有同步保护；
+  2. 在代码中手动创建缺乏控制的线程或线程池；
+  3. 并发访问数据库时没有做任何同步措施；
+  4. 多个线程对同一对象的互斥操作没有同步保护。
+
+  对于 1, 在大部分Java应用中，通常由Spring框架来控制和创建请求和服务实例，因此，保证 **“Controller, Service 类中的实例变量只允许 Service, DAO 的单例，不允许业务变量实例”** 基本确保没有并发不正确更新的问题；不过，包含缓存策略的对象要特别注意多线程并发访问的问题，出于性能考量， 尽量只对共享实例部分加锁。
+
+  对于 2, 禁止在应用中手动创建线程或线程池，失控的线程池很容易导致应用崩溃(有线上应用崩溃的教训)。
+
+  对于 3, 并发访问数据库时，要特别注意时序和状态同步。如果时序控制不对，会导致状态同步和更新出错。
+
+  对于 4, 对同一对象的互斥操作需要加分布式锁同步。
+
+  使用线程池、并发库、并发类、同步工具而不是线程对象、并发原语。在复杂并发场景下，还需注意多个同步对象上的锁是否按合适的顺序获得和释放以避免死锁，相应的错误处理代码是否合理。
+
+#### 事务
+
+  事务方面常出现的问题是：多个紧密关联的业务操作和 SQL 语句没有事务保证。 在资金业务操作或数据强一致性要求的业务操作中，要注意使用事务，保证数据更新的一致性和完整性。
+
+#### SQL问题
+
+  SQL的正确性通常可以通过 DAO 测试来保证。 SQL问题主要是指潜在的性能问题和安全问题。
+
+  要避免SQL性能问题， 在表设计的时候就要做好索引工作。
+
+  在表数据量非常大的情况下，SQL语句编写要非常小心。
+
+  查询SQL需要添加必要索引，添加合适的查询条件和查询顺序，加快查询效率， 避免慢查； 尽量避免使用 Join, 子查询；避免SQL注入。
+
+  SQL优秀书籍推荐： 《SQL语言艺术》
+
+#### 安全问题
+
+  安全问题一向是互联网产品研发中极容易被忽视、而在爆发后又极引发热议的议题。安全和隐私是用户的心理红线之一。应用、数据、资金的安全性应当仅次于产品功能的准确性和使用体验。
+
+  安全问题的CodeReview可参见检查点清单：信息安全 。主要是如下措施：
+  1. 严格检查和屏蔽非法输入；
+  2. 对含敏感信息的请求加密通信；
+  3. 业务处理后消除任何敏感私密信息的任何痕迹；
+  4. 结果返回前在反序列化中清除敏感私密信息；
+  5. 敏感私密信息在数据存储设备中应当加密存储；
+  6. 应用有严格的角色、权限、操作、数据访问分级和控制；
+  7. 切忌暴露服务器的重要的安全性信息，防止服务器被攻击影响正常服务运行。
+
+#### 设计问题
+
+  设计问题通常体现在：
+  1. 是否有潜在的性能问题；
+  2. 是否有安全问题；
+  3. 业务变化时是否容易扩展；
+  4. 是否有遗漏的点。
+
+### 较轻微的问题
+
+  较轻微问题是指“没有技术难度、通过良好习惯即可避免的问题”。
+
+  较轻微问题一般不会造成负面影响的BUG或故障，不过建立一些好的习惯，主动使用代码检测工具，消除这些较轻微错误，也是一种修行。
+
+#### 命名不贴切
+
+  命名不贴切不会影响功能实现，却会误导理解或增加理解难度。
+
+  方法：先查查字典，找个通俗易懂而且比较贴近的名字。可以参考 jdk 的命名、通用词汇和行业词汇； 作用域小的采用短命名，作用域大的采用长命名。取名字是一种重要技能，—— 多少父母为此愁灰了头！
+
+#### 声明时未初始化
+
+  声明时未初始化通常情况下都不会是问题，因为后面会进行赋值。不过，如果赋值的过程中出现异常，那么可能会返回空值，从而导致空值异常。通常，变量声明时赋予默认初始值是个好习惯。
+
+#### 风格与整体有不一致
+
+  工程通常求稳，一致性能更好地维护。在工程项目中，最好能够遵循工程约定的风格，在个人项目中可以凸显个性风格。
+  Java编程一般要遵循《Java编程规范》，有追求的程序猿媛还会追求更高层次的，比如《Google Java 规范》等。
+
+#### 类型转换错误
+
+  编程语言的类型系统是非常重要的。如何在不同类型之间可靠地互转，尤其是在父子类型之间相互赋值，也是一个微技能。滥用类型转换，也会导致BUG 。
+
+  Java 中容易出现的错误是：
+  1. 字符串转数值，字符串含有非数字部分；
+  2. JSON字符串转对象，某个字段含有不兼容的值类型导致解析出错；
+  3. 子类型转不兼容的父类型，滋生运行时异常 ClassCastException；
+  4. 相同特质的类型不兼容。比如 Long 与 Integer 都是数值型，却不能互转。
+
+  类型转换中最容易出BUG的地方是非布尔类型取反。受C语言的影响，很多高级语言支持各种数据类型转布尔类型，比如 PHP 字符串、数组、数字等都可以转布尔类型，相应的就喜欢写 if (!notBoolVar) 这种表达式， 容易隐藏看不出的BUG甚至错误。
+
+#### 否定式风格
+
+  变量含义、表达式语句倾向于使用否定式风格，可能不知不觉耗费大量脑细胞，因为每次理解的时候都要绕个弯子。
+  比如 isNoExpress 是否无需物流， 就有点绕。 为什么呢？ 无需物流是针对快递发货的， 如果快递发货占发货的90%， 无需物流只占10%，那么, isNoExpress = false 几乎总为真。
+  涉及到判断的时候，可能不得不写 if (!isNoExpress) ， 双重否定足够弄晕你。
+
+#### 容器遍历的结构变更
+
+  绝大多数语言都承袭了 C 语言的 for(int i=0;i<N;i++) 循环形式。不过，现代编程语言通常都提供了迭代器遍历、或 foreach 遍历。
+  foreach 遍历通常基于迭代器遍历实现。 **只要对容器结构不做变更，推荐使用 foreach ；**
+  若要遍历的同时做修改或更新，**推荐迭代器模式**。
+  遍历容器的时候同时做删除元素操作，要特别留意，很可能导致越界错误。更可靠的方式时，直接生成新的容器，如果不涉及空间效率的话。
+
+#### API参数传递错误
+
+  如果API参数有多个，而且相邻参数的类型相同，那么要特别留意是否参数顺序是正确的，而不会张冠李戴。
+
+  当然，在设计API参数的时候，就可以仔细用更精准类型进行区分，并将相同类型的参数错开。
+  比如 calc(int accountNo, int pay, int timestamp) ， 就容易传错，比较可靠的是 calc(int accountNo, Currency pay, Timestamp now) ，这样是不可能将参数传递错误的。
+
+#### 单行调用括号过多
+
+  为了简便，常常会写出 wapper(calc(now, String.format(“%s\n”, new BufferedFileReader(filename, “UTF-8″).readLines() ))) 的语句 , 嗯，你得好好瞧瞧和算算右边的括号数量是否正确了。
+  更糟糕的时候，结合API参数传递错误，IDE 可能没有报错， 而你很可能没有意识到自己的参数传递错误了。
+  可靠的方式是， 拆出一部分变量，并将调用之间的括号用空格隔开，显示出层次感。
+  ``` java
+  String fileContent = new BufferedFileReader(filename, "UTF-8").readLines();
+  wapper( calc( now,  String.format("%s\n", fileContent) ) )
+  ```
+
+#### 修改方法签名
+
+  对某个方法有业务改动时，程序猿媛们倾向直接修改原方法的签名。这时，要特别注意：
+  1. 不要修改原方法的参数顺序；
+  2. 在最后面增加可选参数。
+
+  从另一个角度来看，复杂的业务方法应当分两层： 最外层负责调度，方法参数具有包容性，里面包含的字段比较多 ； 内层方法负责特定业务逻辑的实现，方法参数少而精。
+
+  修改原方法签名本身就是容易产生问题的习惯， 篡改原方法的参数顺序更是大忌。 最好的方法是新建一个方法去复用原方法， 然后调用新的方法。代码变更始终铭记“开闭”原则。
+
+#### 打印日志太多
+
+  打印过多的日志并不好。一方面遮掩真正需要的信息，导致排查耗费时间， 另一方面造成服务器空间浪费、影响性能。
+  生产环境日志一般只开放 INFO及以上级别的日志； Debug 日志只在调试或排错的时候使用，生产环境可以禁止debug日志。
+
+#### 多级数据结构
+
+  使用多级数据结构时，要确定父级数据一定有值，或者进行检测。
+  比如 $order['baole']['ump']['money']，必须确保 $order['baole'], $order['baole']['money'] 一定有值或做非空检测。
+
+#### 作用域过大
+
+  由于C语言的影响，猿媛们会在开头就定义好一些变量或要返回的对象，在很靠后的地方才使用到。
+  不必要的过大的作用域对变量和对象的变化产生不可测的影响，并增大理解的成本。可靠的方法是，仅当在使用时才定义，并尽快返回结果。
+
+  另一种情况是，暴露的访问域过大，比如 public 字段。 尽可能地缩小可访问的范围，可以增大变更和重构的空间； 减少可变性，则可以自然地获得并发安全性，降低CodeReview的理解成本。
+
+  比如，不可变的类和字段定义成 final ,
+  最小化包，类，接口，方法和域的可访问性，默认为 private ,
+  若需要继承，可定义为 protected , 仅当需要作为 API 服务暴露出去时，使用 public.
+
+#### 分支与循环
+
+  条件与循环偶尔也会导致错误， 不过通常错误可以在发布前解决掉。
+
+  对于 if-else 嵌套条件， 需要仔细检查是否符合业务逻辑； 如果嵌套太深，是否可以使用另一种方式“解结” ；
+  对于 switch 语句， 大多数语言的 case 有 fall through 问题， 要注意加上 break ； 最好加上 default 的处理。
+  对于 for 循环， 编写合理的结束条件避免死循环； 对于循环变量的控制， 避免出现 -1或 +1 错误， 消除越界错误； for 循环也要特别注意对空值和空容器的处理，避免抛出空值异常。可以通过单测来确保 for 循环的准确性。
diff --git "a/12 - Practice (problems encountered during development)/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.png" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.png"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.png"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/CodeReview\345\270\270\350\247\201\344\273\243\347\240\201\351\227\256\351\242\230.png"
diff --git "a/12 - Practice (problems encountered during development)/Multiple markers at this line @Override\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Multiple markers at this line @Override\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/Multiple markers at this line @Override\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Multiple markers at this line @Override\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"
index 993f2e22..e912b649 100644
--- "a/12 - Practice (problems encountered during development)/Multiple markers at this line @Override\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Multiple markers at this line @Override\347\232\204\350\247\243\345\206\263\346\226\271\346\263\225.md"	
@@ -1,15 +1,15 @@
-使用Eclipse 进行项目开发，在实现类中的方法前面如果添加@Override就提示“Multiple markers at this line”的错误，问题描述如下
-
-Multiple markers at this line
-	- The method getSecurityByKey(String) of type SecurityServiceImpl must override a superclass
-	 method
-	- implements com.dearbinge.data.api.SecurityService.getSecurityByKey
-
-
-出现上述问题的原因：JDK1.5不支持这种写法。实现接口方法需要重写抽象方法。
-解决上述问题的方法如下：
-方法1.选择Eclipse的Window→Preferences→Java→Compiler，把Compiler compliance level从1.5改成1.6。
-
-方法2.右击project选择最后一个properties选择左侧的java compiler,勾选里面的框框，把java编辑器版本都改成1.6。
-
-方法3.右击project下的 JRE System Library[JavaSE-1.5]→Properties,Execution environment 选择“JavaSE-1.6(JDK1.6.0_10)”,点击确定即可。
+使用Eclipse 进行项目开发，在实现类中的方法前面如果添加@Override就提示“Multiple markers at this line”的错误，问题描述如下
+
+Multiple markers at this line
+	- The method getSecurityByKey(String) of type SecurityServiceImpl must override a superclass
+	 method
+	- implements com.dearbinge.data.api.SecurityService.getSecurityByKey
+
+
+出现上述问题的原因：JDK1.5不支持这种写法。实现接口方法需要重写抽象方法。
+解决上述问题的方法如下：
+方法1.选择Eclipse的Window→Preferences→Java→Compiler，把Compiler compliance level从1.5改成1.6。
+
+方法2.右击project选择最后一个properties选择左侧的java compiler,勾选里面的框框，把java编辑器版本都改成1.6。
+
+方法3.右击project下的 JRE System Library[JavaSE-1.5]→Properties,Execution environment 选择“JavaSE-1.6(JDK1.6.0_10)”,点击确定即可。
diff --git "a/12 - Practice (problems encountered during development)/Mybatis \345\244\232\344\270\252delete\350\257\255\345\217\245.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Mybatis \345\244\232\344\270\252delete\350\257\255\345\217\245.txt"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/Mybatis \345\244\232\344\270\252delete\350\257\255\345\217\245.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Mybatis \345\244\232\344\270\252delete\350\257\255\345\217\245.txt"
diff --git a/12 - Practice (problems encountered during development)/ServletContextListener.txt "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/ServletContextListener.txt"
similarity index 97%
rename from 12 - Practice (problems encountered during development)/ServletContextListener.txt
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/ServletContextListener.txt"
index f9ae8151..5f7b7738 100644
--- a/12 - Practice (problems encountered during development)/ServletContextListener.txt	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/ServletContextListener.txt"	
@@ -1,52 +1,52 @@
-  
-  ServletContextListener是对ServeltContext的一个监听.
-  servelt容器启动,serveltContextListener就会调用contextInitialized方法.在方法里面调用event.getServletContext()可以获取ServletContext,
-  ServeltContext是一个上下文对象,他的数据供所有的应用程序共享,进行一些业务的初始化
-  
-  servelt容器关闭,serveltContextListener就会调用contextDestroyed.
-
-  实际上ServeltContextListener是生成ServeltContext对象之后调用的.
-  生成ServeltContext对象之后,这些代码在我们业务实现之前就写好,它怎么知道我们生成类的名字.
-  实际上它并不需要知道我们的类名,类里面有是方法.他们提供一个规范,就一个接口,ServeltContextListner,只要继承这个接口就必须实现这个方法.
-  然后这个类在web.xml中Listener节点配置好.Servelt容器先解析web.xml,获取Listener的值.通过反射生成对象放进缓存.
-  然后创建ServeltContext对象和ServletContextEvent对象.然后在调用ServletContextListener的contextInitialized方法,然后方法可以把用户的业务需求写进去.
-  struts和spring框架就是类似这样的实现,我们以后写一些框架也可以在用.
-
-java代码
-
-package com.chen;
- 
-import javax.servlet.ServletContext;
-import javax.servlet.ServletContextEvent;
-import javax.servlet.ServletContextListener;
- 
-public class MyServletContextListener implements ServletContextListener{
- 
-    @Override
-    public void contextDestroyed(ServletContextEvent arg0) {
-        System.out.println("destroyed");
-    }
- 
-    @Override
-    public void contextInitialized(ServletContextEvent event) {
-        System.out.println("initialized");
-        event.getServletContext().setAttribute("user", "admin");
-         
-    }
- 
-}
-
-xml配置
-
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
-  <display-name>oa</display-name>
- 
-  <listener>
-    <listener-class>com.chen.MyServletContextListener</listener-class>
-  </listener>
- 
-  <welcome-file-list>
-    <welcome-file>index.html</welcome-file>
-  </welcome-file-list>
+  
+  ServletContextListener是对ServeltContext的一个监听.
+  servelt容器启动,serveltContextListener就会调用contextInitialized方法.在方法里面调用event.getServletContext()可以获取ServletContext,
+  ServeltContext是一个上下文对象,他的数据供所有的应用程序共享,进行一些业务的初始化
+  
+  servelt容器关闭,serveltContextListener就会调用contextDestroyed.
+
+  实际上ServeltContextListener是生成ServeltContext对象之后调用的.
+  生成ServeltContext对象之后,这些代码在我们业务实现之前就写好,它怎么知道我们生成类的名字.
+  实际上它并不需要知道我们的类名,类里面有是方法.他们提供一个规范,就一个接口,ServeltContextListner,只要继承这个接口就必须实现这个方法.
+  然后这个类在web.xml中Listener节点配置好.Servelt容器先解析web.xml,获取Listener的值.通过反射生成对象放进缓存.
+  然后创建ServeltContext对象和ServletContextEvent对象.然后在调用ServletContextListener的contextInitialized方法,然后方法可以把用户的业务需求写进去.
+  struts和spring框架就是类似这样的实现,我们以后写一些框架也可以在用.
+
+java代码
+
+package com.chen;
+ 
+import javax.servlet.ServletContext;
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletContextListener;
+ 
+public class MyServletContextListener implements ServletContextListener{
+ 
+    @Override
+    public void contextDestroyed(ServletContextEvent arg0) {
+        System.out.println("destroyed");
+    }
+ 
+    @Override
+    public void contextInitialized(ServletContextEvent event) {
+        System.out.println("initialized");
+        event.getServletContext().setAttribute("user", "admin");
+         
+    }
+ 
+}
+
+xml配置
+
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
+  <display-name>oa</display-name>
+ 
+  <listener>
+    <listener-class>com.chen.MyServletContextListener</listener-class>
+  </listener>
+ 
+  <welcome-file-list>
+    <welcome-file>index.html</welcome-file>
+  </welcome-file-list>
 </web-app>
\ No newline at end of file
diff --git a/12 - Practice (problems encountered during development)/Unsupported major.minor version 52.0 error.txt "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Unsupported major.minor version 52.0 error.txt"
similarity index 98%
rename from 12 - Practice (problems encountered during development)/Unsupported major.minor version 52.0 error.txt
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Unsupported major.minor version 52.0 error.txt"
index 9b8bb8b7..5847ada3 100644
--- a/12 - Practice (problems encountered during development)/Unsupported major.minor version 52.0 error.txt	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/Unsupported major.minor version 52.0 error.txt"	
@@ -1,34 +1,34 @@
-
-http://blog.csdn.net/pipisorry/article/details/42965435
-
-Unsupported major.minor version 52.0 error
-
-在eclipse中开发的项目有个java build path中可以配置的jdk，
-还有个java compiler中可以配置compiler level{eclipse>windows>preferences>java>compiler>compiler compliance level}
-
-
-build path的JDK版本是你开发的时候编译器需要使用到的，在eclipse中开发代码，给提示报错的，编译的过程；
-
-java compiler compliance level中配置的编译版本号，这个编译版本号的作用是，你这个项目将来开发完毕之后，要放到服务器上运行，那个服务器上JDK的运行版本。
-
-build path中配置1.7的JDK，java compiler compliance level中配置的1.7，但是程序运行需要的是1.8的JDK，就报了那个错误
-
-
-build path的JDK版本是你开发的时候编译器需要使用到的，例如用的JDK1.4就不能使用泛型。
-而java compiler compliance level设置的是你写好的JAVA代码按照什么JDK版本级别编译，
-例如：设置的是1.4，编译出来的class文件可以在1.4以上的JRE上运行，如果用的是5.0级别编译，就不能运行在1.4的环境里面。
-
-
-在eclipse中进行开发的时候，build path 中JDK进行类库的编译（就是你使用类在不在这个JDK中),
-java compiler compliance level是对这个项目语法的编译（就是你的项目中语法的正确与否），
-在开发的过程中，这两个地方是都起作用的。所以说，build path 和 java complier compliance level和服务器配置的JDK保持一致，就不会出现任何问题的。
-
-
-J2SE 8 = 52,
-J2SE 7 = 51,
-J2SE 6.0 = 50,
-J2SE 5.0 = 49,
-JDK 1.4 = 48,
-JDK 1.3 = 47,
-JDK 1.2 = 46,
-JDK 1.1 = 45
+
+http://blog.csdn.net/pipisorry/article/details/42965435
+
+Unsupported major.minor version 52.0 error
+
+在eclipse中开发的项目有个java build path中可以配置的jdk，
+还有个java compiler中可以配置compiler level{eclipse>windows>preferences>java>compiler>compiler compliance level}
+
+
+build path的JDK版本是你开发的时候编译器需要使用到的，在eclipse中开发代码，给提示报错的，编译的过程；
+
+java compiler compliance level中配置的编译版本号，这个编译版本号的作用是，你这个项目将来开发完毕之后，要放到服务器上运行，那个服务器上JDK的运行版本。
+
+build path中配置1.7的JDK，java compiler compliance level中配置的1.7，但是程序运行需要的是1.8的JDK，就报了那个错误
+
+
+build path的JDK版本是你开发的时候编译器需要使用到的，例如用的JDK1.4就不能使用泛型。
+而java compiler compliance level设置的是你写好的JAVA代码按照什么JDK版本级别编译，
+例如：设置的是1.4，编译出来的class文件可以在1.4以上的JRE上运行，如果用的是5.0级别编译，就不能运行在1.4的环境里面。
+
+
+在eclipse中进行开发的时候，build path 中JDK进行类库的编译（就是你使用类在不在这个JDK中),
+java compiler compliance level是对这个项目语法的编译（就是你的项目中语法的正确与否），
+在开发的过程中，这两个地方是都起作用的。所以说，build path 和 java complier compliance level和服务器配置的JDK保持一致，就不会出现任何问题的。
+
+
+J2SE 8 = 52,
+J2SE 7 = 51,
+J2SE 6.0 = 50,
+J2SE 5.0 = 49,
+JDK 1.4 = 48,
+JDK 1.3 = 47,
+JDK 1.2 = 46,
+JDK 1.1 = 45
diff --git a/12 - Practice (problems encountered during development)/es can not run elasticsearch as root.txt "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/es can not run elasticsearch as root.txt"
similarity index 100%
rename from 12 - Practice (problems encountered during development)/es can not run elasticsearch as root.txt
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/es can not run elasticsearch as root.txt"
diff --git "a/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/idea class\346\211\276\344\270\215\345\210\260.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/idea class\346\211\276\344\270\215\345\210\260.md"
new file mode 100644
index 00000000..175831df
--- /dev/null
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/idea class\346\211\276\344\270\215\345\210\260.md"	
@@ -0,0 +1,6 @@
+问题
+使用Intellij IDEA 的class搜索工具搜索不到项目中的类，但是类就在构建的项目中。关闭Intellij IDEA再打开也不起作用。
+
+解决
+
+File -> Invalidate Caches / Restart -> Invalidate and Restart
diff --git "a/12 - Practice (problems encountered during development)/java \350\277\234\347\250\213redis.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/java \350\277\234\347\250\213redis.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/java \350\277\234\347\250\213redis.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/java \350\277\234\347\250\213redis.md"
diff --git "a/12 - Practice (problems encountered during development)/linux\347\251\272\351\227\264\351\227\256\351\242\230.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/linux\347\251\272\351\227\264\351\227\256\351\242\230.md"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/linux\347\251\272\351\227\264\351\227\256\351\242\230.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/linux\347\251\272\351\227\264\351\227\256\351\242\230.md"
index 7321ed8e..42654af9 100644
--- "a/12 - Practice (problems encountered during development)/linux\347\251\272\351\227\264\351\227\256\351\242\230.md"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/linux\347\251\272\351\227\264\351\227\256\351\242\230.md"	
@@ -1,6 +1,6 @@
-https://www.cnblogs.com/kluan/p/4458278.html
-
-先贴命令：du -m --max-depth=1或du -h --max-depth=1du：用于统计linux中文件或目录所占磁盘空间的大小du参数######-
-m：以M为单位展示查询结果
--h：以K、M、G为单位展示查询结果，提高信息可读性
---max-depth=1：其中，数字“1”是指查询结果中最多显示的目录层数，这里指最多显示一层目录。示例如下：
+https://www.cnblogs.com/kluan/p/4458278.html
+
+先贴命令：du -m --max-depth=1或du -h --max-depth=1du：用于统计linux中文件或目录所占磁盘空间的大小du参数######-
+m：以M为单位展示查询结果
+-h：以K、M、G为单位展示查询结果，提高信息可读性
+--max-depth=1：其中，数字“1”是指查询结果中最多显示的目录层数，这里指最多显示一层目录。示例如下：
diff --git "a/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mybatis\345\214\271\351\205\215\344\270\215\344\272\206xml.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mybatis\345\214\271\351\205\215\344\270\215\344\272\206xml.md"
new file mode 100644
index 00000000..580d91a1
--- /dev/null
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mybatis\345\214\271\351\205\215\344\270\215\344\272\206xml.md"	
@@ -0,0 +1,8 @@
+resource 里的 xml
+和mapper 不在同一个目录下，
+或者com 无法找到
+
+有@MapperScan 可以不要 mapperLocations xml路径
+
+https://www.pianshen.com/article/676448229/
+// 基于注解扫描Mapper，不需配置xml路径，传统mybatis的使用需要XML
diff --git "a/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mysql+redis double\347\262\276\345\272\246\344\270\242\345\244\261.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mysql+redis double\347\262\276\345\272\246\344\270\242\345\244\261.md"
new file mode 100644
index 00000000..9df709cc
--- /dev/null
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mysql+redis double\347\262\276\345\272\246\344\270\242\345\244\261.md"	
@@ -0,0 +1,10 @@
+redis存大整数会丢失精度，解决办法是将值转为String，再取出来转为数字类型
+
+mysql
+BIGINT(20)的取值范围为-9223372036854775808~92233 72036 85477 5807   
+-2<sup>63</sup> ~ 2<sup>63</sup>-1
+ 与Java Long匹配
+BIGINT(20) UNSIGNED的取值范围是0 ~ 18446744073709551615，
+0 ~ 2<sup>64</sup>-1
+
+Double BigDecimal 精度问题
diff --git "a/12 - Practice (problems encountered during development)/mysqlCPU100%\345\244\204\347\220\206.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mysqlCPU100%\345\244\204\347\220\206.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/mysqlCPU100%\345\244\204\347\220\206.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/mysqlCPU100%\345\244\204\347\220\206.md"
diff --git a/12 - Practice (problems encountered during development)/python.md "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/python.md"
similarity index 100%
rename from 12 - Practice (problems encountered during development)/python.md
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/python.md"
diff --git "a/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring @Async\345\257\274\350\207\264\345\276\252\347\216\257\344\276\235\350\265\226\346\212\245\351\224\231.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring @Async\345\257\274\350\207\264\345\276\252\347\216\257\344\276\235\350\265\226\346\212\245\351\224\231.md"
new file mode 100644
index 00000000..9b02cc53
--- /dev/null
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring @Async\345\257\274\350\207\264\345\276\252\347\216\257\344\276\235\350\265\226\346\212\245\351\224\231.md"	
@@ -0,0 +1,9 @@
+https://segmentfault.com/a/1190000021217176
+
+https://my.oschina.net/tridays/blog/805111
+
+当在出现循环依赖的 Spring Bean 中使用 @Async 时，会报以下错误：
+
+Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Bean with name 'a' has been injected into other beans [b] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
+
+该问题出现的原因是：在正常加载完循环依赖后，因为 @Async 注解的出现，又需将该 Bean 代理一次，然后 Spring 发现该 Bean 已经被其他对象注入，且注入的是没被代理过的版本，于是报错。这个问题也会出现在使用 AOP 等需要代理原类的场景下。
diff --git "a/12 - Practice (problems encountered during development)/spring mvc\347\273\237\344\270\200\345\274\202\345\270\270\345\244\204\347\220\206\357\274\210@ControllerAdvice + @ExceptionHandler\357\274\211.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring mvc\347\273\237\344\270\200\345\274\202\345\270\270\345\244\204\347\220\206\357\274\210@ControllerAdvice + @ExceptionHandler\357\274\211.txt"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/spring mvc\347\273\237\344\270\200\345\274\202\345\270\270\345\244\204\347\220\206\357\274\210@ControllerAdvice + @ExceptionHandler\357\274\211.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring mvc\347\273\237\344\270\200\345\274\202\345\270\270\345\244\204\347\220\206\357\274\210@ControllerAdvice + @ExceptionHandler\357\274\211.txt"
index 7bc6cb50..7740a4c2 100644
--- "a/12 - Practice (problems encountered during development)/spring mvc\347\273\237\344\270\200\345\274\202\345\270\270\345\244\204\347\220\206\357\274\210@ControllerAdvice + @ExceptionHandler\357\274\211.txt"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring mvc\347\273\237\344\270\200\345\274\202\345\270\270\345\244\204\347\220\206\357\274\210@ControllerAdvice + @ExceptionHandler\357\274\211.txt"	
@@ -1,3 +1,3 @@
-http://blog.csdn.net/kinginblue/article/details/70186586
-
+http://blog.csdn.net/kinginblue/article/details/70186586
+
 @ControllerAdvice 要在spring扫描范围内
\ No newline at end of file
diff --git a/12 - Practice (problems encountered during development)/spring security 5.md "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring security 5.md"
similarity index 100%
rename from 12 - Practice (problems encountered during development)/spring security 5.md
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring security 5.md"
diff --git a/14 - Front-end/me/js/script.js "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring \345\234\250Thread\344\270\255\346\263\250\345\205\245@Resource@Autowired\345\244\261\350\264\245\357\274\214\346\200\273\344\270\272null~\350\247\243\345\206\263.txt"
similarity index 100%
rename from 14 - Front-end/me/js/script.js
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring \345\234\250Thread\344\270\255\346\263\250\345\205\245@Resource@Autowired\345\244\261\350\264\245\357\274\214\346\200\273\344\270\272null~\350\247\243\345\206\263.txt"
diff --git "a/12 - Practice (problems encountered during development)/spring\344\270\213\350\275\275\346\226\207\344\273\266\344\270\255\346\226\207\344\271\261\347\240\201.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\344\270\213\350\275\275\346\226\207\344\273\266\344\270\255\346\226\207\344\271\261\347\240\201.md"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/spring\344\270\213\350\275\275\346\226\207\344\273\266\344\270\255\346\226\207\344\271\261\347\240\201.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\344\270\213\350\275\275\346\226\207\344\273\266\344\270\255\346\226\207\344\271\261\347\240\201.md"
index 387d673b..94685909 100644
--- "a/12 - Practice (problems encountered during development)/spring\344\270\213\350\275\275\346\226\207\344\273\266\344\270\255\346\226\207\344\271\261\347\240\201.md"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\344\270\213\350\275\275\346\226\207\344\273\266\344\270\255\346\226\207\344\271\261\347\240\201.md"	
@@ -1,13 +1,13 @@
-https://www.jianshu.com/p/58e605d881e3
-```java
-        fileName = URLEncoder.encode(fileName, StandardCharsets.UTF_8.toString());
-        response.setContentType(MediaType.APPLICATION_OCTET_STREAM.toString());
-        // 解决中文文件名乱码关键行
-        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"; filename*=utf-8''" + fileName);
-```
-https://blog.csdn.net/clj198606061111/article/details/20743769
-```java
-  String fileName=new String("你好.xlsx".getBytes("UTF-8"),"iso-8859-1");//为了解决中文名称乱码问题
-  headers.setContentDispositionFormData("attachment", fileName);
-  headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
-```
+https://www.jianshu.com/p/58e605d881e3
+```java
+        fileName = URLEncoder.encode(fileName, StandardCharsets.UTF_8.toString());
+        response.setContentType(MediaType.APPLICATION_OCTET_STREAM.toString());
+        // 解决中文文件名乱码关键行
+        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"; filename*=utf-8''" + fileName);
+```
+https://blog.csdn.net/clj198606061111/article/details/20743769
+```java
+  String fileName=new String("你好.xlsx".getBytes("UTF-8"),"iso-8859-1");//为了解决中文名称乱码问题
+  headers.setContentDispositionFormData("attachment", fileName);
+  headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
+```
diff --git "a/12 - Practice (problems encountered during development)/spring\344\272\213\345\212\241@Transactional\345\234\250\345\220\214\344\270\200\344\270\252\347\261\273\344\270\255\347\232\204\346\226\271\346\263\225\350\260\203\347\224\250\344\270\215\347\224\237\346\225\210.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\344\272\213\345\212\241@Transactional\345\234\250\345\220\214\344\270\200\344\270\252\347\261\273\344\270\255\347\232\204\346\226\271\346\263\225\350\260\203\347\224\250\344\270\215\347\224\237\346\225\210.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/spring\344\272\213\345\212\241@Transactional\345\234\250\345\220\214\344\270\200\344\270\252\347\261\273\344\270\255\347\232\204\346\226\271\346\263\225\350\260\203\347\224\250\344\270\215\347\224\237\346\225\210.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\344\272\213\345\212\241@Transactional\345\234\250\345\220\214\344\270\200\344\270\252\347\261\273\344\270\255\347\232\204\346\226\271\346\263\225\350\260\203\347\224\250\344\270\215\347\224\237\346\225\210.md"
diff --git "a/12 - Practice (problems encountered during development)/spring\345\256\271\345\231\250.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\345\256\271\345\231\250.md"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/spring\345\256\271\345\231\250.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\345\256\271\345\231\250.md"
index 4155ce39..ae1262c4 100644
--- "a/12 - Practice (problems encountered during development)/spring\345\256\271\345\231\250.md"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/spring\345\256\271\345\231\250.md"	
@@ -1,21 +1,21 @@
-[spring 容器] (http://blog.csdn.net/s740556472/article/details/54879954)
-
-
-父容器 spring 将dao service注入容器
-
-子容器 spring mvc 将controller 注入容器
-
-父容器不能访问子容器
-
-子容器可以访问父容器
-
-#### 自动注入 和 new 对象 区别
-对象池
-
-spring注入方便管理，依赖注入或者说是控制反转，说白了就是使用了配置文件，这种思想的唯一好处就是增加了模块的重用性灵活性。
-一般配置文件里存的都是数据，键值之类的。Spring的配置文件把要引用类和要给类传的参数都放到配置文件里，这样比以前写死在程序里new一个对象更灵活，因此更具重用性。
-
-spring实现了对象池，一些对象创建和使用完毕之后不会被销毁，放进对象池（某种集合）以备下次使用，下次再需要这个对象，不new，直接从池里出去来用。节省时间，节省cpu
-
-Autowire相当于由spring负责依赖注入，而new是直接new一个对象。
+[spring 容器] (http://blog.csdn.net/s740556472/article/details/54879954)
+
+
+父容器 spring 将dao service注入容器
+
+子容器 spring mvc 将controller 注入容器
+
+父容器不能访问子容器
+
+子容器可以访问父容器
+
+#### 自动注入 和 new 对象 区别
+对象池
+
+spring注入方便管理，依赖注入或者说是控制反转，说白了就是使用了配置文件，这种思想的唯一好处就是增加了模块的重用性灵活性。
+一般配置文件里存的都是数据，键值之类的。Spring的配置文件把要引用类和要给类传的参数都放到配置文件里，这样比以前写死在程序里new一个对象更灵活，因此更具重用性。
+
+spring实现了对象池，一些对象创建和使用完毕之后不会被销毁，放进对象池（某种集合）以备下次使用，下次再需要这个对象，不new，直接从池里出去来用。节省时间，节省cpu
+
+Autowire相当于由spring负责依赖注入，而new是直接new一个对象。
 spring注入的对象和你new的对象，并且，还包括其它信息，如事务，依赖注入等。
\ No newline at end of file
diff --git "a/12 - Practice (problems encountered during development)/tomcat  java buildclass\344\270\215\346\233\264\346\226\260\345\216\237\345\233\240.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/tomcat  java buildclass\344\270\215\346\233\264\346\226\260\345\216\237\345\233\240.txt"
similarity index 97%
rename from "12 - Practice (problems encountered during development)/tomcat  java buildclass\344\270\215\346\233\264\346\226\260\345\216\237\345\233\240.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/tomcat  java buildclass\344\270\215\346\233\264\346\226\260\345\216\237\345\233\240.txt"
index af6e1228..bc20f0c4 100644
--- "a/12 - Practice (problems encountered during development)/tomcat  java buildclass\344\270\215\346\233\264\346\226\260\345\216\237\345\233\240.txt"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/tomcat  java buildclass\344\270\215\346\233\264\346\226\260\345\216\237\345\233\240.txt"	
@@ -1,5 +1,5 @@
-依赖的jar包不足，程序中有错 解决所有的javaproblem
-可能是build下部分文件夹被删除 清空 build目录
-
-
+依赖的jar包不足，程序中有错 解决所有的javaproblem
+可能是build下部分文件夹被删除 清空 build目录
+
+
 eclipse Project clean后会重新build
\ No newline at end of file
diff --git "a/12 - Practice (problems encountered during development)/tomcat \344\270\255\346\226\207\345\217\230\346\210\220\351\227\256\345\217\267\347\232\204\345\216\237\345\233\240\345\244\204\347\220\206.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/tomcat \344\270\255\346\226\207\345\217\230\346\210\220\351\227\256\345\217\267\347\232\204\345\216\237\345\233\240\345\244\204\347\220\206.txt"
similarity index 97%
rename from "12 - Practice (problems encountered during development)/tomcat \344\270\255\346\226\207\345\217\230\346\210\220\351\227\256\345\217\267\347\232\204\345\216\237\345\233\240\345\244\204\347\220\206.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/tomcat \344\270\255\346\226\207\345\217\230\346\210\220\351\227\256\345\217\267\347\232\204\345\216\237\345\233\240\345\244\204\347\220\206.txt"
index f7556a6f..376ec374 100644
--- "a/12 - Practice (problems encountered during development)/tomcat \344\270\255\346\226\207\345\217\230\346\210\220\351\227\256\345\217\267\347\232\204\345\216\237\345\233\240\345\244\204\347\220\206.txt"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/tomcat \344\270\255\346\226\207\345\217\230\346\210\220\351\227\256\345\217\267\347\232\204\345\216\237\345\233\240\345\244\204\347\220\206.txt"	
@@ -1,15 +1,15 @@
-https://www.cnblogs.com/nn839155963/p/7411394.html
-
-
-修改 tomcat catalina.sh
-
-
-if [ -z "$JSSE_OPTS" ] ; then
-  JSSE_OPTS="-Djdk.tls.ephemeralDHKeySize=2048"
-fi
-JAVA_OPTS="$JAVA_OPTS $JSSE_OPTS"
-
-# Register custom URL handlers
-# Do this here so custom URL handles (specifically 'war:...') can be used in the security policy
-#JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources"
+https://www.cnblogs.com/nn839155963/p/7411394.html
+
+
+修改 tomcat catalina.sh
+
+
+if [ -z "$JSSE_OPTS" ] ; then
+  JSSE_OPTS="-Djdk.tls.ephemeralDHKeySize=2048"
+fi
+JAVA_OPTS="$JAVA_OPTS $JSSE_OPTS"
+
+# Register custom URL handlers
+# Do this here so custom URL handles (specifically 'war:...') can be used in the security policy
+#JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources"
 JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dfile.encoding=UTF8 -Dsun.jnu.encoding=UTF8"
\ No newline at end of file
diff --git a/12 - Practice (problems encountered during development)/update.md "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/update.md"
similarity index 100%
rename from 12 - Practice (problems encountered during development)/update.md
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/update.md"
diff --git "a/12 - Practice (problems encountered during development)/web.xml \350\256\276\347\275\256\346\212\233\345\207\272404\345\274\202\345\270\270.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/web.xml \350\256\276\347\275\256\346\212\233\345\207\272404\345\274\202\345\270\270.txt"
similarity index 96%
rename from "12 - Practice (problems encountered during development)/web.xml \350\256\276\347\275\256\346\212\233\345\207\272404\345\274\202\345\270\270.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/web.xml \350\256\276\347\275\256\346\212\233\345\207\272404\345\274\202\345\270\270.txt"
index 86b9440c..5f4e3b71 100644
--- "a/12 - Practice (problems encountered during development)/web.xml \350\256\276\347\275\256\346\212\233\345\207\272404\345\274\202\345\270\270.txt"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/web.xml \350\256\276\347\275\256\346\212\233\345\207\272404\345\274\202\345\270\270.txt"	
@@ -1,29 +1,29 @@
-  <servlet>
-    <servlet-name>springDispatcherServlet</servlet-name>
-    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
-    <init-param>
-      <param-name>contextConfigLocation</param-name>
-      <param-value>classpath:spring-mvc.xml</param-value>
-    </init-param>
-    <init-param>
-      <param-name>throwExceptionIfNoHandlerFound</param-name>
-      <param-value>true</param-value>
-    </init-param>
-    <load-on-startup>1</load-on-startup>
-  </servlet>
-  
-  
-  
-  
-  
-  
-  <init-param>
-      <param-name>throwExceptionIfNoHandlerFound</param-name>
-      <param-value>true</param-value>
-    </init-param>
-	
-	
-	<init-param>
-      <param-name>throwExceptionIfNoHandlerFound</param-name>
-      <param-value>true</param-value>
+  <servlet>
+    <servlet-name>springDispatcherServlet</servlet-name>
+    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+    <init-param>
+      <param-name>contextConfigLocation</param-name>
+      <param-value>classpath:spring-mvc.xml</param-value>
+    </init-param>
+    <init-param>
+      <param-name>throwExceptionIfNoHandlerFound</param-name>
+      <param-value>true</param-value>
+    </init-param>
+    <load-on-startup>1</load-on-startup>
+  </servlet>
+  
+  
+  
+  
+  
+  
+  <init-param>
+      <param-name>throwExceptionIfNoHandlerFound</param-name>
+      <param-value>true</param-value>
+    </init-param>
+	
+	
+	<init-param>
+      <param-name>throwExceptionIfNoHandlerFound</param-name>
+      <param-value>true</param-value>
     </init-param>
\ No newline at end of file
diff --git "a/12 - Practice (problems encountered during development)/\345\233\236\346\273\232\346\227\245\345\277\227.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\345\233\236\346\273\232\346\227\245\345\277\227.txt"
similarity index 98%
rename from "12 - Practice (problems encountered during development)/\345\233\236\346\273\232\346\227\245\345\277\227.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\345\233\236\346\273\232\346\227\245\345\277\227.txt"
index 2ab374c9..4390c26f 100644
--- "a/12 - Practice (problems encountered during development)/\345\233\236\346\273\232\346\227\245\345\277\227.txt"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\345\233\236\346\273\232\346\227\245\345\277\227.txt"	
@@ -1,30 +1,30 @@
-回滚了
-
-Creating a new SqlSession
-Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
-JDBC Connection [com.mysql.jdbc.JDBC4Connection@742e598d] will be managed by Spring
-==>  Preparing: delete from TaskChannel where TaskID = ? 
-==> Parameters: 7c2f9dc1356e4bb5a39b59d304898e0e(String)
-<==    Updates: 14
-Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
-Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
-Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
-
-
-执行成功的
-
-Creating a new SqlSession
-Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
-JDBC Connection [com.mysql.jdbc.JDBC4Connection@2d756fdb] will be managed by Spring
-==>  Preparing: delete from TaskChannel where TaskID = ? 
-==> Parameters: 7c2f9dc1356e4bb5a39b59d304898e0e(String)
-<==    Updates: 14
-Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
-Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
-Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
-Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
-
-
-
-执行成功的有committing  提交
+回滚了
+
+Creating a new SqlSession
+Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
+JDBC Connection [com.mysql.jdbc.JDBC4Connection@742e598d] will be managed by Spring
+==>  Preparing: delete from TaskChannel where TaskID = ? 
+==> Parameters: 7c2f9dc1356e4bb5a39b59d304898e0e(String)
+<==    Updates: 14
+Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
+Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
+Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@8853405]
+
+
+执行成功的
+
+Creating a new SqlSession
+Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
+JDBC Connection [com.mysql.jdbc.JDBC4Connection@2d756fdb] will be managed by Spring
+==>  Preparing: delete from TaskChannel where TaskID = ? 
+==> Parameters: 7c2f9dc1356e4bb5a39b59d304898e0e(String)
+<==    Updates: 14
+Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
+Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
+Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
+Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
+
+
+
+执行成功的有committing  提交
 Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d814c0a]
\ No newline at end of file
diff --git "a/12 - Practice (problems encountered during development)/\347\256\227\346\263\225.md" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\347\256\227\346\263\225.md"
similarity index 100%
rename from "12 - Practice (problems encountered during development)/\347\256\227\346\263\225.md"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\347\256\227\346\263\225.md"
diff --git "a/12 - Practice (problems encountered during development)/\347\273\217\351\252\214.txt" "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\347\273\217\351\252\214.txt"
similarity index 96%
rename from "12 - Practice (problems encountered during development)/\347\273\217\351\252\214.txt"
rename to "12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\347\273\217\351\252\214.txt"
index 2553a7d8..b2b58545 100644
--- "a/12 - Practice (problems encountered during development)/\347\273\217\351\252\214.txt"	
+++ "b/12 - Practice (problems encountered during development) \345\256\236\350\267\265\351\227\256\351\242\230/\347\273\217\351\252\214.txt"	
@@ -1,2 +1,2 @@
-数据格式 都在开发前定义好 做好模块分离
-
+数据格式 都在开发前定义好 做好模块分离
+
diff --git "a/13 - DevOps/Docker/Docker \347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\345\234\250\345\223\252\351\207\214\357\274\237.md" "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/Docker \347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\345\234\250\345\223\252\351\207\214\357\274\237.md"
similarity index 99%
rename from "13 - DevOps/Docker/Docker \347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\345\234\250\345\223\252\351\207\214\357\274\237.md"
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/Docker \347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\345\234\250\345\223\252\351\207\214\357\274\237.md"
index dd3a7524..4dbc6e74 100644
--- "a/13 - DevOps/Docker/Docker \347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\345\234\250\345\223\252\351\207\214\357\274\237.md"	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/Docker \347\232\204\345\272\224\347\224\250\345\234\272\346\231\257\345\234\250\345\223\252\351\207\214\357\274\237.md"	
@@ -1,24 +1,24 @@
-
-作者：Li Yingjie
-链接：https://www.zhihu.com/question/22969309/answer/38317063
-
-下面是我总结的一些Docker的使用场景，它为你展示了如何借助Docker的优势，在低开销的情况下，打造一个一致性的环境。
-八个Docker的真实应用场景
-
-1. **简化配置**这是Docker公司宣传的Docker的主要使用场景。
-
-	虚拟机的最大好处是能在你的硬件设施上运行各种配置不一样的平台（软件、系统），Docker在降低额外开销的情况下提供了同样的功能。它能让你将运行环境和配置放在代码中然后部署，同一个Docker的配置可以在不同的环境中使用，这样就降低了硬件要求和应用环境之间耦合度。
-
-2. **代码流水线**（Code Pipeline）管理前一个场景对于管理代码的流水线起到了很大的帮助。代码从开发者的机器到最终在生产环境上的部署，需要经过很多的中间环境。而每一个中间环境都有自己微小的差别，Docker给应用提供了一个从开发到上线均一致的环境，让代码的流水线变得简单不少。
-
-3. 提高开发效率这就带来了一些额外的好处：Docker能提升开发者的开发效率。如果你想看一个详细一点的例子，可以参考Aater在DevOpsDays Austin 2014 大会或者是DockerCon上的演讲。不同的开发环境中，我们都想把两件事做好。一是我们想让开发环境尽量贴近生产环境，二是我们想快速搭建开发环境。理想状态中，要达到第一个目标，我们需要将每一个服务都跑在独立的虚拟机中以便监控生产环境中服务的运行状态。然而，我们却不想每次都需要网络连接，每次重新编译的时候远程连接上去特别麻烦。这就是Docker做的特别好的地方，开发环境的机器通常内存比较小，之前使用虚拟的时候，我们经常需要为开发环境的机器加内存，而现在Docker可以轻易的让几十个服务在Docker中跑起来。
-
-4. 隔离应用有很多种原因会让你选择在一个机器上运行不同的应用，比如之前提到的提高开发效率的场景等。我们经常需要考虑两点，一是因为要降低成本而进行服务器整合，二是将一个整体式的应用拆分成松耦合的单个服务（译者注：微服务架构）。如果你想了解为什么松耦合的应用这么重要，请参考Steve Yege的这篇论文，文中将Google和亚马逊做了比较。
-
-5. 整合服务器正如通过虚拟机来整合多个应用，Docker隔离应用的能力使得Docker可以整合多个服务器以降低成本。由于没有多个操作系统的内存占用，以及能在多个实例之间共享没有使用的内存，Docker可以比虚拟机提供更好的服务器整合解决方案。
-
-6. 调试能力Docker提供了很多的工具，这些工具不一定只是针对容器，但是却适用于容器。它们提供了很多的功能，包括可以为容器设置检查点、设置版本和查看两个容器之间的差别，这些特性可以帮助调试Bug。你可以在《Docker拯救世界》的文章中找到这一点的例证。
-
-7. 多租户环境另外一个Docker有意思的使用场景是在多租户的应用中，它可以避免关键应用的重写。我们一个特别的关于这个场景的例子是为IoT（译者注：物联网）的应用开发一个快速、易用的多租户环境。这种多租户的基本代码非常复杂，很难处理，重新规划这样一个应用不但消耗时间，也浪费金钱。使用Docker，可以为每一个租户的应用层的多个实例创建隔离的环境，这不仅简单而且成本低廉，当然这一切得益于Docker环境的启动速度和其高效的diff命令。你可以在这里了解关于此场景的更多信息。
-
-8. 快速部署在虚拟机之前，引入新的硬件资源需要消耗几天的时间。Docker的虚拟化技术将这个时间降到了几分钟，Docker只是创建一个容器进程而无需启动操作系统，这个过程只需要秒级的时间。这正是Google和Facebook都看重的特性。你可以在数据中心创建销毁资源而无需担心重新启动带来的开销。通常数据中心的资源利用率只有30%，通过使用Docker并进行有效的资源分配可以提高资源的利用率。
+
+作者：Li Yingjie
+链接：https://www.zhihu.com/question/22969309/answer/38317063
+
+下面是我总结的一些Docker的使用场景，它为你展示了如何借助Docker的优势，在低开销的情况下，打造一个一致性的环境。
+八个Docker的真实应用场景
+
+1. **简化配置**这是Docker公司宣传的Docker的主要使用场景。
+
+	虚拟机的最大好处是能在你的硬件设施上运行各种配置不一样的平台（软件、系统），Docker在降低额外开销的情况下提供了同样的功能。它能让你将运行环境和配置放在代码中然后部署，同一个Docker的配置可以在不同的环境中使用，这样就降低了硬件要求和应用环境之间耦合度。
+
+2. **代码流水线**（Code Pipeline）管理前一个场景对于管理代码的流水线起到了很大的帮助。代码从开发者的机器到最终在生产环境上的部署，需要经过很多的中间环境。而每一个中间环境都有自己微小的差别，Docker给应用提供了一个从开发到上线均一致的环境，让代码的流水线变得简单不少。
+
+3. 提高开发效率这就带来了一些额外的好处：Docker能提升开发者的开发效率。如果你想看一个详细一点的例子，可以参考Aater在DevOpsDays Austin 2014 大会或者是DockerCon上的演讲。不同的开发环境中，我们都想把两件事做好。一是我们想让开发环境尽量贴近生产环境，二是我们想快速搭建开发环境。理想状态中，要达到第一个目标，我们需要将每一个服务都跑在独立的虚拟机中以便监控生产环境中服务的运行状态。然而，我们却不想每次都需要网络连接，每次重新编译的时候远程连接上去特别麻烦。这就是Docker做的特别好的地方，开发环境的机器通常内存比较小，之前使用虚拟的时候，我们经常需要为开发环境的机器加内存，而现在Docker可以轻易的让几十个服务在Docker中跑起来。
+
+4. 隔离应用有很多种原因会让你选择在一个机器上运行不同的应用，比如之前提到的提高开发效率的场景等。我们经常需要考虑两点，一是因为要降低成本而进行服务器整合，二是将一个整体式的应用拆分成松耦合的单个服务（译者注：微服务架构）。如果你想了解为什么松耦合的应用这么重要，请参考Steve Yege的这篇论文，文中将Google和亚马逊做了比较。
+
+5. 整合服务器正如通过虚拟机来整合多个应用，Docker隔离应用的能力使得Docker可以整合多个服务器以降低成本。由于没有多个操作系统的内存占用，以及能在多个实例之间共享没有使用的内存，Docker可以比虚拟机提供更好的服务器整合解决方案。
+
+6. 调试能力Docker提供了很多的工具，这些工具不一定只是针对容器，但是却适用于容器。它们提供了很多的功能，包括可以为容器设置检查点、设置版本和查看两个容器之间的差别，这些特性可以帮助调试Bug。你可以在《Docker拯救世界》的文章中找到这一点的例证。
+
+7. 多租户环境另外一个Docker有意思的使用场景是在多租户的应用中，它可以避免关键应用的重写。我们一个特别的关于这个场景的例子是为IoT（译者注：物联网）的应用开发一个快速、易用的多租户环境。这种多租户的基本代码非常复杂，很难处理，重新规划这样一个应用不但消耗时间，也浪费金钱。使用Docker，可以为每一个租户的应用层的多个实例创建隔离的环境，这不仅简单而且成本低廉，当然这一切得益于Docker环境的启动速度和其高效的diff命令。你可以在这里了解关于此场景的更多信息。
+
+8. 快速部署在虚拟机之前，引入新的硬件资源需要消耗几天的时间。Docker的虚拟化技术将这个时间降到了几分钟，Docker只是创建一个容器进程而无需启动操作系统，这个过程只需要秒级的时间。这正是Google和Facebook都看重的特性。你可以在数据中心创建销毁资源而无需担心重新启动带来的开销。通常数据中心的资源利用率只有30%，通过使用Docker并进行有效的资源分配可以提高资源的利用率。
diff --git "a/13 - DevOps/Docker/SpringBoot+Docker+Git+Jenkins\345\256\236\347\216\260\347\256\200\346\230\223\347\232\204\346\214\201\347\273\255\351\233\206\346\210\220\345\222\214\346\214\201\347\273\255\351\203\250\347\275\262.md" "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/SpringBoot+Docker+Git+Jenkins\345\256\236\347\216\260\347\256\200\346\230\223\347\232\204\346\214\201\347\273\255\351\233\206\346\210\220\345\222\214\346\214\201\347\273\255\351\203\250\347\275\262.md"
similarity index 96%
rename from "13 - DevOps/Docker/SpringBoot+Docker+Git+Jenkins\345\256\236\347\216\260\347\256\200\346\230\223\347\232\204\346\214\201\347\273\255\351\233\206\346\210\220\345\222\214\346\214\201\347\273\255\351\203\250\347\275\262.md"
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/SpringBoot+Docker+Git+Jenkins\345\256\236\347\216\260\347\256\200\346\230\223\347\232\204\346\214\201\347\273\255\351\233\206\346\210\220\345\222\214\346\214\201\347\273\255\351\203\250\347\275\262.md"
index eb16d0b5..9d24adaa 100644
--- "a/13 - DevOps/Docker/SpringBoot+Docker+Git+Jenkins\345\256\236\347\216\260\347\256\200\346\230\223\347\232\204\346\214\201\347\273\255\351\233\206\346\210\220\345\222\214\346\214\201\347\273\255\351\203\250\347\275\262.md"	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/SpringBoot+Docker+Git+Jenkins\345\256\236\347\216\260\347\256\200\346\230\223\347\232\204\346\214\201\347\273\255\351\233\206\346\210\220\345\222\214\346\214\201\347\273\255\351\203\250\347\275\262.md"	
@@ -1,90 +1,90 @@
-https://juejin.im/post/5adc6cc16fb9a07ac90ccae8
-
-流程：
-
-1. ```push```代码到```Github```触发```WebHook```。（因网络原因，本篇使用```gitee```）
-2. ```Jenkins```从仓库拉去代码
-3. ```maven```构建项目
-4. 代码静态分析
-5. 单元测试
-6. ```build```镜像
-7. ```push```镜像到镜像仓库（本篇使用的镜像仓库为网易镜像仓库）
-8. 更新服务
-
-
-Jenkins
-  **Pipelines**
-
-
-gitee集成WebHooks
-
-Pipeline的几个基本概念： 更多Pipeline语法参考：pipeline 语法详解http://www.cnblogs.com/fengjian2016/p/8227532.html
-
-Stage: 阶段，一个Pipeline可以划分为若干个Stage，每个Stage代表一组操作。注意，Stage是一个逻辑分组的概念，可以跨多个Node。
-Node: 节点，一个Node就是一个Jenkins节点，或者是Master，或者是Agent，是执行Step的具体运行期环境。
-Step: 步骤，Step是最基本的操作单元，小到创建一个目录，大到构建一个Docker镜像，由各类Jenkins Plugin提供。
-
-``` js
-#!groovy
-pipeline{
-	agent any
-	//定义仓库地址
-	environment {
-		REPOSITORY="https://gitee.com/merryyou/sso-merryyou.git"
-	}
-
-	stages {
-
-		stage('获取代码'){
-			steps {
-				echo "start fetch code from git:${REPOSITORY}"
-				//清空当前目录
-				deleteDir()
-				//拉去代码
-				git "${REPOSITORY}"
-			}
-		}
-
-		stage('代码静态检查'){
-			steps {
-				//伪代码检查
-				echo "start code check"
-			}
-		}		
-
-		stage('编译+单元测试'){
-			steps {
-				echo "start compile"
-				//切换目录
-				dir('sso-client1') {
-					//重新打包
-					bat 'mvn -Dmaven.test.skip=true -U clean install'
-				}
-			}
-		}
-
-		stage('构建镜像'){
-			steps {
-				echo "start build image"
-				dir('sso-client1') {
-					//build镜像
-					bat 'docker build -t hub.c.163.com/longfeizheng/sso-client1:1.0 .'
-					//登录163云仓库
-					bat 'docker login -u longfei_zheng@163.com -p password hub.c.163.com'
-					//推送镜像到163仓库
-					bat 'docker push hub.c.163.com/longfeizheng/sso-client1:1.0'
-				}
-			}
-		}
-
-		stage('启动服务'){
-			steps {
-				echo "start sso-merryyou"
-				//重启服务
-				bat 'docker-compose up -d --build'
-			}
-		}				
-
-	}
-}
-```
+https://juejin.im/post/5adc6cc16fb9a07ac90ccae8
+
+流程：
+
+1. ```push```代码到```Github```触发```WebHook```。（因网络原因，本篇使用```gitee```）
+2. ```Jenkins```从仓库拉去代码
+3. ```maven```构建项目
+4. 代码静态分析
+5. 单元测试
+6. ```build```镜像
+7. ```push```镜像到镜像仓库（本篇使用的镜像仓库为网易镜像仓库）
+8. 更新服务
+
+
+Jenkins
+  **Pipelines**
+
+
+gitee集成WebHooks
+
+Pipeline的几个基本概念： 更多Pipeline语法参考：pipeline 语法详解http://www.cnblogs.com/fengjian2016/p/8227532.html
+
+Stage: 阶段，一个Pipeline可以划分为若干个Stage，每个Stage代表一组操作。注意，Stage是一个逻辑分组的概念，可以跨多个Node。
+Node: 节点，一个Node就是一个Jenkins节点，或者是Master，或者是Agent，是执行Step的具体运行期环境。
+Step: 步骤，Step是最基本的操作单元，小到创建一个目录，大到构建一个Docker镜像，由各类Jenkins Plugin提供。
+
+``` js
+#!groovy
+pipeline{
+	agent any
+	//定义仓库地址
+	environment {
+		REPOSITORY="https://gitee.com/merryyou/sso-merryyou.git"
+	}
+
+	stages {
+
+		stage('获取代码'){
+			steps {
+				echo "start fetch code from git:${REPOSITORY}"
+				//清空当前目录
+				deleteDir()
+				//拉去代码
+				git "${REPOSITORY}"
+			}
+		}
+
+		stage('代码静态检查'){
+			steps {
+				//伪代码检查
+				echo "start code check"
+			}
+		}		
+
+		stage('编译+单元测试'){
+			steps {
+				echo "start compile"
+				//切换目录
+				dir('sso-client1') {
+					//重新打包
+					bat 'mvn -Dmaven.test.skip=true -U clean install'
+				}
+			}
+		}
+
+		stage('构建镜像'){
+			steps {
+				echo "start build image"
+				dir('sso-client1') {
+					//build镜像
+					bat 'docker build -t hub.c.163.com/longfeizheng/sso-client1:1.0 .'
+					//登录163云仓库
+					bat 'docker login -u longfei_zheng@163.com -p password hub.c.163.com'
+					//推送镜像到163仓库
+					bat 'docker push hub.c.163.com/longfeizheng/sso-client1:1.0'
+				}
+			}
+		}
+
+		stage('启动服务'){
+			steps {
+				echo "start sso-merryyou"
+				//重启服务
+				bat 'docker-compose up -d --build'
+			}
+		}				
+
+	}
+}
+```
diff --git "a/13 - DevOps/Docker/\345\256\211\350\243\205.md" "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/\345\256\211\350\243\205.md"
similarity index 95%
rename from "13 - DevOps/Docker/\345\256\211\350\243\205.md"
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/\345\256\211\350\243\205.md"
index 1b4cc8c4..424f7329 100644
--- "a/13 - DevOps/Docker/\345\256\211\350\243\205.md"	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Docker/\345\256\211\350\243\205.md"	
@@ -1,25 +1,25 @@
-
-http://www.runoob.com/docker/centos-docker-install.html
-
-Docker 要求 CentOS 系统的内核版本高于 3.10 ，查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker 。
-
-通过 uname -r 命令查看你当前的内核版本
-```
-uname -r
-3.10.0-327.el7.x86_64
-```
-安装 Docker
-Docker 软件包和依赖包已经包含在默认的 CentOS-Extras 软件源里，安装命令如下：
-```
-yum -y install docker-io
-```
-
-启动 Docker 后台服务
-```
-service docker start
-```
-
-测试运行 hello-world
-```
-docker run hello-world
-```
+
+http://www.runoob.com/docker/centos-docker-install.html
+
+Docker 要求 CentOS 系统的内核版本高于 3.10 ，查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker 。
+
+通过 uname -r 命令查看你当前的内核版本
+```
+uname -r
+3.10.0-327.el7.x86_64
+```
+安装 Docker
+Docker 软件包和依赖包已经包含在默认的 CentOS-Extras 软件源里，安装命令如下：
+```
+yum -y install docker-io
+```
+
+启动 Docker 后台服务
+```
+service docker start
+```
+
+测试运行 hello-world
+```
+docker run hello-world
+```
diff --git "a/13 - DevOps/Jenkins/Jenkins\346\214\201\347\273\255\351\233\206\346\210\220\344\275\223\347\263\273 \357\275\234 \346\234\200\345\256\214\346\225\264\347\232\204\344\273\213\347\273\215\345\217\212\350\265\204\346\226\231.md" "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/Jenkins\346\214\201\347\273\255\351\233\206\346\210\220\344\275\223\347\263\273 \357\275\234 \346\234\200\345\256\214\346\225\264\347\232\204\344\273\213\347\273\215\345\217\212\350\265\204\346\226\231.md"
similarity index 96%
rename from "13 - DevOps/Jenkins/Jenkins\346\214\201\347\273\255\351\233\206\346\210\220\344\275\223\347\263\273 \357\275\234 \346\234\200\345\256\214\346\225\264\347\232\204\344\273\213\347\273\215\345\217\212\350\265\204\346\226\231.md"
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/Jenkins\346\214\201\347\273\255\351\233\206\346\210\220\344\275\223\347\263\273 \357\275\234 \346\234\200\345\256\214\346\225\264\347\232\204\344\273\213\347\273\215\345\217\212\350\265\204\346\226\231.md"
index 79a60eca..b3d67014 100644
--- "a/13 - DevOps/Jenkins/Jenkins\346\214\201\347\273\255\351\233\206\346\210\220\344\275\223\347\263\273 \357\275\234 \346\234\200\345\256\214\346\225\264\347\232\204\344\273\213\347\273\215\345\217\212\350\265\204\346\226\231.md"	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/Jenkins\346\214\201\347\273\255\351\233\206\346\210\220\344\275\223\347\263\273 \357\275\234 \346\234\200\345\256\214\346\225\264\347\232\204\344\273\213\347\273\215\345\217\212\350\265\204\346\226\231.md"	
@@ -1,68 +1,68 @@
-简单直接点，其实这篇文章就是告诉各位，Jenkins能解决什么问题，有哪些应用场景，为何要掌握Jenkins，掌握Jenkins后有哪些好处，弄懂Jenkins需要掌握哪些知识
-
-
-Jenkins是一个广泛用于持续构建的可视化web工具，持续构建说得更直白点，就是各种项目的"自动化"编译、打包、分发部署。
-jenkins可以很好的支持各种语言（比如：java, c#, php等）的项目构建，也完全兼容ant、maven、gradle等多种第三方构建工具，同时跟svn、git能无缝集成，也支持直接与知名源代码托管网站，比如github、bitbucket直接集成。
-
-简单点说，Jenkins其实就是大的框架集，可以整个任何你想整合的内容，实现公司的整个持续集成体系！
-
-如：```自动化```，```性能```，```打包```，```部署```，```发布```&```发布结果自动化验证```，```接口测试```，```单元测试```
-
-各种你能想到的，和不能想到的
-
-Jenkins可自由部署在各平台：```Windows```， ```Linux```， ```Mac```
-
-
-如下简单列几个应用场景：
-
-1. 使用Jenkins搭建iOS/Android 持续集成打包平台
-2. Jenkins集成邮件通知模板
-3. Jenkins+Ant+Robotium构建 自动化测试持续集成
-4. jenkins+ant+jmeter搭建 持续集成的接口测试平台
-5. **持续集成**：jenkins + Git + Maven配置
-
-
-Selenium+Testng+Ant+Jenkins
-
-
-搭建持续集成
-
-单元测试平台（Jenkins+Ant+Java+Junit+SVN）
-
-jenkins+ant执行junit单元测试
-
-
-使用jenkins+Emma统计
-
-Android客户端单元测试覆盖率
-
-
-将Jenkins的测试结果整合到Testlink
-
-
-Jenkins+PMD构建自动化静态代码检测
-
-
-Maven+Nexus+Jenkins+Svn+
-
-Tomcat+Sonar搭建持续集成环境
-
-
-Jmeter+maven+Jenkins构建云性能测试平台
-
-
-Jenkins集成PMD，FindBugs，CheckStyle
-
-jenkins结合ansible用
-
-shell实现自动化部署和回滚
-
-jenkins主从服务器，分布式构建部署
-
-使用jenkins + python + selenium
-
-一步步搭建web自动化测试“框架”
-
-一步一步构建iOS持续集成:
-
+简单直接点，其实这篇文章就是告诉各位，Jenkins能解决什么问题，有哪些应用场景，为何要掌握Jenkins，掌握Jenkins后有哪些好处，弄懂Jenkins需要掌握哪些知识
+
+
+Jenkins是一个广泛用于持续构建的可视化web工具，持续构建说得更直白点，就是各种项目的"自动化"编译、打包、分发部署。
+jenkins可以很好的支持各种语言（比如：java, c#, php等）的项目构建，也完全兼容ant、maven、gradle等多种第三方构建工具，同时跟svn、git能无缝集成，也支持直接与知名源代码托管网站，比如github、bitbucket直接集成。
+
+简单点说，Jenkins其实就是大的框架集，可以整个任何你想整合的内容，实现公司的整个持续集成体系！
+
+如：```自动化```，```性能```，```打包```，```部署```，```发布```&```发布结果自动化验证```，```接口测试```，```单元测试```
+
+各种你能想到的，和不能想到的
+
+Jenkins可自由部署在各平台：```Windows```， ```Linux```， ```Mac```
+
+
+如下简单列几个应用场景：
+
+1. 使用Jenkins搭建iOS/Android 持续集成打包平台
+2. Jenkins集成邮件通知模板
+3. Jenkins+Ant+Robotium构建 自动化测试持续集成
+4. jenkins+ant+jmeter搭建 持续集成的接口测试平台
+5. **持续集成**：jenkins + Git + Maven配置
+
+
+Selenium+Testng+Ant+Jenkins
+
+
+搭建持续集成
+
+单元测试平台（Jenkins+Ant+Java+Junit+SVN）
+
+jenkins+ant执行junit单元测试
+
+
+使用jenkins+Emma统计
+
+Android客户端单元测试覆盖率
+
+
+将Jenkins的测试结果整合到Testlink
+
+
+Jenkins+PMD构建自动化静态代码检测
+
+
+Maven+Nexus+Jenkins+Svn+
+
+Tomcat+Sonar搭建持续集成环境
+
+
+Jmeter+maven+Jenkins构建云性能测试平台
+
+
+Jenkins集成PMD，FindBugs，CheckStyle
+
+jenkins结合ansible用
+
+shell实现自动化部署和回滚
+
+jenkins主从服务器，分布式构建部署
+
+使用jenkins + python + selenium
+
+一步步搭建web自动化测试“框架”
+
+一步一步构建iOS持续集成:
+
 Jenkins+GitLab+蒲公英+FTP
\ No newline at end of file
diff --git a/13 - DevOps/Jenkins/all.md "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/all.md"
similarity index 95%
rename from 13 - DevOps/Jenkins/all.md
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/all.md"
index 98885685..79475e00 100644
--- a/13 - DevOps/Jenkins/all.md	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/all.md"	
@@ -1,30 +1,30 @@
-https://www.jianshu.com/p/ba09cdc53343
-
-
-https://blog.csdn.net/w105021/article/details/78657382
-
-nohup java -Xms256m -Xmx1024m -XX:MaxPermSize=512m -jar jenkins.war --ajp13Port=-1 --httpPort=7076 > jenkins.out 2>&1 &
-
-其中 --httpPort=7076指定jenkins启动监听的端口，这里更改为7076（默认是8080）。-Xms256m -Xmx1024m -XX:MaxPermSize=512m设置了JVM参数(需要因环境而异)。
-
-
-https://www.cnblogs.com/520playboy/p/6258150.html
-
-
-jdk
-
-maven
-
-git
-
-tomcat
-
-
-Jenkins 配置 插件 maven git
-
-maven项目
-配置
-
-构建
-
-然后即可在tomcat部署
+https://www.jianshu.com/p/ba09cdc53343
+
+
+https://blog.csdn.net/w105021/article/details/78657382
+
+nohup java -Xms256m -Xmx1024m -XX:MaxPermSize=512m -jar jenkins.war --ajp13Port=-1 --httpPort=7076 > jenkins.out 2>&1 &
+
+其中 --httpPort=7076指定jenkins启动监听的端口，这里更改为7076（默认是8080）。-Xms256m -Xmx1024m -XX:MaxPermSize=512m设置了JVM参数(需要因环境而异)。
+
+
+https://www.cnblogs.com/520playboy/p/6258150.html
+
+
+jdk
+
+maven
+
+git
+
+tomcat
+
+
+Jenkins 配置 插件 maven git
+
+maven项目
+配置
+
+构建
+
+然后即可在tomcat部署
diff --git "a/13 - DevOps/Jenkins/jenkins\346\217\222\344\273\266\347\256\241\347\220\206.md" "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/jenkins\346\217\222\344\273\266\347\256\241\347\220\206.md"
similarity index 93%
rename from "13 - DevOps/Jenkins/jenkins\346\217\222\344\273\266\347\256\241\347\220\206.md"
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/jenkins\346\217\222\344\273\266\347\256\241\347\220\206.md"
index 6bf92abc..6fa68055 100644
--- "a/13 - DevOps/Jenkins/jenkins\346\217\222\344\273\266\347\256\241\347\220\206.md"	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/jenkins\346\217\222\344\273\266\347\256\241\347\220\206.md"	
@@ -1,16 +1,16 @@
-系统管理 —— 管理插件
-
-git项目需要插件
-
-可选插件找到 	Git plugin
-
-新建工程
-
-认证方式
-
-源码管理 选择git
-
-
-构建常见错误
-
+系统管理 —— 管理插件
+
+git项目需要插件
+
+可选插件找到 	Git plugin
+
+新建工程
+
+认证方式
+
+源码管理 选择git
+
+
+构建常见错误
+
 https://www.2cto.com/kf/201612/571328.html
\ No newline at end of file
diff --git "a/13 - DevOps/Jenkins/\346\214\201\347\273\255\351\233\206\346\210\220\344\271\213Jenkins _ \350\200\201\345\276\220\345\205\210\345\270\246\344\275\240\345\205\245\344\270\252\351\227\250.md" "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/\346\214\201\347\273\255\351\233\206\346\210\220\344\271\213Jenkins _ \350\200\201\345\276\220\345\205\210\345\270\246\344\275\240\345\205\245\344\270\252\351\227\250.md"
similarity index 96%
rename from "13 - DevOps/Jenkins/\346\214\201\347\273\255\351\233\206\346\210\220\344\271\213Jenkins _ \350\200\201\345\276\220\345\205\210\345\270\246\344\275\240\345\205\245\344\270\252\351\227\250.md"
rename to "13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/\346\214\201\347\273\255\351\233\206\346\210\220\344\271\213Jenkins _ \350\200\201\345\276\220\345\205\210\345\270\246\344\275\240\345\205\245\344\270\252\351\227\250.md"
index 009eb64f..f54a8cbe 100644
--- "a/13 - DevOps/Jenkins/\346\214\201\347\273\255\351\233\206\346\210\220\344\271\213Jenkins _ \350\200\201\345\276\220\345\205\210\345\270\246\344\275\240\345\205\245\344\270\252\351\227\250.md"	
+++ "b/13 - DevOps \345\274\200\345\217\221\345\267\245\345\205\267/Jenkins/\346\214\201\347\273\255\351\233\206\346\210\220\344\271\213Jenkins _ \350\200\201\345\276\220\345\205\210\345\270\246\344\275\240\345\205\245\344\270\252\351\227\250.md"	
@@ -1,34 +1,34 @@
-1.准备工作～
-1）下载jenkins安装包
-官网直接下载：https://jenkins.io/
-
-
-2）安装jdk
- 
-2.启动jenkins服务
-启动非常简单：
-java -jar /usr/local/webserver/jenkins.war --httpPort=8080
- 
-3.在浏览器中输入http://ip:8080,进入jenkins页面
-
-
-4.在进行新建任务之前，进行一些必要设置
-1）点击系统管理—>系统设置ssh server 的配置
-2）系统管理－> Configure Global Security，配置安全设置
-3）     系统管理－> 管理插件，添加一些必要的插件
-4）     新增一些构建用户
- 
-5.在构建项目之前，先准备好代码库地址，并且添加对应插件～
-代码库，可以用svn ,也可以git
- 
-6.选择新建任务(以构建一个maven项目为例)
-
-7.填入项目在git上的地址，选择对应分支，保存即可
-
-8.即构建，构建成功则如下图所示
-
-9.jenkins maven还有很多细节，比如定时构建、触发构建等等，有兴趣自己玩耍，有问题可找老徐交流～
-
-
-启动 net start jenkins
+1.准备工作～
+1）下载jenkins安装包
+官网直接下载：https://jenkins.io/
+
+
+2）安装jdk
+ 
+2.启动jenkins服务
+启动非常简单：
+java -jar /usr/local/webserver/jenkins.war --httpPort=8080
+ 
+3.在浏览器中输入http://ip:8080,进入jenkins页面
+
+
+4.在进行新建任务之前，进行一些必要设置
+1）点击系统管理—>系统设置ssh server 的配置
+2）系统管理－> Configure Global Security，配置安全设置
+3）     系统管理－> 管理插件，添加一些必要的插件
+4）     新增一些构建用户
+ 
+5.在构建项目之前，先准备好代码库地址，并且添加对应插件～
+代码库，可以用svn ,也可以git
+ 
+6.选择新建任务(以构建一个maven项目为例)
+
+7.填入项目在git上的地址，选择对应分支，保存即可
+
+8.即构建，构建成功则如下图所示
+
+9.jenkins maven还有很多细节，比如定时构建、触发构建等等，有兴趣自己玩耍，有问题可找老徐交流～
+
+
+启动 net start jenkins
 停止 net stop jenkins
\ No newline at end of file
diff --git a/14 - Front-end/AngularJS .txt "b/14 - Front-end \345\211\215\347\253\257/AngularJS .txt"
similarity index 97%
rename from 14 - Front-end/AngularJS .txt
rename to "14 - Front-end \345\211\215\347\253\257/AngularJS .txt"
index aba63aa8..5f5c4c2b 100644
--- a/14 - Front-end/AngularJS .txt	
+++ "b/14 - Front-end \345\211\215\347\253\257/AngularJS .txt"	
@@ -1,13 +1,13 @@
-<script src="http://cdn.static.runoob.com/libs/angular.js/1.4.6/angular.min.js"></script>
-
-ng-app 	 指令定义一个 AngularJS 应用程序。
-ng-model 指令把元素值（比如输入域的值）绑定到应用程序。
-ng-bind  指令把应用程序数据绑定到 HTML 视图。
-
-当网页加载完毕，AngularJS 自动开启。
-
-ng-app   指令告诉 AngularJS，<div> 元素是 AngularJS 应用程序 的"所有者"。
-ng-model 指令把输入域的值绑定到应用程序变量 name。
-ng-bind  指令把应用程序变量 name 绑定到某个段落的 innerHTML。
-ng-init  指令初始化 AngularJS 应用程序变量。
-
+<script src="http://cdn.static.runoob.com/libs/angular.js/1.4.6/angular.min.js"></script>
+
+ng-app 	 指令定义一个 AngularJS 应用程序。
+ng-model 指令把元素值（比如输入域的值）绑定到应用程序。
+ng-bind  指令把应用程序数据绑定到 HTML 视图。
+
+当网页加载完毕，AngularJS 自动开启。
+
+ng-app   指令告诉 AngularJS，<div> 元素是 AngularJS 应用程序 的"所有者"。
+ng-model 指令把输入域的值绑定到应用程序变量 name。
+ng-bind  指令把应用程序变量 name 绑定到某个段落的 innerHTML。
+ng-init  指令初始化 AngularJS 应用程序变量。
+
diff --git "a/14 - Front-end/NodeJS/node\345\256\211\350\243\205.txt" "b/14 - Front-end \345\211\215\347\253\257/NodeJS/node\345\256\211\350\243\205.txt"
similarity index 100%
rename from "14 - Front-end/NodeJS/node\345\256\211\350\243\205.txt"
rename to "14 - Front-end \345\211\215\347\253\257/NodeJS/node\345\256\211\350\243\205.txt"
diff --git a/14 - Front-end/NodeJS/server.js "b/14 - Front-end \345\211\215\347\253\257/NodeJS/server.js"
similarity index 96%
rename from 14 - Front-end/NodeJS/server.js
rename to "14 - Front-end \345\211\215\347\253\257/NodeJS/server.js"
index ba1f286e..f7fb94a4 100644
--- a/14 - Front-end/NodeJS/server.js	
+++ "b/14 - Front-end \345\211\215\347\253\257/NodeJS/server.js"	
@@ -1,15 +1,15 @@
-var http = require('http');
-
-http.createServer(function (request, response) {
-
-    // 发送 HTTP 头部 
-    // HTTP 状态值: 200 : OK
-    // 内容类型: text/plain
-    response.writeHead(200, {'Content-Type': 'text/plain'});
-
-    // 发送响应数据 "Hello World"
-    response.end('Hello World\n');
-}).listen(8888);
-
-// 终端打印如下信息
+var http = require('http');
+
+http.createServer(function (request, response) {
+
+    // 发送 HTTP 头部 
+    // HTTP 状态值: 200 : OK
+    // 内容类型: text/plain
+    response.writeHead(200, {'Content-Type': 'text/plain'});
+
+    // 发送响应数据 "Hello World"
+    response.end('Hello World\n');
+}).listen(8888);
+
+// 终端打印如下信息
 console.log('Server running at http://127.0.0.1:8888/');
\ No newline at end of file
diff --git a/14 - Front-end/all.txt "b/14 - Front-end \345\211\215\347\253\257/all.txt"
similarity index 96%
rename from 14 - Front-end/all.txt
rename to "14 - Front-end \345\211\215\347\253\257/all.txt"
index 04e1a5d9..9288acc4 100644
--- a/14 - Front-end/all.txt	
+++ "b/14 - Front-end \345\211\215\347\253\257/all.txt"	
@@ -1,21 +1,21 @@
-
-
-AngularJS 引入
-<script src="http://cdn.static.runoob.com/libs/angular.js/1.4.6/angular.min.js"></script>
-
-Vue  引入  
-<script src="https://cdn.bootcss.com/vue/2.2.2/vue.min.js"></script>
-
-React 引入
-<script src="https://cdn.bootcss.com/react/15.4.2/react.min.js"></script>
-<script src="https://cdn.bootcss.com/react/15.4.2/react-dom.min.js"></script>
-<script src="https://cdn.bootcss.com/babel-standalone/6.22.1/babel.min.js"></script>
-
-Node 前端服务器 
-
-下载 安装 https://nodejs.org/en/download/
-
-npm 
-
-
-
+
+
+AngularJS 引入
+<script src="http://cdn.static.runoob.com/libs/angular.js/1.4.6/angular.min.js"></script>
+
+Vue  引入  
+<script src="https://cdn.bootcss.com/vue/2.2.2/vue.min.js"></script>
+
+React 引入
+<script src="https://cdn.bootcss.com/react/15.4.2/react.min.js"></script>
+<script src="https://cdn.bootcss.com/react/15.4.2/react-dom.min.js"></script>
+<script src="https://cdn.bootcss.com/babel-standalone/6.22.1/babel.min.js"></script>
+
+Node 前端服务器 
+
+下载 安装 https://nodejs.org/en/download/
+
+npm 
+
+
+
diff --git "a/14 - Front-end/echarts\347\233\264\347\272\277\346\233\262\347\272\277" "b/14 - Front-end \345\211\215\347\253\257/echarts\347\233\264\347\272\277\346\233\262\347\272\277"
similarity index 95%
rename from "14 - Front-end/echarts\347\233\264\347\272\277\346\233\262\347\272\277"
rename to "14 - Front-end \345\211\215\347\253\257/echarts\347\233\264\347\272\277\346\233\262\347\272\277"
index 8bf2a522..0b3b742b 100644
--- "a/14 - Front-end/echarts\347\233\264\347\272\277\346\233\262\347\272\277"	
+++ "b/14 - Front-end \345\211\215\347\253\257/echarts\347\233\264\347\272\277\346\233\262\347\272\277"	
@@ -1,12 +1,12 @@
-series : [
-      {
-           name:'your name',
-           symbol:'none',  //这句就是去掉点的
-           smooth:true,  //这句就是让曲线变平滑的
-           type:'line',
-           stack: '总量',
-           data:[0, 0, 0, 0, 0, 0, 0]
-
-       },
-
- ]  
+series : [
+      {
+           name:'your name',
+           symbol:'none',  //这句就是去掉点的
+           smooth:true,  //这句就是让曲线变平滑的
+           type:'line',
+           stack: '总量',
+           data:[0, 0, 0, 0, 0, 0, 0]
+
+       },
+
+ ]  
diff --git "a/14 - Front-end/hexo\345\215\232\345\256\242/1.md" "b/14 - Front-end \345\211\215\347\253\257/hexo\345\215\232\345\256\242/1.md"
similarity index 96%
rename from "14 - Front-end/hexo\345\215\232\345\256\242/1.md"
rename to "14 - Front-end \345\211\215\347\253\257/hexo\345\215\232\345\256\242/1.md"
index 9fdf41d8..ad076c94 100644
--- "a/14 - Front-end/hexo\345\215\232\345\256\242/1.md"	
+++ "b/14 - Front-end \345\211\215\347\253\257/hexo\345\215\232\345\256\242/1.md"	
@@ -1,11 +1,11 @@
-https://www.cnblogs.com/visugar/p/6821777.html
-
-
-node_modules：是依赖包
-public：存放的是生成的页面
-scaffolds：命令生成文章等的模板
-source：用命令创建的各种文章
-themes：主题
-_config.yml：整个博客的配置
-db.json：source解析所得到的
-package.json：项目所需模块项目的配置信息
+https://www.cnblogs.com/visugar/p/6821777.html
+
+
+node_modules：是依赖包
+public：存放的是生成的页面
+scaffolds：命令生成文章等的模板
+source：用命令创建的各种文章
+themes：主题
+_config.yml：整个博客的配置
+db.json：source解析所得到的
+package.json：项目所需模块项目的配置信息
diff --git a/14 - Front-end/js.txt "b/14 - Front-end \345\211\215\347\253\257/js.txt"
similarity index 97%
rename from 14 - Front-end/js.txt
rename to "14 - Front-end \345\211\215\347\253\257/js.txt"
index ee0fd07f..9f7732c2 100644
--- a/14 - Front-end/js.txt	
+++ "b/14 - Front-end \345\211\215\347\253\257/js.txt"	
@@ -1 +1 @@
-js继承，闭包，作用域链，原型链
+js继承，闭包，作用域链，原型链
diff --git "a/14 - Front-end/js/\345\216\237\345\236\213\351\223\276.md" "b/14 - Front-end \345\211\215\347\253\257/js/\345\216\237\345\236\213\351\223\276.md"
similarity index 98%
rename from "14 - Front-end/js/\345\216\237\345\236\213\351\223\276.md"
rename to "14 - Front-end \345\211\215\347\253\257/js/\345\216\237\345\236\213\351\223\276.md"
index 34ddefa9..9a4d7e66 100644
--- "a/14 - Front-end/js/\345\216\237\345\236\213\351\223\276.md"	
+++ "b/14 - Front-end \345\211\215\347\253\257/js/\345\216\237\345\236\213\351\223\276.md"	
@@ -1,17 +1,17 @@
-
-``` js
-var animal = function(){};
-var dog = function(){};
-
-animal.price = 2000;//
-dog.prototype = animal;
-var tidy = new dog();
-
-console.log(dog.price) //为什么输出 undefined
-console.log(tidy.price) //为什么输出 2000
-
-```
-因为原型链是依赖于 **__proto__** ，而不是 **prototype**。
-dog是函数对象，本身没有price属性，此时dog的__proto__属性指向的是其构造函数的原型。
-dog的构造函数就是Function，因为var dog = function(){};语句实际上是var dog = new Function();，所以，dog.__proto__ === Function.**prototype**；而Function.prototype并没有price属性，如果加一句：Function.prototype.price = 123；那么第一个打印就是123；
-如此依赖，tidy是一个普通对象，由dog函数构造而来，因此tidy.__proto__ == dog.**prototype** == animal；所以当tidy上找不到price属性时，会从__proto__寻找原型上的方法，找到animal对象，animal对象有price属性，则返回。
+
+``` js
+var animal = function(){};
+var dog = function(){};
+
+animal.price = 2000;//
+dog.prototype = animal;
+var tidy = new dog();
+
+console.log(dog.price) //为什么输出 undefined
+console.log(tidy.price) //为什么输出 2000
+
+```
+因为原型链是依赖于 **__proto__** ，而不是 **prototype**。
+dog是函数对象，本身没有price属性，此时dog的__proto__属性指向的是其构造函数的原型。
+dog的构造函数就是Function，因为var dog = function(){};语句实际上是var dog = new Function();，所以，dog.__proto__ === Function.**prototype**；而Function.prototype并没有price属性，如果加一句：Function.prototype.price = 123；那么第一个打印就是123；
+如此依赖，tidy是一个普通对象，由dog函数构造而来，因此tidy.__proto__ == dog.**prototype** == animal；所以当tidy上找不到price属性时，会从__proto__寻找原型上的方法，找到animal对象，animal对象有price属性，则返回。
diff --git "a/14 - Front-end/js/\345\270\270\347\224\250\344\273\243\347\240\201.md" "b/14 - Front-end \345\211\215\347\253\257/js/\345\270\270\347\224\250\344\273\243\347\240\201.md"
similarity index 96%
rename from "14 - Front-end/js/\345\270\270\347\224\250\344\273\243\347\240\201.md"
rename to "14 - Front-end \345\211\215\347\253\257/js/\345\270\270\347\224\250\344\273\243\347\240\201.md"
index a909db00..db8fa347 100644
--- "a/14 - Front-end/js/\345\270\270\347\224\250\344\273\243\347\240\201.md"	
+++ "b/14 - Front-end \345\211\215\347\253\257/js/\345\270\270\347\224\250\344\273\243\347\240\201.md"	
@@ -1,147 +1,147 @@
-根据属性找元素 https://www.jianshu.com/p/4a504943751e
-```html
-<!DOCTYPE html>
-<html>
-     <head>
-           <meta charset= "utf-8" >
-           <title >js根据属性值获取元素</title >
-     </head >
-     <body >        
-        <div node="a1">q1</div>
-        <div node="a2">q2</div>
-        <div node="a3">q3</div>
-        <div node="a1">q11</div>
-        <div node="a2">q12</div>
-        <div node="a3">q13</div>
-        <div node="a1">q21</div>
-        <div node="a2">q22</div>
-        <div node="a3">q23</div>
-     </body>
-</html>
-<script>
-<!--使用jQuery-->
-$('div[node="a1"]')
-<!--使用原生js-->
-function getDom(tagName,name,value){
-    var selectDom = [];
-    var dom=document.getElementsByTagName(tagName);
-    for (var i=0; i<dom.length; i++) {
-        if(value===dom[i].getAttribute(name)){
-            selectDom.push(dom[i]);
-        }
-    }
-    return selectDom;
-}
-getDom('div','node','a1')
-</script>
-```
-### 获取焦点
- $("#Tree_select").focus(); 必须要界面上鼠标能进去的焦点
-
-### select 常用
-移除
-$("#taskTypeID_edit option[value='1']").remove();
-添加
-$("#taskTypeID_edit").append("<option value='1'>全局任务</option>");
-设值
-$("#taskTypeID_edit").val("1");
-选值
-$("#taskTypeID_edit option:selected").val(),
-
-### jQuery对css进行编写
-$("#id").css('background-color', '#E3E3E3')
-$(".l-window-mask").css({"display":"block"});
-
-### js 对 display进行操作
-document.getElementById("id").style.display='';
-document.getElementById("id").style.display='none';
-
-### 对readonly操作 js 和 jQuery
-document.getElementById("id").readOnly=true;
-document.getElementById("id").readOnly=false;
-
-$("#id").attr('readonly','readonly');
-
-### disabled
-document.getElementById("startTime_edit").disabled=false;
-
-$("#exeCount_edit").attr('disabled','disabled');
-
-$("#").removeAttr("disabled");
-
-### 删除class属于
-removeClass("disabledClass");
-
-获取
-$("#w3s").attr("href")
-
-
-### 定时任务 1000 1s一次
-var timetask = setInterval(function(){
-	//定时循环任务体
-}, 1000);
-
-### 关闭定时任务
-clearInterval(timetask);
-
-### 延时任务
-3s后弹出
-setTimeout("alert('对不起, 要你久候')", 3000 )
-
-
-### 当前鼠标的聚焦点 取id tag
-document.activeElement.tagName
-document.activeElement.id
-
-### 通过属性选择
- $('a[hreflang|="en"]').css("border","2px solid red");
-
-
-### 遮罩层
-$("<div id='l-window-mask_treeselect' class='l-window-mask'></div>").appendTo("body").css({"z-index":"9100","display":"block"});
-
-### 移除
-$().remove();
-
-###
-//日期long to YYYY-MM-DD
-var fmtDate = ns.fmtDate = function(obj) {
-	var endDate = new Date();
-	endDate.setTime(obj);
-	var year = endDate.getFullYear();
-	var month = endDate.getMonth() + 1;
-	var day = endDate.getDate();
-	if(month < 10) month = "0" + month;
-	if(day < 10) day = "0" + day;
-	return year + "-" + month + "-" + day;
-}
-
-//时间long to HH:mm:ss
-var millisecondFmt = ns.millisecondFmt = function(time) {
-	time = parseInt(time);
-	time = time / 1000;
-	var hh;
-	var mm;
-	var ss;
-	if(time == null || time < 0) {
-		return;
-	}
-	hh = time / 3600 | 0;
-	time = parseInt(time) - hh * 3600;
-	if(parseInt(hh) < 10) {
-		hh = "0" + hh;
-	}
-	mm = time / 60 | 0;
-	ss = parseInt(time) - mm * 60;
-	if(parseInt(mm) < 10) {
-		mm = "0" + mm;
-	}
-	if(ss < 10){
-		ss = "0" + ss;
-	}
-	return hh + ":" + mm + ":" + ss;
-}
-
-### 文件大小
-FireFox、Chrome浏览器中可以根据 **document.getElementById(“id_file”).files[0].size** 获取上传文件的大小（字节数）byte
-而IE浏览器中不支持该属性，只能借助<img>标签的dynsrc属性，来间接实现获取文件的大小（但需要同意ActiveX控件的运行，但是不会引起上面的不友好、不安全的提示）。
+根据属性找元素 https://www.jianshu.com/p/4a504943751e
+```html
+<!DOCTYPE html>
+<html>
+     <head>
+           <meta charset= "utf-8" >
+           <title >js根据属性值获取元素</title >
+     </head >
+     <body >        
+        <div node="a1">q1</div>
+        <div node="a2">q2</div>
+        <div node="a3">q3</div>
+        <div node="a1">q11</div>
+        <div node="a2">q12</div>
+        <div node="a3">q13</div>
+        <div node="a1">q21</div>
+        <div node="a2">q22</div>
+        <div node="a3">q23</div>
+     </body>
+</html>
+<script>
+<!--使用jQuery-->
+$('div[node="a1"]')
+<!--使用原生js-->
+function getDom(tagName,name,value){
+    var selectDom = [];
+    var dom=document.getElementsByTagName(tagName);
+    for (var i=0; i<dom.length; i++) {
+        if(value===dom[i].getAttribute(name)){
+            selectDom.push(dom[i]);
+        }
+    }
+    return selectDom;
+}
+getDom('div','node','a1')
+</script>
+```
+### 获取焦点
+ $("#Tree_select").focus(); 必须要界面上鼠标能进去的焦点
+
+### select 常用
+移除
+$("#taskTypeID_edit option[value='1']").remove();
+添加
+$("#taskTypeID_edit").append("<option value='1'>全局任务</option>");
+设值
+$("#taskTypeID_edit").val("1");
+选值
+$("#taskTypeID_edit option:selected").val(),
+
+### jQuery对css进行编写
+$("#id").css('background-color', '#E3E3E3')
+$(".l-window-mask").css({"display":"block"});
+
+### js 对 display进行操作
+document.getElementById("id").style.display='';
+document.getElementById("id").style.display='none';
+
+### 对readonly操作 js 和 jQuery
+document.getElementById("id").readOnly=true;
+document.getElementById("id").readOnly=false;
+
+$("#id").attr('readonly','readonly');
+
+### disabled
+document.getElementById("startTime_edit").disabled=false;
+
+$("#exeCount_edit").attr('disabled','disabled');
+
+$("#").removeAttr("disabled");
+
+### 删除class属于
+removeClass("disabledClass");
+
+获取
+$("#w3s").attr("href")
+
+
+### 定时任务 1000 1s一次
+var timetask = setInterval(function(){
+	//定时循环任务体
+}, 1000);
+
+### 关闭定时任务
+clearInterval(timetask);
+
+### 延时任务
+3s后弹出
+setTimeout("alert('对不起, 要你久候')", 3000 )
+
+
+### 当前鼠标的聚焦点 取id tag
+document.activeElement.tagName
+document.activeElement.id
+
+### 通过属性选择
+ $('a[hreflang|="en"]').css("border","2px solid red");
+
+
+### 遮罩层
+$("<div id='l-window-mask_treeselect' class='l-window-mask'></div>").appendTo("body").css({"z-index":"9100","display":"block"});
+
+### 移除
+$().remove();
+
+###
+//日期long to YYYY-MM-DD
+var fmtDate = ns.fmtDate = function(obj) {
+	var endDate = new Date();
+	endDate.setTime(obj);
+	var year = endDate.getFullYear();
+	var month = endDate.getMonth() + 1;
+	var day = endDate.getDate();
+	if(month < 10) month = "0" + month;
+	if(day < 10) day = "0" + day;
+	return year + "-" + month + "-" + day;
+}
+
+//时间long to HH:mm:ss
+var millisecondFmt = ns.millisecondFmt = function(time) {
+	time = parseInt(time);
+	time = time / 1000;
+	var hh;
+	var mm;
+	var ss;
+	if(time == null || time < 0) {
+		return;
+	}
+	hh = time / 3600 | 0;
+	time = parseInt(time) - hh * 3600;
+	if(parseInt(hh) < 10) {
+		hh = "0" + hh;
+	}
+	mm = time / 60 | 0;
+	ss = parseInt(time) - mm * 60;
+	if(parseInt(mm) < 10) {
+		mm = "0" + mm;
+	}
+	if(ss < 10){
+		ss = "0" + ss;
+	}
+	return hh + ":" + mm + ":" + ss;
+}
+
+### 文件大小
+FireFox、Chrome浏览器中可以根据 **document.getElementById(“id_file”).files[0].size** 获取上传文件的大小（字节数）byte
+而IE浏览器中不支持该属性，只能借助<img>标签的dynsrc属性，来间接实现获取文件的大小（但需要同意ActiveX控件的运行，但是不会引起上面的不友好、不安全的提示）。
diff --git "a/14 - Front-end/js/\346\273\232\345\212\250\346\235\241\344\275\215\347\275\256\345\256\232\344\275\215.txt" "b/14 - Front-end \345\211\215\347\253\257/js/\346\273\232\345\212\250\346\235\241\344\275\215\347\275\256\345\256\232\344\275\215.txt"
similarity index 96%
rename from "14 - Front-end/js/\346\273\232\345\212\250\346\235\241\344\275\215\347\275\256\345\256\232\344\275\215.txt"
rename to "14 - Front-end \345\211\215\347\253\257/js/\346\273\232\345\212\250\346\235\241\344\275\215\347\275\256\345\256\232\344\275\215.txt"
index 78ad8e43..e31874e3 100644
--- "a/14 - Front-end/js/\346\273\232\345\212\250\346\235\241\344\275\215\347\275\256\345\256\232\344\275\215.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/js/\346\273\232\345\212\250\346\235\241\344\275\215\347\275\256\345\256\232\344\275\215.txt"	
@@ -1,16 +1,16 @@
-<div class="of-y" id="nurse" >
-　　<table class="high width" id="nurse-plan">
-<tr id="tr-one"></tr>
-<tr id="tr-two"></tr>
-<tr id="tr-three"></tr>
-<tr id="tr-four"></tr>
-</table>
-</div>
-
-
-// 定位
-$("#nurse").scrollTop($("#nurse").scrollTop() + $('#tr-three').offset().top - $("#nurse").offset().top); --普通
-$("#nurse").animate({ scrollTop: $("#nurse").scrollTop() + $('#tr-three').offset().top - $("#nurse").offset().top }, 1000); --有动画效果
-				 
-				 
+<div class="of-y" id="nurse" >
+　　<table class="high width" id="nurse-plan">
+<tr id="tr-one"></tr>
+<tr id="tr-two"></tr>
+<tr id="tr-three"></tr>
+<tr id="tr-four"></tr>
+</table>
+</div>
+
+
+// 定位
+$("#nurse").scrollTop($("#nurse").scrollTop() + $('#tr-three').offset().top - $("#nurse").offset().top); --普通
+$("#nurse").animate({ scrollTop: $("#nurse").scrollTop() + $('#tr-three').offset().top - $("#nurse").offset().top }, 1000); --有动画效果
+				 
+				 
 				 
\ No newline at end of file
diff --git "a/14 - Front-end/js/\351\227\255\345\214\205.md" "b/14 - Front-end \345\211\215\347\253\257/js/\351\227\255\345\214\205.md"
similarity index 98%
rename from "14 - Front-end/js/\351\227\255\345\214\205.md"
rename to "14 - Front-end \345\211\215\347\253\257/js/\351\227\255\345\214\205.md"
index 2aeee09a..ed3365d5 100644
--- "a/14 - Front-end/js/\351\227\255\345\214\205.md"	
+++ "b/14 - Front-end \345\211\215\347\253\257/js/\351\227\255\345\214\205.md"	
@@ -1,32 +1,32 @@
-
-
-目前以上答案似乎都只是再说闭包是个什么样子。补充一点吧。
-近似正确的短答案：
-**闭包就是一个函数把外部的那些不属于自己的对象也包含（闭合）进来了。**
-短答案：JavaScript中的闭包，无非就是变量解析的过程。
-首先看一段话：每次定义一个函数，都会产生一个作用域链（scope chain）。
-当JavaScript寻找变量varible时（这个过程称为 **变量解析**），总会优先在当前作用域链的第一个对象中查找属性varible ，如果找到，则直接使用这个属性；否则，继续查找下一个对象的是否存在这个属性；这个过程会持续直至找到这个属性或者最终未找到引发错误为止。看个简单版的例子：
-``` js
-(function(){
-    var hello="hello,world";
-    function welcome(hi){
-        alert(hi);        //解析到作用域链的第一个对象的属性
-        alert(hello);    //解析到作用域链的第二个对象的属性
-    }
-    welcome("It's easy");
-})();
-```
-运行结果很简单，一个弹窗It's easy.一个弹窗hello,world。
-分析过程如下：对于函数welcome()，定义welcome的时候会产生一个作用域链对象，为了表示方便，记作scopechain。
-scopechain是个有顺序的集合对象。
-scopechain的第一个对象：为了方便表示记作sc1， sc1有若干属性，引用本函数的参数和局部变量，如sc1.hi ；
-scopechain的第二个对象：为了方便表示记作sc2， sc2有若干属性，引用外层函数的参数和局部变量，如sc2.hello；
-...scopechain的最后一个对象：为了方便表示记作scn，scn引用的全局的执行环境对象，也就是window对象！，如scn.eval()；
-这里之所以可以弹出hello,world，原因就是变量解析时在welcome函数作用域链的第一个对象上找不到hello属性，然后就去第二个对象上找去了（结果还真找到了）。
-所以，JavaScript中的所谓的高大上的闭包其实很简单，**根本上还是变量解析**。而之所以可以实现，还是因为变量解析会在作用域链中依次寻找对应属性的导致的。
-
-
-作者：大水
-链接：https://www.zhihu.com/question/34547104/answer/59515735
-来源：知乎
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+目前以上答案似乎都只是再说闭包是个什么样子。补充一点吧。
+近似正确的短答案：
+**闭包就是一个函数把外部的那些不属于自己的对象也包含（闭合）进来了。**
+短答案：JavaScript中的闭包，无非就是变量解析的过程。
+首先看一段话：每次定义一个函数，都会产生一个作用域链（scope chain）。
+当JavaScript寻找变量varible时（这个过程称为 **变量解析**），总会优先在当前作用域链的第一个对象中查找属性varible ，如果找到，则直接使用这个属性；否则，继续查找下一个对象的是否存在这个属性；这个过程会持续直至找到这个属性或者最终未找到引发错误为止。看个简单版的例子：
+``` js
+(function(){
+    var hello="hello,world";
+    function welcome(hi){
+        alert(hi);        //解析到作用域链的第一个对象的属性
+        alert(hello);    //解析到作用域链的第二个对象的属性
+    }
+    welcome("It's easy");
+})();
+```
+运行结果很简单，一个弹窗It's easy.一个弹窗hello,world。
+分析过程如下：对于函数welcome()，定义welcome的时候会产生一个作用域链对象，为了表示方便，记作scopechain。
+scopechain是个有顺序的集合对象。
+scopechain的第一个对象：为了方便表示记作sc1， sc1有若干属性，引用本函数的参数和局部变量，如sc1.hi ；
+scopechain的第二个对象：为了方便表示记作sc2， sc2有若干属性，引用外层函数的参数和局部变量，如sc2.hello；
+...scopechain的最后一个对象：为了方便表示记作scn，scn引用的全局的执行环境对象，也就是window对象！，如scn.eval()；
+这里之所以可以弹出hello,world，原因就是变量解析时在welcome函数作用域链的第一个对象上找不到hello属性，然后就去第二个对象上找去了（结果还真找到了）。
+所以，JavaScript中的所谓的高大上的闭包其实很简单，**根本上还是变量解析**。而之所以可以实现，还是因为变量解析会在作用域链中依次寻找对应属性的导致的。
+
+
+作者：大水
+链接：https://www.zhihu.com/question/34547104/answer/59515735
+来源：知乎
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
diff --git a/14 - Front-end/jscon.html "b/14 - Front-end \345\211\215\347\253\257/jscon.html"
similarity index 97%
rename from 14 - Front-end/jscon.html
rename to "14 - Front-end \345\211\215\347\253\257/jscon.html"
index 7b4f6572..0d00ab61 100644
--- a/14 - Front-end/jscon.html	
+++ "b/14 - Front-end \345\211\215\347\253\257/jscon.html"	
@@ -1,253 +1,253 @@
-<!DOCTYPE html>
-<html>
-	
-
-<head>
-	
-<body  bgcolor="#ffffff"  onLoad="document.form.input.focus()">
-
-	
-	
-	 <SCRIPT LANGUAGE="JavaScript">
-<!-- Begin
-function doit() {
-form.input.value = eval(form.input.value)
-}
-function Cos() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.cos(x);
-}
-function Sin() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.sin(x);
-}
-function Ln() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.log(x);
-}
-function Root() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.sqrt(x);
-}
-function Tan() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.tan(x);
-}
-function Icos() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.acos(x);
-}
-function Isin() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.asin(x);
-}
-function Itan() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.atan(x);
-}
-function Round() {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else form.input.value = Math.round(x);
-}
-function Ran() {
-x = form.input.value
-form.input.value = Math.random(x);
-}
-function Neg () {
-x = form.input.value
-if (x == '') alert('Error: Input Required');
-else x = parseFloat(x) * -1;
-}
-function del() {
-x = form.input.value
-x = (x.substring) - 1
-}
-//  End -->
-</script>
-<div align="center">
-<form name="form" method="post" action="javascript:doit()">
-  <table width="260" border="0" height="260" align="center" bordercolor="#000000" bgcolor="#000000">
-    <tr bgcolor="#000000">
-      <td colspan="7" height="2">
-        <div align="center"><b><font face="Arial, Helvetica, sans-serif" color="#FFFFFF">考勤计算器</font></b></div>
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td colspan="7" height="2">
-        <div align="center">
-          <input type="text"   name="input" size="40">
-        </div>
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50" height="4">
-        <input type="button" name="one"   value="1" onClick="form.input.value += '1'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="4">
-        <input type="button" name="two"   value="2" onClick="form.input.value += '2'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="4">
-        <input type="button" name="three" value="3" onClick="form.input.value += '3'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20" height="4"> </td>
-      <td width="50" height="4">
-        <input type="button" name="clear" value="C" onClick="form.input.value = ''" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #9F0004; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="4">
-        <input type="button" name="percent" value=" % " onClick="form.input.value = eval(form.input.value) / 100" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="4">
-        <input type="button" name="(" value=" ( " onClick="form.input.value += '('" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50" height="2">
-        <input type="button" name="four"  value="4" onClick="form.input.value += '4'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="five"  value="5" onClick="form.input.value += '5'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="six"   value="6" onClick="form.input.value += '6'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20" height="2">  </td>
-      <td width="50" height="2">
-        <input type="button" name="times" value="  x  " onClick="form.input.value += ' * '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="div"   value="  /  " onClick="form.input.value += ' / '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name=")" value=" ) " onClick="form.input.value += ')'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50" height="2">
-        <input type="button" name="seven" value="7" onClick="form.input.value += '7'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="eight" value="8" onClick="form.input.value += '8'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="nine"  value="9" onClick="form.input.value += '9'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20" height="2">  </td>
-      <td width="50" height="2">
-        <input type="button" name="plus"  value="  +  " onClick="form.input.value += ' + '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="minus" value="  -  " onClick="form.input.value += ' - '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="round" value="Rnd" onClick="Round()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50" height="2">
-        <input type="button" name="zero"  value="0" onClick="form.input.value += '0'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="point" value="." onClick="form.input.value += '.'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="pi" value="PI" onClick="form.input.value += '3.1415926535897932384626433832795'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20" height="2">  </td>
-      <td width="50" height="2">
-        <input type="button" name="pi2" value="+/-" onClick="Neg()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="DoIt"  value=" = " onClick="doit()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50" height="2">
-        <input type="button" name="round2" value="Ran#" onClick="Ran()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50" height="24"> </td>
-      <td width="50" height="24"> </td>
-      <td width="50" height="24"> </td>
-      <td width="20" height="24"> </td>
-      <td width="50" height="24">  </td>
-      <td width="50" height="24"> </td>
-      <td width="50" height="24"> </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50">
-        <input type="button" name="quad" value="^2" onClick="form.input.value = form.input.value * form.input.value" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="root" value="root" onClick="Root()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="ln" value="ln" onClick="Ln()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20"> </td>
-      <td width="50">
-        <input type="button" name="1/2" value="1/2" onClick="form.input.value += '0.5'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="1/3" value="1/3" onClick="form.input.value += '0.3333333333'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="1/4" value="1/4" onClick="form.input.value += '0.25'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50">
-        <input type="button" name="sin" value="sin" onClick="Sin()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="cos" value="cos" onClick="Cos()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="tan" value="tan" onClick="Tan()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20"> </td>
-      <td width="50">
-        <input type="button" name="1/5" value="1/5" onClick="form.input.value += '0.2'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="1/6" value="1/6" onClick="form.input.value += '0.1666666667'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="1/7" value="1/7" onClick="form.input.value += '0.1428571429'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-    <tr bgcolor="#000000">
-      <td width="50">
-        <input type="button" name="sin2" value="asin" onClick="Isin()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="cos2" value="acos" onClick="Icos()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="tan2" value="atan" onClick="Itan()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="20"> </td>
-      <td width="50">
-        <input type="button" name="1/8" value="1/8" onClick="form.input.value += '0.125'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="1/9" value="1/9" onClick="form.input.value += '0.1111111111'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-      <td width="50">
-        <input type="button" name="1/10" value="1/10" onClick="form.input.value += '0.1'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
-      </td>
-    </tr>
-  </table>
-</form>
-</div> 
-</body>
-
-</head>
+<!DOCTYPE html>
+<html>
+	
+
+<head>
+	
+<body  bgcolor="#ffffff"  onLoad="document.form.input.focus()">
+
+	
+	
+	 <SCRIPT LANGUAGE="JavaScript">
+<!-- Begin
+function doit() {
+form.input.value = eval(form.input.value)
+}
+function Cos() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.cos(x);
+}
+function Sin() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.sin(x);
+}
+function Ln() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.log(x);
+}
+function Root() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.sqrt(x);
+}
+function Tan() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.tan(x);
+}
+function Icos() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.acos(x);
+}
+function Isin() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.asin(x);
+}
+function Itan() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.atan(x);
+}
+function Round() {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else form.input.value = Math.round(x);
+}
+function Ran() {
+x = form.input.value
+form.input.value = Math.random(x);
+}
+function Neg () {
+x = form.input.value
+if (x == '') alert('Error: Input Required');
+else x = parseFloat(x) * -1;
+}
+function del() {
+x = form.input.value
+x = (x.substring) - 1
+}
+//  End -->
+</script>
+<div align="center">
+<form name="form" method="post" action="javascript:doit()">
+  <table width="260" border="0" height="260" align="center" bordercolor="#000000" bgcolor="#000000">
+    <tr bgcolor="#000000">
+      <td colspan="7" height="2">
+        <div align="center"><b><font face="Arial, Helvetica, sans-serif" color="#FFFFFF">考勤计算器</font></b></div>
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td colspan="7" height="2">
+        <div align="center">
+          <input type="text"   name="input" size="40">
+        </div>
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50" height="4">
+        <input type="button" name="one"   value="1" onClick="form.input.value += '1'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="4">
+        <input type="button" name="two"   value="2" onClick="form.input.value += '2'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="4">
+        <input type="button" name="three" value="3" onClick="form.input.value += '3'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20" height="4"> </td>
+      <td width="50" height="4">
+        <input type="button" name="clear" value="C" onClick="form.input.value = ''" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #9F0004; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="4">
+        <input type="button" name="percent" value=" % " onClick="form.input.value = eval(form.input.value) / 100" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="4">
+        <input type="button" name="(" value=" ( " onClick="form.input.value += '('" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50" height="2">
+        <input type="button" name="four"  value="4" onClick="form.input.value += '4'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="five"  value="5" onClick="form.input.value += '5'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="six"   value="6" onClick="form.input.value += '6'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20" height="2">  </td>
+      <td width="50" height="2">
+        <input type="button" name="times" value="  x  " onClick="form.input.value += ' * '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="div"   value="  /  " onClick="form.input.value += ' / '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name=")" value=" ) " onClick="form.input.value += ')'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50" height="2">
+        <input type="button" name="seven" value="7" onClick="form.input.value += '7'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="eight" value="8" onClick="form.input.value += '8'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="nine"  value="9" onClick="form.input.value += '9'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20" height="2">  </td>
+      <td width="50" height="2">
+        <input type="button" name="plus"  value="  +  " onClick="form.input.value += ' + '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="minus" value="  -  " onClick="form.input.value += ' - '" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="round" value="Rnd" onClick="Round()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50" height="2">
+        <input type="button" name="zero"  value="0" onClick="form.input.value += '0'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="point" value="." onClick="form.input.value += '.'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="pi" value="PI" onClick="form.input.value += '3.1415926535897932384626433832795'" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #666666; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20" height="2">  </td>
+      <td width="50" height="2">
+        <input type="button" name="pi2" value="+/-" onClick="Neg()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="DoIt"  value=" = " onClick="doit()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50" height="2">
+        <input type="button" name="round2" value="Ran#" onClick="Ran()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50" height="24"> </td>
+      <td width="50" height="24"> </td>
+      <td width="50" height="24"> </td>
+      <td width="20" height="24"> </td>
+      <td width="50" height="24">  </td>
+      <td width="50" height="24"> </td>
+      <td width="50" height="24"> </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50">
+        <input type="button" name="quad" value="^2" onClick="form.input.value = form.input.value * form.input.value" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="root" value="root" onClick="Root()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="ln" value="ln" onClick="Ln()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20"> </td>
+      <td width="50">
+        <input type="button" name="1/2" value="1/2" onClick="form.input.value += '0.5'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="1/3" value="1/3" onClick="form.input.value += '0.3333333333'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="1/4" value="1/4" onClick="form.input.value += '0.25'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50">
+        <input type="button" name="sin" value="sin" onClick="Sin()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="cos" value="cos" onClick="Cos()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="tan" value="tan" onClick="Tan()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20"> </td>
+      <td width="50">
+        <input type="button" name="1/5" value="1/5" onClick="form.input.value += '0.2'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="1/6" value="1/6" onClick="form.input.value += '0.1666666667'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="1/7" value="1/7" onClick="form.input.value += '0.1428571429'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+    <tr bgcolor="#000000">
+      <td width="50">
+        <input type="button" name="sin2" value="asin" onClick="Isin()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="cos2" value="acos" onClick="Icos()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="tan2" value="atan" onClick="Itan()" style="COLOR: #FFFFFF; BACKGROUND-COLOR: #333333; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="20"> </td>
+      <td width="50">
+        <input type="button" name="1/8" value="1/8" onClick="form.input.value += '0.125'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="1/9" value="1/9" onClick="form.input.value += '0.1111111111'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+      <td width="50">
+        <input type="button" name="1/10" value="1/10" onClick="form.input.value += '0.1'" style="COLOR: #B3B300; BACKGROUND-COLOR: #000000; HEIGHT: 25 px; WIDTH: 40px">
+      </td>
+    </tr>
+  </table>
+</form>
+</div> 
+</body>
+
+</head>
 </html>
\ No newline at end of file
diff --git "a/14 - Front-end/jstree/json\346\240\274\345\274\217.md" "b/14 - Front-end \345\211\215\347\253\257/jstree/json\346\240\274\345\274\217.md"
similarity index 100%
rename from "14 - Front-end/jstree/json\346\240\274\345\274\217.md"
rename to "14 - Front-end \345\211\215\347\253\257/jstree/json\346\240\274\345\274\217.md"
diff --git "a/14 - Front-end/jstree/\346\234\215\345\212\241\345\231\250demo.txt" "b/14 - Front-end \345\211\215\347\253\257/jstree/\346\234\215\345\212\241\345\231\250demo.txt"
similarity index 96%
rename from "14 - Front-end/jstree/\346\234\215\345\212\241\345\231\250demo.txt"
rename to "14 - Front-end \345\211\215\347\253\257/jstree/\346\234\215\345\212\241\345\231\250demo.txt"
index 7672e12c..4cc801b8 100644
--- "a/14 - Front-end/jstree/\346\234\215\345\212\241\345\231\250demo.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/jstree/\346\234\215\345\212\241\345\231\250demo.txt"	
@@ -1,227 +1,227 @@
-	
-	html
-	<div id="grouptree" style="height: 430px;"></div>
-	
-	css
-	<link type="text/css" rel="stylesheet" href="jstree/dist/themes/default/style.min.css" />
-
-	js
-	<script type="text/javascript" src="jstree/dist/libs/jquery.js"></script>
-	<script type="text/javascript" src="jstree/dist/jstree.min.js"></script>
-	
-	
-	$(function() {
-		$('#grouptree').on("changed.jstree",function(e, data) {
-			if (data.selected.length) {
-				alert('The selected node is: '
-					+ data.instance.get_node(data.selected[0]).text);
-				}
-		}).jstree({
-			'core' : {
-				'data' : {
-					'url' : 'jSTree/returnJson', //底层封装url
-					'data' : function(node) {
-						return {
-							'id' : node.id
-						};
-					}
-				},
-			},
-			'plugins' : [ 'wholerow' ]
-		})
-		.on("activate_node.jstree", function(obj, e) {
-			var id = e.node.id;
-			if (id.charAt(0) == 4) { //判断字符串第一个字符是否为4      字符串下标以0开头
-				$("#editcode").append(id.substring(id.indexOf("_") + 1)); //点击事件   此方法为第四层时向文本添加字符串切割下划线之后的内容  字符串操作包含头不包含尾
-			}
-		});
-		var to = false; //自带搜索功能
-		$('#search').click(function() {
-			if (to) {
-				clearTimeout(to);
-			}
-			to = setTimeout(function() {
-				var v = $('#searchname').val();
-				$('#edittree').jstree(true).search(v);
-			}, 250);
-		});
-
-	});
-	
-	
-	服务端
-	VO:
-	
-		public class JSTreeVO {
-		
-			private String id;
-
-			private String text;
-
-			private Boolean children;
-
-			private String icon;
-
-			public String getText() {
-				return text;
-			}
-
-			public void setText(String text) {
-				this.text = text;
-			}
-
-			public Boolean getChildren() {
-				return children;
-			}
-
-			public void setChildren(Boolean children) {
-				this.children = children;
-			}
-
-			public String getIcon() {
-				return icon;
-			}
-
-			public void setIcon(String icon) {
-				this.icon = icon;
-			}
-
-			public String getId() {
-				return id;
-			}
-
-			public void setId(String id) {
-				this.id = id;
-			}
-
-			@Override
-			public String toString() {
-				return "JSTreeVO [id=" + id + ", text=" + text + ", children=" + children + ", icon=" + icon + "]";
-			}
-
-		}
-	
-	Controller:
-	
-		import java.util.ArrayList;
-		import java.util.List;
-
-		import javax.servlet.http.HttpServletRequest;
-		import javax.servlet.http.HttpSession;
-
-		import org.apache.log4j.Logger;
-		import org.springframework.context.annotation.Scope;
-		import org.springframework.stereotype.Controller;
-		import org.springframework.web.bind.annotation.RequestMapping;
-		import org.springframework.web.bind.annotation.RequestMethod;
-		import org.springframework.web.bind.annotation.RequestParam;
-		import org.springframework.web.bind.annotation.ResponseBody;
-
-		import com.kedacom.tsu.model.VO.JSTreeVO;
-
-		@Controller("jSTreeController")
-		@RequestMapping("/jSTree")
-		@Scope("prototype")
-		public class JSTreeController {
-			
-			private static Logger log = Logger.getLogger(JSTreeController.class);
-			
-			@RequestMapping(value="/returnJson",method = RequestMethod.POST)
-			@ResponseBody
-			public List<JSTreeVO> retrunsoc(
-					@RequestParam(value = "id", defaultValue = "#", required = false) String id,
-					HttpServletRequest request, HttpSession session) {
-				log.info(id);
-				
-				List<JSTreeVO> jsonlist = new ArrayList<JSTreeVO>();
-
-				if ("#".equals(id)) {
-					
-					JSTreeVO jsTreeVO = new JSTreeVO();
-					jsTreeVO.setChildren(true);
-					//当设置成true时，点击该树节点，jstree就会进行一次请求，请求的url和data配置就是初始化jstree中的那些。
-					//当设置成false时，jstree就将该节点当成叶子节点
-					jsTreeVO.setId("1");
-					jsTreeVO.setText("ROOT");
-					jsonlist.add(jsTreeVO);
-					
-				} else if ("1".equals(id)) {// 分割拼接的字符串 _前面为层数 后面为id 
-					
-					JSTreeVO jsTreeVO = new JSTreeVO();
-					jsTreeVO.setChildren(false);
-					jsTreeVO.setId("11");
-					jsTreeVO.setText("11");
-					jsonlist.add(jsTreeVO);
-					
-					JSTreeVO jsTreeVO2 = new JSTreeVO();
-					jsTreeVO2.setChildren(true);
-					jsTreeVO2.setId("12");
-					jsTreeVO2.setText("12");
-					jsonlist.add(jsTreeVO2);
-					
-					JSTreeVO jsTreeVO3 = new JSTreeVO();
-					jsTreeVO3.setChildren(false);
-					jsTreeVO3.setId("13");
-					jsTreeVO3.setText("13");
-					jsonlist.add(jsTreeVO3);
-					
-					JSTreeVO jsTreeVO4 = new JSTreeVO();
-					jsTreeVO4.setChildren(false);
-					jsTreeVO4.setId("14");
-					jsTreeVO4.setText("14");
-					jsonlist.add(jsTreeVO4);
-					
-					JSTreeVO jsTreeVO5 = new JSTreeVO();
-					jsTreeVO5.setChildren(false);
-					jsTreeVO5.setId("15");
-					jsTreeVO5.setText("15");
-					jsonlist.add(jsTreeVO5);
-					
-					
-				} else if ("12".equals(id)) {
-					JSTreeVO jsTreeVO = new JSTreeVO();
-					jsTreeVO.setChildren(true);
-					jsTreeVO.setId("121");
-					jsTreeVO.setText("121");
-					jsonlist.add(jsTreeVO);
-					
-					JSTreeVO jsTreeVO2 = new JSTreeVO();
-					jsTreeVO2.setChildren(false);
-					jsTreeVO2.setId("122");
-					jsTreeVO2.setText("122");
-					jsonlist.add(jsTreeVO2);
-					
-					JSTreeVO jsTreeVO3 = new JSTreeVO();
-					jsTreeVO3.setChildren(false);
-					jsTreeVO3.setId("123");
-					jsTreeVO3.setText("123");
-					jsonlist.add(jsTreeVO3);
-				} else if ("121".equals(id)) {
-					JSTreeVO jsTreeVO = new JSTreeVO();
-					jsTreeVO.setChildren(false);
-					jsTreeVO.setId("1211");
-					jsTreeVO.setText("1211");
-					jsonlist.add(jsTreeVO);
-					
-					JSTreeVO jsTreeVO2 = new JSTreeVO();
-					jsTreeVO2.setChildren(false);
-					jsTreeVO2.setId("1212");
-					jsTreeVO2.setText("1212");
-					jsonlist.add(jsTreeVO2);
-					
-					JSTreeVO jsTreeVO3 = new JSTreeVO();
-					jsTreeVO3.setChildren(false);
-					jsTreeVO3.setId("1213");
-					jsTreeVO3.setText("1213");
-					jsonlist.add(jsTreeVO3);
-				}
-				
-				return jsonlist;
-			}
-
-		}
-
-	
-	
-	
+	
+	html
+	<div id="grouptree" style="height: 430px;"></div>
+	
+	css
+	<link type="text/css" rel="stylesheet" href="jstree/dist/themes/default/style.min.css" />
+
+	js
+	<script type="text/javascript" src="jstree/dist/libs/jquery.js"></script>
+	<script type="text/javascript" src="jstree/dist/jstree.min.js"></script>
+	
+	
+	$(function() {
+		$('#grouptree').on("changed.jstree",function(e, data) {
+			if (data.selected.length) {
+				alert('The selected node is: '
+					+ data.instance.get_node(data.selected[0]).text);
+				}
+		}).jstree({
+			'core' : {
+				'data' : {
+					'url' : 'jSTree/returnJson', //底层封装url
+					'data' : function(node) {
+						return {
+							'id' : node.id
+						};
+					}
+				},
+			},
+			'plugins' : [ 'wholerow' ]
+		})
+		.on("activate_node.jstree", function(obj, e) {
+			var id = e.node.id;
+			if (id.charAt(0) == 4) { //判断字符串第一个字符是否为4      字符串下标以0开头
+				$("#editcode").append(id.substring(id.indexOf("_") + 1)); //点击事件   此方法为第四层时向文本添加字符串切割下划线之后的内容  字符串操作包含头不包含尾
+			}
+		});
+		var to = false; //自带搜索功能
+		$('#search').click(function() {
+			if (to) {
+				clearTimeout(to);
+			}
+			to = setTimeout(function() {
+				var v = $('#searchname').val();
+				$('#edittree').jstree(true).search(v);
+			}, 250);
+		});
+
+	});
+	
+	
+	服务端
+	VO:
+	
+		public class JSTreeVO {
+		
+			private String id;
+
+			private String text;
+
+			private Boolean children;
+
+			private String icon;
+
+			public String getText() {
+				return text;
+			}
+
+			public void setText(String text) {
+				this.text = text;
+			}
+
+			public Boolean getChildren() {
+				return children;
+			}
+
+			public void setChildren(Boolean children) {
+				this.children = children;
+			}
+
+			public String getIcon() {
+				return icon;
+			}
+
+			public void setIcon(String icon) {
+				this.icon = icon;
+			}
+
+			public String getId() {
+				return id;
+			}
+
+			public void setId(String id) {
+				this.id = id;
+			}
+
+			@Override
+			public String toString() {
+				return "JSTreeVO [id=" + id + ", text=" + text + ", children=" + children + ", icon=" + icon + "]";
+			}
+
+		}
+	
+	Controller:
+	
+		import java.util.ArrayList;
+		import java.util.List;
+
+		import javax.servlet.http.HttpServletRequest;
+		import javax.servlet.http.HttpSession;
+
+		import org.apache.log4j.Logger;
+		import org.springframework.context.annotation.Scope;
+		import org.springframework.stereotype.Controller;
+		import org.springframework.web.bind.annotation.RequestMapping;
+		import org.springframework.web.bind.annotation.RequestMethod;
+		import org.springframework.web.bind.annotation.RequestParam;
+		import org.springframework.web.bind.annotation.ResponseBody;
+
+		import com.kedacom.tsu.model.VO.JSTreeVO;
+
+		@Controller("jSTreeController")
+		@RequestMapping("/jSTree")
+		@Scope("prototype")
+		public class JSTreeController {
+			
+			private static Logger log = Logger.getLogger(JSTreeController.class);
+			
+			@RequestMapping(value="/returnJson",method = RequestMethod.POST)
+			@ResponseBody
+			public List<JSTreeVO> retrunsoc(
+					@RequestParam(value = "id", defaultValue = "#", required = false) String id,
+					HttpServletRequest request, HttpSession session) {
+				log.info(id);
+				
+				List<JSTreeVO> jsonlist = new ArrayList<JSTreeVO>();
+
+				if ("#".equals(id)) {
+					
+					JSTreeVO jsTreeVO = new JSTreeVO();
+					jsTreeVO.setChildren(true);
+					//当设置成true时，点击该树节点，jstree就会进行一次请求，请求的url和data配置就是初始化jstree中的那些。
+					//当设置成false时，jstree就将该节点当成叶子节点
+					jsTreeVO.setId("1");
+					jsTreeVO.setText("ROOT");
+					jsonlist.add(jsTreeVO);
+					
+				} else if ("1".equals(id)) {// 分割拼接的字符串 _前面为层数 后面为id 
+					
+					JSTreeVO jsTreeVO = new JSTreeVO();
+					jsTreeVO.setChildren(false);
+					jsTreeVO.setId("11");
+					jsTreeVO.setText("11");
+					jsonlist.add(jsTreeVO);
+					
+					JSTreeVO jsTreeVO2 = new JSTreeVO();
+					jsTreeVO2.setChildren(true);
+					jsTreeVO2.setId("12");
+					jsTreeVO2.setText("12");
+					jsonlist.add(jsTreeVO2);
+					
+					JSTreeVO jsTreeVO3 = new JSTreeVO();
+					jsTreeVO3.setChildren(false);
+					jsTreeVO3.setId("13");
+					jsTreeVO3.setText("13");
+					jsonlist.add(jsTreeVO3);
+					
+					JSTreeVO jsTreeVO4 = new JSTreeVO();
+					jsTreeVO4.setChildren(false);
+					jsTreeVO4.setId("14");
+					jsTreeVO4.setText("14");
+					jsonlist.add(jsTreeVO4);
+					
+					JSTreeVO jsTreeVO5 = new JSTreeVO();
+					jsTreeVO5.setChildren(false);
+					jsTreeVO5.setId("15");
+					jsTreeVO5.setText("15");
+					jsonlist.add(jsTreeVO5);
+					
+					
+				} else if ("12".equals(id)) {
+					JSTreeVO jsTreeVO = new JSTreeVO();
+					jsTreeVO.setChildren(true);
+					jsTreeVO.setId("121");
+					jsTreeVO.setText("121");
+					jsonlist.add(jsTreeVO);
+					
+					JSTreeVO jsTreeVO2 = new JSTreeVO();
+					jsTreeVO2.setChildren(false);
+					jsTreeVO2.setId("122");
+					jsTreeVO2.setText("122");
+					jsonlist.add(jsTreeVO2);
+					
+					JSTreeVO jsTreeVO3 = new JSTreeVO();
+					jsTreeVO3.setChildren(false);
+					jsTreeVO3.setId("123");
+					jsTreeVO3.setText("123");
+					jsonlist.add(jsTreeVO3);
+				} else if ("121".equals(id)) {
+					JSTreeVO jsTreeVO = new JSTreeVO();
+					jsTreeVO.setChildren(false);
+					jsTreeVO.setId("1211");
+					jsTreeVO.setText("1211");
+					jsonlist.add(jsTreeVO);
+					
+					JSTreeVO jsTreeVO2 = new JSTreeVO();
+					jsTreeVO2.setChildren(false);
+					jsTreeVO2.setId("1212");
+					jsTreeVO2.setText("1212");
+					jsonlist.add(jsTreeVO2);
+					
+					JSTreeVO jsTreeVO3 = new JSTreeVO();
+					jsTreeVO3.setChildren(false);
+					jsTreeVO3.setId("1213");
+					jsTreeVO3.setText("1213");
+					jsonlist.add(jsTreeVO3);
+				}
+				
+				return jsonlist;
+			}
+
+		}
+
+	
+	
+	
 	
\ No newline at end of file
diff --git "a/14 - Front-end/jstree/\346\234\254\345\234\260demo.txt" "b/14 - Front-end \345\211\215\347\253\257/jstree/\346\234\254\345\234\260demo.txt"
similarity index 95%
rename from "14 - Front-end/jstree/\346\234\254\345\234\260demo.txt"
rename to "14 - Front-end \345\211\215\347\253\257/jstree/\346\234\254\345\234\260demo.txt"
index 83187d6b..1e32cdec 100644
--- "a/14 - Front-end/jstree/\346\234\254\345\234\260demo.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/jstree/\346\234\254\345\234\260demo.txt"	
@@ -1,45 +1,45 @@
-	
-	html
-	<div id="evts" class="demo"></div>
-	
-	css
-	<link type="text/css" rel="stylesheet" href="jstree/dist/themes/default/style.min.css" />
-
-	js
-	<script type="text/javascript" src="jstree/dist/libs/jquery.js"></script>
-	<script type="text/javascript" src="jstree/dist/jstree.min.js"></script>
-	
-	
-	$('#evts').on(
-			"changed.jstree",
-			function(e, data) {
-				if (data.selected.length) {
-					alert('The selected node is: '
-							+ data.instance.get_node(data.selected[0]).text);
-				}
-			}).jstree({
-		'core' : {
-			'multiple' : false,
-			'data' : [ {
-				"text" : "Root node",
-				"id" : 1,
-				"children" : [ {
-					"text" : "Child node 1",
-					"id" : 11
-					}, {
-					"text" : "Child node 2",
-					"id" : 12,
-					"children" : [ {
-						"text" : "Child Child node 1",
-						"id" : 121
-						}, {
-						"text" : "Child Child node 2",
-						"id" : 122
-						} ]
-				} ]
-			} ]
-		}
-	});
-	
-	
+	
+	html
+	<div id="evts" class="demo"></div>
+	
+	css
+	<link type="text/css" rel="stylesheet" href="jstree/dist/themes/default/style.min.css" />
+
+	js
+	<script type="text/javascript" src="jstree/dist/libs/jquery.js"></script>
+	<script type="text/javascript" src="jstree/dist/jstree.min.js"></script>
+	
+	
+	$('#evts').on(
+			"changed.jstree",
+			function(e, data) {
+				if (data.selected.length) {
+					alert('The selected node is: '
+							+ data.instance.get_node(data.selected[0]).text);
+				}
+			}).jstree({
+		'core' : {
+			'multiple' : false,
+			'data' : [ {
+				"text" : "Root node",
+				"id" : 1,
+				"children" : [ {
+					"text" : "Child node 1",
+					"id" : 11
+					}, {
+					"text" : "Child node 2",
+					"id" : 12,
+					"children" : [ {
+						"text" : "Child Child node 1",
+						"id" : 121
+						}, {
+						"text" : "Child Child node 2",
+						"id" : 122
+						} ]
+				} ]
+			} ]
+		}
+	});
+	
+	
 	
\ No newline at end of file
diff --git a/14 - Front-end/me/README.md "b/14 - Front-end \345\211\215\347\253\257/me/README.md"
similarity index 90%
rename from 14 - Front-end/me/README.md
rename to "14 - Front-end \345\211\215\347\253\257/me/README.md"
index 69a4a567..0d0e3018 100644
--- a/14 - Front-end/me/README.md	
+++ "b/14 - Front-end \345\211\215\347\253\257/me/README.md"	
@@ -1,7 +1,7 @@
-# loveincode.github.io
-
-
-
-地址：https://loveincode.github.io/
-
-
+# loveincode.github.io
+
+
+
+地址：https://loveincode.github.io/
+
+
diff --git a/14 - Front-end/me/css/style.css "b/14 - Front-end \345\211\215\347\253\257/me/css/style.css"
similarity index 92%
rename from 14 - Front-end/me/css/style.css
rename to "14 - Front-end \345\211\215\347\253\257/me/css/style.css"
index a6bb6b83..334da171 100644
--- a/14 - Front-end/me/css/style.css	
+++ "b/14 - Front-end \345\211\215\347\253\257/me/css/style.css"	
@@ -1,28 +1,28 @@
-body {
-	background: #060e1b;
-	overflow: hidden;
-	color: white;
-	font-family: "Comic Sans MS","Helvetica","Microsoft Yahei","Verdana","Arial","sans-serif";
-	font-size: 17px;
-}
-
-canvas {
-	//opacity: 0.5;
-}
-
-#aboutme {
-	width: 100%;
-	position: absolute;
-}
-
-a {
-	color: white;
-}
-
-a:hover {
-	color: gray;
-}
-
-#cnzz_stat_icon_1264360708 {
-	display: none;
+body {
+	background: #060e1b;
+	overflow: hidden;
+	color: white;
+	font-family: "Comic Sans MS","Helvetica","Microsoft Yahei","Verdana","Arial","sans-serif";
+	font-size: 17px;
+}
+
+canvas {
+	//opacity: 0.5;
+}
+
+#aboutme {
+	width: 100%;
+	position: absolute;
+}
+
+a {
+	color: white;
+}
+
+a:hover {
+	color: gray;
+}
+
+#cnzz_stat_icon_1264360708 {
+	display: none;
 }
\ No newline at end of file
diff --git a/14 - Front-end/me/image/logo.png "b/14 - Front-end \345\211\215\347\253\257/me/image/logo.png"
similarity index 100%
rename from 14 - Front-end/me/image/logo.png
rename to "14 - Front-end \345\211\215\347\253\257/me/image/logo.png"
diff --git a/14 - Front-end/me/image/logo.svg "b/14 - Front-end \345\211\215\347\253\257/me/image/logo.svg"
similarity index 100%
rename from 14 - Front-end/me/image/logo.svg
rename to "14 - Front-end \345\211\215\347\253\257/me/image/logo.svg"
diff --git a/14 - Front-end/me/index.html "b/14 - Front-end \345\211\215\347\253\257/me/index.html"
similarity index 97%
rename from 14 - Front-end/me/index.html
rename to "14 - Front-end \345\211\215\347\253\257/me/index.html"
index 66652430..d1862e40 100644
--- a/14 - Front-end/me/index.html	
+++ "b/14 - Front-end \345\211\215\347\253\257/me/index.html"	
@@ -1,52 +1,52 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="utf-8">
-<title>About Me</title>
-<link rel="icon" href="./image/logo.png" type="image/png" sizes="256x256">
-<link rel="icon" href="./image/logo.svg" type="image/svg+xml" sizes="any">
-<link rel="stylesheet" href="./css/style.css"/>
-</head>
-<body>
-<center id="aboutme">
-
-<h1>Brief</h1>
-		I'am loveincode,Java Development Engineer,Born in 1994,From Chengdu.China.
-<br/>
-		Major in software engineering(2013-2017),
-<a href="http://www.sspu.edu.cn/" target="_blank">Shanghai Polytechnic University</a>, Currently working in Shanghai.China.
-<br/>
-<h1>Job</h1>
-<a href="http://www.shun-lu.com/" target="_blank">顺陆金融 Java(2015.7-2015.9)</a>
-<br/>
-<a href="http://www.sari.cas.cn/" target="_blank">中科院上海高等研究院 Java(2016.7-2017.1)</a>
-<br/>
-<a href="http://www.kedacom.com/" target="_blank">KEDACOM(2017.3-？) Java</a>
-<h1>Contact</h1>
-		github：
-<a href="https://github.com/loveincode" target="_blank">loveincode</a>
-<br/> 
-		email :
-<a href="mailto:hyfaihsx@163.com" target="_blank">hyfaihsx@163.com</span></a>
-<br/> 
-		blog：
-<a href="http://loveincode.cnblogs.com" target="_blank">loveincode.cnblogs.com</a>
-<br/> 
-		qq群：305468437 （欢迎热爱Java的小伙伴加入）
-<h1>Interesting</h1>
-		coding cooking running
-<br/>
-<br/>
-<br/>
-<br/>
-		访问人数：
-<!-- GoStats Simple HTML Based Code -->
-<a target="_blank" title="web site traffic statistics" href="http://www.gostats.org"><img alt="web site traffic statistics" src="//www.gostats.org/0.png?a=701069329&ct=7&ci=16" style="border-width:0"/></a>
-<!-- End GoStats Simple HTML Based Code -->
-</center>
-<canvas id="canvas"></canvas>
-</body>
-<script type="text/javascript">var cnzz_protocol = (("https:" == document.location.protocol) ? " https://" : " http://");document.write(unescape("%3Cspan id='cnzz_stat_icon_1264360708'%3E%3C/span%3E%3Cscript src='" + cnzz_protocol + "s19.cnzz.com/z_stat.php%3Fid%3D1264360708%26show%3Dpic1' type='text/javascript'%3E%3C/script%3E"));</script>
-<script src="./js/script.js"></script>
-<script src="./js/backxuan.js"></script>
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>About Me</title>
+<link rel="icon" href="./image/logo.png" type="image/png" sizes="256x256">
+<link rel="icon" href="./image/logo.svg" type="image/svg+xml" sizes="any">
+<link rel="stylesheet" href="./css/style.css"/>
+</head>
+<body>
+<center id="aboutme">
+
+<h1>Brief</h1>
+		I'am loveincode,Java Development Engineer,Born in 1994,From Chengdu.China.
+<br/>
+		Major in software engineering(2013-2017),
+<a href="http://www.sspu.edu.cn/" target="_blank">Shanghai Polytechnic University</a>, Currently working in Shanghai.China.
+<br/>
+<h1>Job</h1>
+<a href="http://www.shun-lu.com/" target="_blank">顺陆金融 Java(2015.7-2015.9)</a>
+<br/>
+<a href="http://www.sari.cas.cn/" target="_blank">中科院上海高等研究院 Java(2016.7-2017.1)</a>
+<br/>
+<a href="http://www.kedacom.com/" target="_blank">KEDACOM(2017.3-？) Java</a>
+<h1>Contact</h1>
+		github：
+<a href="https://github.com/loveincode" target="_blank">loveincode</a>
+<br/> 
+		email :
+<a href="mailto:hyfaihsx@163.com" target="_blank">hyfaihsx@163.com</span></a>
+<br/> 
+		blog：
+<a href="http://loveincode.cnblogs.com" target="_blank">loveincode.cnblogs.com</a>
+<br/> 
+		qq群：305468437 （欢迎热爱Java的小伙伴加入）
+<h1>Interesting</h1>
+		coding cooking running
+<br/>
+<br/>
+<br/>
+<br/>
+		访问人数：
+<!-- GoStats Simple HTML Based Code -->
+<a target="_blank" title="web site traffic statistics" href="http://www.gostats.org"><img alt="web site traffic statistics" src="//www.gostats.org/0.png?a=701069329&ct=7&ci=16" style="border-width:0"/></a>
+<!-- End GoStats Simple HTML Based Code -->
+</center>
+<canvas id="canvas"></canvas>
+</body>
+<script type="text/javascript">var cnzz_protocol = (("https:" == document.location.protocol) ? " https://" : " http://");document.write(unescape("%3Cspan id='cnzz_stat_icon_1264360708'%3E%3C/span%3E%3Cscript src='" + cnzz_protocol + "s19.cnzz.com/z_stat.php%3Fid%3D1264360708%26show%3Dpic1' type='text/javascript'%3E%3C/script%3E"));</script>
+<script src="./js/script.js"></script>
+<script src="./js/backxuan.js"></script>
 </html>
\ No newline at end of file
diff --git a/14 - Front-end/me/js/backxuan.js "b/14 - Front-end \345\211\215\347\253\257/me/js/backxuan.js"
similarity index 95%
rename from 14 - Front-end/me/js/backxuan.js
rename to "14 - Front-end \345\211\215\347\253\257/me/js/backxuan.js"
index b71afdce..b78e1024 100644
--- a/14 - Front-end/me/js/backxuan.js	
+++ "b/14 - Front-end \345\211\215\347\253\257/me/js/backxuan.js"	
@@ -1,100 +1,100 @@
-"use strict";
-
-var canvas = document.getElementById('canvas'),
-	ctx = canvas.getContext('2d'),
-	w = canvas.width = window.innerWidth,
-	h = canvas.height = window.innerHeight,
-
-	hue = 217,
-	stars = [],
-	count = 0,
-	maxStars = 1200;
-
-var canvas2 = document.createElement('canvas'),
-	ctx2 = canvas2.getContext('2d');
-canvas2.width = 100;
-canvas2.height = 100;
-var half = canvas2.width / 2,
-	gradient2 = ctx2.createRadialGradient(half, half, 0, half, half, half);
-gradient2.addColorStop(0.025, '#fff');
-gradient2.addColorStop(0.1, 'hsl(' + hue + ', 61%, 33%)');
-gradient2.addColorStop(0.25, 'hsl(' + hue + ', 64%, 6%)');
-gradient2.addColorStop(1, 'transparent');
-
-ctx2.fillStyle = gradient2;
-ctx2.beginPath();
-ctx2.arc(half, half, half, 0, Math.PI * 2);
-ctx2.fill();
-
-// End cache
-
-function random(min, max) {
-	if (arguments.length < 2) {
-		max = min;
-		min = 0;
-	}
-
-	if (min > max) {
-		var hold = max;
-		max = min;
-		min = hold;
-	}
-
-	return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-function maxOrbit(x, y) {
-	var max = Math.max(x, y),
-		diameter = Math.round(Math.sqrt(max * max + max * max));
-	return diameter / 2;
-}
-
-var Star = function() {
-
-		this.orbitRadius = random(maxOrbit(w, h));
-		this.radius = random(60, this.orbitRadius) / 12;
-		this.orbitX = w / 2;
-		this.orbitY = h / 2;
-		this.timePassed = random(0, maxStars);
-		this.speed = random(this.orbitRadius) / 900000;
-		this.alpha = random(2, 10) / 10;
-
-		count++;
-		stars[count] = this;
-	}
-
-Star.prototype.draw = function() {
-	var x = Math.sin(this.timePassed) * this.orbitRadius + this.orbitX,
-		y = Math.cos(this.timePassed) * this.orbitRadius + this.orbitY,
-		twinkle = random(10);
-
-	if (twinkle === 1 && this.alpha > 0) {
-		this.alpha -= 0.05;
-	} else if (twinkle === 2 && this.alpha < 1) {
-		this.alpha += 0.05;
-	}
-
-	ctx.globalAlpha = this.alpha;
-	ctx.drawImage(canvas2, x - this.radius / 2, y - this.radius / 2, this.radius, this.radius);
-	this.timePassed += this.speed;
-}
-
-for (var i = 0; i < maxStars; i++) {
-	new Star();
-}
-
-function animation() {
-	ctx.globalCompositeOperation = 'source-over';
-	ctx.globalAlpha = 0.8;
-	ctx.fillStyle = 'hsla(' + hue + ', 64%, 6%, 1)';
-	ctx.fillRect(0, 0, w, h)
-
-	ctx.globalCompositeOperation = 'lighter';
-	for (var i = 1, l = stars.length; i < l; i++) {
-		stars[i].draw();
-	};
-
-	window.requestAnimationFrame(animation);
-}
-
+"use strict";
+
+var canvas = document.getElementById('canvas'),
+	ctx = canvas.getContext('2d'),
+	w = canvas.width = window.innerWidth,
+	h = canvas.height = window.innerHeight,
+
+	hue = 217,
+	stars = [],
+	count = 0,
+	maxStars = 1200;
+
+var canvas2 = document.createElement('canvas'),
+	ctx2 = canvas2.getContext('2d');
+canvas2.width = 100;
+canvas2.height = 100;
+var half = canvas2.width / 2,
+	gradient2 = ctx2.createRadialGradient(half, half, 0, half, half, half);
+gradient2.addColorStop(0.025, '#fff');
+gradient2.addColorStop(0.1, 'hsl(' + hue + ', 61%, 33%)');
+gradient2.addColorStop(0.25, 'hsl(' + hue + ', 64%, 6%)');
+gradient2.addColorStop(1, 'transparent');
+
+ctx2.fillStyle = gradient2;
+ctx2.beginPath();
+ctx2.arc(half, half, half, 0, Math.PI * 2);
+ctx2.fill();
+
+// End cache
+
+function random(min, max) {
+	if (arguments.length < 2) {
+		max = min;
+		min = 0;
+	}
+
+	if (min > max) {
+		var hold = max;
+		max = min;
+		min = hold;
+	}
+
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function maxOrbit(x, y) {
+	var max = Math.max(x, y),
+		diameter = Math.round(Math.sqrt(max * max + max * max));
+	return diameter / 2;
+}
+
+var Star = function() {
+
+		this.orbitRadius = random(maxOrbit(w, h));
+		this.radius = random(60, this.orbitRadius) / 12;
+		this.orbitX = w / 2;
+		this.orbitY = h / 2;
+		this.timePassed = random(0, maxStars);
+		this.speed = random(this.orbitRadius) / 900000;
+		this.alpha = random(2, 10) / 10;
+
+		count++;
+		stars[count] = this;
+	}
+
+Star.prototype.draw = function() {
+	var x = Math.sin(this.timePassed) * this.orbitRadius + this.orbitX,
+		y = Math.cos(this.timePassed) * this.orbitRadius + this.orbitY,
+		twinkle = random(10);
+
+	if (twinkle === 1 && this.alpha > 0) {
+		this.alpha -= 0.05;
+	} else if (twinkle === 2 && this.alpha < 1) {
+		this.alpha += 0.05;
+	}
+
+	ctx.globalAlpha = this.alpha;
+	ctx.drawImage(canvas2, x - this.radius / 2, y - this.radius / 2, this.radius, this.radius);
+	this.timePassed += this.speed;
+}
+
+for (var i = 0; i < maxStars; i++) {
+	new Star();
+}
+
+function animation() {
+	ctx.globalCompositeOperation = 'source-over';
+	ctx.globalAlpha = 0.8;
+	ctx.fillStyle = 'hsla(' + hue + ', 64%, 6%, 1)';
+	ctx.fillRect(0, 0, w, h)
+
+	ctx.globalCompositeOperation = 'lighter';
+	for (var i = 1, l = stars.length; i < l; i++) {
+		stars[i].draw();
+	};
+
+	window.requestAnimationFrame(animation);
+}
+
 animation();
\ No newline at end of file
diff --git "a/14 - Front-end/react/08 React \347\273\204\344\273\266\347\224\237\345\221\275\345\221\250\346\234\237.txt" "b/14 - Front-end \345\211\215\347\253\257/me/js/script.js"
similarity index 100%
rename from "14 - Front-end/react/08 React \347\273\204\344\273\266\347\224\237\345\221\275\345\221\250\346\234\237.txt"
rename to "14 - Front-end \345\211\215\347\253\257/me/js/script.js"
diff --git a/14 - Front-end/me/resume.md "b/14 - Front-end \345\211\215\347\253\257/me/resume.md"
similarity index 96%
rename from 14 - Front-end/me/resume.md
rename to "14 - Front-end \345\211\215\347\253\257/me/resume.md"
index aaa1b285..d3128366 100644
--- a/14 - Front-end/me/resume.md	
+++ "b/14 - Front-end \345\211\215\347\253\257/me/resume.md"	
@@ -1,26 +1,26 @@
-角色 
-
-java开发
-
-成果
-
-《东方有线在线营销系统》
-通过对用户数据的处理建模与信息提炼进行客户特征集市以及挖掘模型集市，从而达到用户全面画像的标签化展示。
-通过筛选客户特征标签的方式，实现营销活动从发起，数据提供，后台分析活动执行到结束的全流程闭环式管理。 
-               
-《面向智能工厂的智能生产管控解决方案 SD–IMS》
-
-
-《智能运维系统》
-IOMS-Intelligent  Operation Management System（智能运维管理系统）
-基于SOA的思想来进行设计，遵循“简单化，可扩展化，可服务化”的原则，将IOMS中的各模块设计成为处于不同层次上的服务。
-
-
-思路
-
-
-
-技术栈
-
-Java Spring Hibernate Struts2 Tomcat Mysql JVM NIO RPC 
-
+角色 
+
+java开发
+
+成果
+
+《东方有线在线营销系统》
+通过对用户数据的处理建模与信息提炼进行客户特征集市以及挖掘模型集市，从而达到用户全面画像的标签化展示。
+通过筛选客户特征标签的方式，实现营销活动从发起，数据提供，后台分析活动执行到结束的全流程闭环式管理。 
+               
+《面向智能工厂的智能生产管控解决方案 SD–IMS》
+
+
+《智能运维系统》
+IOMS-Intelligent  Operation Management System（智能运维管理系统）
+基于SOA的思想来进行设计，遵循“简单化，可扩展化，可服务化”的原则，将IOMS中的各模块设计成为处于不同层次上的服务。
+
+
+思路
+
+
+
+技术栈
+
+Java Spring Hibernate Struts2 Tomcat Mysql JVM NIO RPC 
+
diff --git a/14 - Front-end/qrcode.js "b/14 - Front-end \345\211\215\347\253\257/qrcode.js"
similarity index 97%
rename from 14 - Front-end/qrcode.js
rename to "14 - Front-end \345\211\215\347\253\257/qrcode.js"
index 2daf705c..4ab51ff5 100644
--- a/14 - Front-end/qrcode.js	
+++ "b/14 - Front-end \345\211\215\347\253\257/qrcode.js"	
@@ -1,908 +1,908 @@
-
-var QRCode;
-
-(function () {
-    //---------------------------------------------------------------------
-    // QRCode for JavaScript
-    //---------------------------------------------------------------------
-    function QR8bitByte(data) {
-        this.mode = QRMode.MODE_8BIT_BYTE;
-        this.data = data;
-        this.parsedData = [];
-
-        // Added to support UTF-8 Characters
-        for (var i = 0, l = this.data.length; i < l; i++) {
-            var byteArray = [];
-            var code = this.data.charCodeAt(i);
-
-            if (code > 0x10000) {
-                byteArray[0] = 0xF0 | ((code & 0x1C0000) >>> 18);
-                byteArray[1] = 0x80 | ((code & 0x3F000) >>> 12);
-                byteArray[2] = 0x80 | ((code & 0xFC0) >>> 6);
-                byteArray[3] = 0x80 | (code & 0x3F);
-            } else if (code > 0x800) {
-                byteArray[0] = 0xE0 | ((code & 0xF000) >>> 12);
-                byteArray[1] = 0x80 | ((code & 0xFC0) >>> 6);
-                byteArray[2] = 0x80 | (code & 0x3F);
-            } else if (code > 0x80) {
-                byteArray[0] = 0xC0 | ((code & 0x7C0) >>> 6);
-                byteArray[1] = 0x80 | (code & 0x3F);
-            } else {
-                byteArray[0] = code;
-            }
-
-            this.parsedData.push(byteArray);
-        }
-
-        this.parsedData = Array.prototype.concat.apply([], this.parsedData);
-
-        if (this.parsedData.length != this.data.length) {
-            this.parsedData.unshift(191);
-            this.parsedData.unshift(187);
-            this.parsedData.unshift(239);
-        }
-    }
-
-    QR8bitByte.prototype = {
-        getLength: function (buffer) {
-            return this.parsedData.length;
-        },
-        write: function (buffer) {
-            for (var i = 0, l = this.parsedData.length; i < l; i++) {
-                buffer.put(this.parsedData[i], 8);
-            }
-        }
-    };
-
-    function QRCodeModel(typeNumber, errorCorrectLevel) {
-        this.typeNumber = typeNumber;
-        this.errorCorrectLevel = errorCorrectLevel;
-        this.modules = null;
-        this.moduleCount = 0;
-        this.dataCache = null;
-        this.dataList = [];
-    }
-
-function QRPolynomial(num, shift) {
-    if (num.length == undefined) throw new Error(num.length + "/" + shift);
-    var offset = 0;
-    while (offset < num.length && num[offset] == 0) offset++;
-    this.num = new Array(num.length - offset + shift);
-    for (var i = 0; i < num.length - offset; i++) this.num[i] = num[i + offset];
-}
-
-function QRRSBlock(totalCount, dataCount) {
-    this.totalCount = totalCount, this.dataCount = dataCount;
-}
-
-function QRBitBuffer() {
-    this.buffer = [], this.length = 0;
-}
-
-    QRCodeModel.prototype = {
-        "addData": function(data) {
-            var newData = new QR8bitByte(data);
-            this.dataList.push(newData), this.dataCache = null;
-        },
-        "isDark": function(row, col) {
-            if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) throw new Error(row + "," + col);
-            return this.modules[row][col];
-        },
-        "getModuleCount": function() {
-            return this.moduleCount;
-        },
-        "make": function() {
-            this.makeImpl(!1, this.getBestMaskPattern());
-        },
-        "makeImpl": function(test, maskPattern) {
-            this.moduleCount = this.typeNumber * 4 + 17, this.modules = new Array(this.moduleCount);
-            for (var row = 0; row < this.moduleCount; row++) {
-                this.modules[row] = new Array(this.moduleCount);
-                for (var col = 0; col < this.moduleCount; col++) this.modules[row][col] = null;
-            }
-            this.setupPositionProbePattern(0, 0),
-            this.setupPositionProbePattern(this.moduleCount - 7, 0),
-            this.setupPositionProbePattern(0, this.moduleCount - 7),
-            this.setupPositionAdjustPattern(), this.setupTimingPattern(),
-            this.setupTypeInfo(test, maskPattern),
-            this.typeNumber >= 7 && this.setupTypeNumber(test),
-            this.dataCache == null && (this.dataCache = QRCodeModel.createData(this.typeNumber, this.errorCorrectLevel, this.dataList)), this.mapData(this.dataCache, maskPattern);
-        },
-        "setupPositionProbePattern": function(row, col) {
-            for (var r = -1; r <= 7; r++) {
-                if (row + r <= -1 || this.moduleCount <= row + r) continue;
-                for (var c = -1; c <= 7; c++) {
-                    if (col + c <= -1 || this.moduleCount <= col + c) continue;
-                    0 <= r && r <= 6 && (c == 0 || c == 6) || 0 <= c && c <= 6 && (r == 0 || r == 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4 ? this.modules[row + r][col + c] = !0 : this.modules[row + r][col + c] = !1;
-                }
-            }
-        },
-        "getBestMaskPattern": function() {
-            var minLostPoint = 0, pattern = 0;
-            for (var i = 0; i < 8; i++) {
-                this.makeImpl(!0, i);
-                var lostPoint = QRUtil.getLostPoint(this);
-                if (i == 0 || minLostPoint > lostPoint) minLostPoint = lostPoint, pattern = i;
-            }
-            return pattern;
-        },
-        "createMovieClip": function(target_mc, instance_name, depth) {
-            var qr_mc = target_mc.createEmptyMovieClip(instance_name, depth), cs = 1;
-            this.make();
-            for (var row = 0; row < this.modules.length; row++) {
-                var y = row * cs;
-                for (var col = 0; col < this.modules[row].length; col++) {
-                    var x = col * cs, dark = this.modules[row][col];
-                    dark && (qr_mc.beginFill(0, 100), qr_mc.moveTo(x, y), qr_mc.lineTo(x + cs, y), qr_mc.lineTo(x + cs, y + cs), qr_mc.lineTo(x, y + cs), qr_mc.endFill());
-                }
-            }
-            return qr_mc;
-        },
-        "setupTimingPattern": function() {
-            for (var r = 8; r < this.moduleCount - 8; r++) {
-                if (this.modules[r][6] != null) continue;
-                this.modules[r][6] = r % 2 == 0;
-            }
-            for (var c = 8; c < this.moduleCount - 8; c++) {
-                if (this.modules[6][c] != null) continue;
-                this.modules[6][c] = c % 2 == 0;
-            }
-        },
-        "setupPositionAdjustPattern": function() {
-            var pos = QRUtil.getPatternPosition(this.typeNumber);
-            for (var i = 0; i < pos.length; i++) for (var j = 0; j < pos.length; j++) {
-                var row = pos[i], col = pos[j];
-                if (this.modules[row][col] != null) continue;
-                for (var r = -2; r <= 2; r++) for (var c = -2; c <= 2; c++) r == -2 || r == 2 || c == -2 || c == 2 || r == 0 && c == 0 ? this.modules[row + r][col + c] = !0 : this.modules[row + r][col + c] = !1;
-            }
-        },
-        "setupTypeNumber": function(test) {
-            var bits = QRUtil.getBCHTypeNumber(this.typeNumber);
-            for (var i = 0; i < 18; i++) {
-                var mod = !test && (bits >> i & 1) == 1;
-                this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;
-            }
-            for (var i = 0; i < 18; i++) {
-                var mod = !test && (bits >> i & 1) == 1;
-                this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
-            }
-        },
-        "setupTypeInfo": function(test, maskPattern) {
-            var data = this.errorCorrectLevel << 3 | maskPattern, bits = QRUtil.getBCHTypeInfo(data);
-            for (var i = 0; i < 15; i++) {
-                var mod = !test && (bits >> i & 1) == 1;
-                i < 6 ? this.modules[i][8] = mod : i < 8 ? this.modules[i + 1][8] = mod : this.modules[this.moduleCount - 15 + i][8] = mod;
-            }
-            for (var i = 0; i < 15; i++) {
-                var mod = !test && (bits >> i & 1) == 1;
-                i < 8 ? this.modules[8][this.moduleCount - i - 1] = mod : i < 9 ? this.modules[8][15 - i - 1 + 1] = mod : this.modules[8][15 - i - 1] = mod;
-            }
-            this.modules[this.moduleCount - 8][8] = !test;
-        },
-        "mapData": function(data, maskPattern) {
-            var inc = -1, row = this.moduleCount - 1, bitIndex = 7, byteIndex = 0;
-            for (var col = this.moduleCount - 1; col > 0; col -= 2) {
-                col == 6 && col--;
-                for (;;) {
-                    for (var c = 0; c < 2; c++) if (this.modules[row][col - c] == null) {
-                        var dark = !1;
-                        byteIndex < data.length && (dark = (data[byteIndex] >>> bitIndex & 1) == 1);
-                        var mask = QRUtil.getMask(maskPattern, row, col - c);
-                        mask && (dark = !dark), this.modules[row][col - c] = dark, bitIndex--, bitIndex == -1 && (byteIndex++, bitIndex = 7);
-                    }
-                    row += inc;
-                    if (row < 0 || this.moduleCount <= row) {
-                        row -= inc, inc = -inc;
-                        break;
-                    }
-                }
-            }
-        }
-    }, QRCodeModel.PAD0 = 236, QRCodeModel.PAD1 = 17, QRCodeModel.createData = function(typeNumber, errorCorrectLevel, dataList) {
-        var rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel), buffer = new QRBitBuffer;
-        for (var i = 0; i < dataList.length; i++) {
-            var data = dataList[i];
-            buffer.put(data.mode, 4), buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber)), data.write(buffer);
-        }
-        var totalDataCount = 0;
-        for (var i = 0; i < rsBlocks.length; i++) totalDataCount += rsBlocks[i].dataCount;
-        if (buffer.getLengthInBits() > totalDataCount * 8) throw new Error("code length overflow. (" + buffer.getLengthInBits() + ">" + totalDataCount * 8 + ")");
-        buffer.getLengthInBits() + 4 <= totalDataCount * 8 && buffer.put(0, 4);
-        while (buffer.getLengthInBits() % 8 != 0) buffer.putBit(!1);
-        for (;;) {
-            if (buffer.getLengthInBits() >= totalDataCount * 8) break;
-            buffer.put(QRCodeModel.PAD0, 8);
-            if (buffer.getLengthInBits() >= totalDataCount * 8) break;
-            buffer.put(QRCodeModel.PAD1, 8);
-        }
-        return QRCodeModel.createBytes(buffer, rsBlocks);
-    }, QRCodeModel.createBytes = function(buffer, rsBlocks) {
-        var offset = 0, maxDcCount = 0, maxEcCount = 0, dcdata = new Array(rsBlocks.length), ecdata = new Array(rsBlocks.length);
-        for (var r = 0; r < rsBlocks.length; r++) {
-            var dcCount = rsBlocks[r].dataCount, ecCount = rsBlocks[r].totalCount - dcCount;
-            maxDcCount = Math.max(maxDcCount, dcCount), maxEcCount = Math.max(maxEcCount, ecCount), dcdata[r] = new Array(dcCount);
-            for (var i = 0; i < dcdata[r].length; i++) dcdata[r][i] = 255 & buffer.buffer[i + offset];
-            offset += dcCount;
-            var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount), rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1), modPoly = rawPoly.mod(rsPoly);
-            ecdata[r] = new Array(rsPoly.getLength() - 1);
-            for (var i = 0; i < ecdata[r].length; i++) {
-                var modIndex = i + modPoly.getLength() - ecdata[r].length;
-                ecdata[r][i] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
-            }
-        }
-        var totalCodeCount = 0;
-        for (var i = 0; i < rsBlocks.length; i++) totalCodeCount += rsBlocks[i].totalCount;
-        var data = new Array(totalCodeCount), index = 0;
-        for (var i = 0; i < maxDcCount; i++) for (var r = 0; r < rsBlocks.length; r++) i < dcdata[r].length && (data[index++] = dcdata[r][i]);
-        for (var i = 0; i < maxEcCount; i++) for (var r = 0; r < rsBlocks.length; r++) i < ecdata[r].length && (data[index++] = ecdata[r][i]);
-        return data;
-    };
-
-    var QRMode = {
-        "MODE_NUMBER": 1,
-        "MODE_ALPHA_NUM": 2,
-        "MODE_8BIT_BYTE": 4,
-        "MODE_KANJI": 8
-    }, QRErrorCorrectLevel = {
-        "L": 1,
-        "M": 0,
-        "Q": 3,
-        "H": 2
-    }, QRMaskPattern = {
-        "PATTERN000": 0,
-        "PATTERN001": 1,
-        "PATTERN010": 2,
-        "PATTERN011": 3,
-        "PATTERN100": 4,
-        "PATTERN101": 5,
-        "PATTERN110": 6,
-        "PATTERN111": 7
-    }, QRUtil = {
-        "PATTERN_POSITION_TABLE": [ [], [ 6, 18 ], [ 6, 22 ], [ 6, 26 ], [ 6, 30 ], [ 6, 34 ], [ 6, 22, 38 ], [ 6, 24, 42 ], [ 6, 26, 46 ], [ 6, 28, 50 ], [ 6, 30, 54 ], [ 6, 32, 58 ], [ 6, 34, 62 ], [ 6, 26, 46, 66 ], [ 6, 26, 48, 70 ], [ 6, 26, 50, 74 ], [ 6, 30, 54, 78 ], [ 6, 30, 56, 82 ], [ 6, 30, 58, 86 ], [ 6, 34, 62, 90 ], [ 6, 28, 50, 72, 94 ], [ 6, 26, 50, 74, 98 ], [ 6, 30, 54, 78, 102 ], [ 6, 28, 54, 80, 106 ], [ 6, 32, 58, 84, 110 ], [ 6, 30, 58, 86, 114 ], [ 6, 34, 62, 90, 118 ], [ 6, 26, 50, 74, 98, 122 ], [ 6, 30, 54, 78, 102, 126 ], [ 6, 26, 52, 78, 104, 130 ], [ 6, 30, 56, 82, 108, 134 ], [ 6, 34, 60, 86, 112, 138 ], [ 6, 30, 58, 86, 114, 142 ], [ 6, 34, 62, 90, 118, 146 ], [ 6, 30, 54, 78, 102, 126, 150 ], [ 6, 24, 50, 76, 102, 128, 154 ], [ 6, 28, 54, 80, 106, 132, 158 ], [ 6, 32, 58, 84, 110, 136, 162 ], [ 6, 26, 54, 82, 110, 138, 166 ], [ 6, 30, 58, 86, 114, 142, 170 ] ],
-        "G15": 1335,
-        "G18": 7973,
-        "G15_MASK": 21522,
-        "getBCHTypeInfo": function(data) {
-            var d = data << 10;
-            while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) d ^= QRUtil.G15 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15);
-            return (data << 10 | d) ^ QRUtil.G15_MASK;
-        },
-        "getBCHTypeNumber": function(data) {
-            var d = data << 12;
-            while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) d ^= QRUtil.G18 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18);
-            return data << 12 | d;
-        },
-        "getBCHDigit": function(data) {
-            var digit = 0;
-            while (data != 0) digit++, data >>>= 1;
-            return digit;
-        },
-        "getPatternPosition": function(typeNumber) {
-            return QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];
-        },
-        "getMask": function(maskPattern, i, j) {
-            switch (maskPattern) {
-              case QRMaskPattern.PATTERN000:
-                return (i + j) % 2 == 0;
-              case QRMaskPattern.PATTERN001:
-                return i % 2 == 0;
-              case QRMaskPattern.PATTERN010:
-                return j % 3 == 0;
-              case QRMaskPattern.PATTERN011:
-                return (i + j) % 3 == 0;
-              case QRMaskPattern.PATTERN100:
-                return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0;
-              case QRMaskPattern.PATTERN101:
-                return i * j % 2 + i * j % 3 == 0;
-              case QRMaskPattern.PATTERN110:
-                return (i * j % 2 + i * j % 3) % 2 == 0;
-              case QRMaskPattern.PATTERN111:
-                return (i * j % 3 + (i + j) % 2) % 2 == 0;
-              default:
-                throw new Error("bad maskPattern:" + maskPattern);
-            }
-        },
-        "getErrorCorrectPolynomial": function(errorCorrectLength) {
-            var a = new QRPolynomial([ 1 ], 0);
-            for (var i = 0; i < errorCorrectLength; i++) a = a.multiply(new QRPolynomial([ 1, QRMath.gexp(i) ], 0));
-            return a;
-        },
-        "getLengthInBits": function(mode, type) {
-            if (1 <= type && type < 10) switch (mode) {
-              case QRMode.MODE_NUMBER:
-                return 10;
-              case QRMode.MODE_ALPHA_NUM:
-                return 9;
-              case QRMode.MODE_8BIT_BYTE:
-                return 8;
-              case QRMode.MODE_KANJI:
-                return 8;
-              default:
-                throw new Error("mode:" + mode);
-            } else if (type < 27) switch (mode) {
-              case QRMode.MODE_NUMBER:
-                return 12;
-              case QRMode.MODE_ALPHA_NUM:
-                return 11;
-              case QRMode.MODE_8BIT_BYTE:
-                return 16;
-              case QRMode.MODE_KANJI:
-                return 10;
-              default:
-                throw new Error("mode:" + mode);
-            } else {
-                if (!(type < 41)) throw new Error("type:" + type);
-                switch (mode) {
-                  case QRMode.MODE_NUMBER:
-                    return 14;
-                  case QRMode.MODE_ALPHA_NUM:
-                    return 13;
-                  case QRMode.MODE_8BIT_BYTE:
-                    return 16;
-                  case QRMode.MODE_KANJI:
-                    return 12;
-                  default:
-                    throw new Error("mode:" + mode);
-                }
-            }
-        },
-        "getLostPoint": function(qrCode) {
-            var moduleCount = qrCode.getModuleCount(), lostPoint = 0;
-            for (var row = 0; row < moduleCount; row++) for (var col = 0; col < moduleCount; col++) {
-                var sameCount = 0, dark = qrCode.isDark(row, col);
-                for (var r = -1; r <= 1; r++) {
-                    if (row + r < 0 || moduleCount <= row + r) continue;
-                    for (var c = -1; c <= 1; c++) {
-                        if (col + c < 0 || moduleCount <= col + c) continue;
-                        if (r == 0 && c == 0) continue;
-                        dark == qrCode.isDark(row + r, col + c) && sameCount++;
-                    }
-                }
-                sameCount > 5 && (lostPoint += 3 + sameCount - 5);
-            }
-            for (var row = 0; row < moduleCount - 1; row++) for (var col = 0; col < moduleCount - 1; col++) {
-                var count = 0;
-                qrCode.isDark(row, col) && count++, qrCode.isDark(row + 1, col) && count++, qrCode.isDark(row, col + 1) && count++, qrCode.isDark(row + 1, col + 1) && count++;
-                if (count == 0 || count == 4) lostPoint += 3;
-            }
-            for (var row = 0; row < moduleCount; row++) for (var col = 0; col < moduleCount - 6; col++) qrCode.isDark(row, col) && !qrCode.isDark(row, col + 1) && qrCode.isDark(row, col + 2) && qrCode.isDark(row, col + 3) && qrCode.isDark(row, col + 4) && !qrCode.isDark(row, col + 5) && qrCode.isDark(row, col + 6) && (lostPoint += 40);
-            for (var col = 0; col < moduleCount; col++) for (var row = 0; row < moduleCount - 6; row++) qrCode.isDark(row, col) && !qrCode.isDark(row + 1, col) && qrCode.isDark(row + 2, col) && qrCode.isDark(row + 3, col) && qrCode.isDark(row + 4, col) && !qrCode.isDark(row + 5, col) && qrCode.isDark(row + 6, col) && (lostPoint += 40);
-            var darkCount = 0;
-            for (var col = 0; col < moduleCount; col++) for (var row = 0; row < moduleCount; row++) qrCode.isDark(row, col) && darkCount++;
-            var ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
-            return lostPoint += ratio * 10, lostPoint;
-        }
-    }, QRMath = {
-        "glog": function(n) {
-            if (n < 1) throw new Error("glog(" + n + ")");
-            return QRMath.LOG_TABLE[n];
-        },
-        "gexp": function(n) {
-            while (n < 0) n += 255;
-            while (n >= 256) n -= 255;
-            return QRMath.EXP_TABLE[n];
-        },
-        "EXP_TABLE": new Array(256),
-        "LOG_TABLE": new Array(256)
-    };
-
-    for (var i = 0; i < 8; i++) QRMath.EXP_TABLE[i] = 1 << i;
-
-    for (var i = 8; i < 256; i++) QRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4] ^ QRMath.EXP_TABLE[i - 5] ^ QRMath.EXP_TABLE[i - 6] ^ QRMath.EXP_TABLE[i - 8];
-
-    for (var i = 0; i < 255; i++) QRMath.LOG_TABLE[QRMath.EXP_TABLE[i]] = i;
-
-    QRPolynomial.prototype = {
-        "get": function(index) {
-            return this.num[index];
-        },
-        "getLength": function() {
-            return this.num.length;
-        },
-        "multiply": function(e) {
-            var num = new Array(this.getLength() + e.getLength() - 1);
-            for (var i = 0; i < this.getLength(); i++) for (var j = 0; j < e.getLength(); j++) num[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));
-            return new QRPolynomial(num, 0);
-        },
-        "mod": function(e) {
-            if (this.getLength() - e.getLength() < 0) return this;
-            var ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0)), num = new Array(this.getLength());
-            for (var i = 0; i < this.getLength(); i++) num[i] = this.get(i);
-            for (var i = 0; i < e.getLength(); i++) num[i] ^= QRMath.gexp(QRMath.glog(e.get(i)) + ratio);
-            return (new QRPolynomial(num, 0)).mod(e);
-        }
-    }, QRRSBlock.RS_BLOCK_TABLE = [ [ 1, 26, 19 ], [ 1, 26, 16 ], [ 1, 26, 13 ], [ 1, 26, 9 ], [ 1, 44, 34 ], [ 1, 44, 28 ], [ 1, 44, 22 ], [ 1, 44, 16 ], [ 1, 70, 55 ], [ 1, 70, 44 ], [ 2, 35, 17 ], [ 2, 35, 13 ], [ 1, 100, 80 ], [ 2, 50, 32 ], [ 2, 50, 24 ], [ 4, 25, 9 ], [ 1, 134, 108 ], [ 2, 67, 43 ], [ 2, 33, 15, 2, 34, 16 ], [ 2, 33, 11, 2, 34, 12 ], [ 2, 86, 68 ], [ 4, 43, 27 ], [ 4, 43, 19 ], [ 4, 43, 15 ], [ 2, 98, 78 ], [ 4, 49, 31 ], [ 2, 32, 14, 4, 33, 15 ], [ 4, 39, 13, 1, 40, 14 ], [ 2, 121, 97 ], [ 2, 60, 38, 2, 61, 39 ], [ 4, 40, 18, 2, 41, 19 ], [ 4, 40, 14, 2, 41, 15 ], [ 2, 146, 116 ], [ 3, 58, 36, 2, 59, 37 ], [ 4, 36, 16, 4, 37, 17 ], [ 4, 36, 12, 4, 37, 13 ], [ 2, 86, 68, 2, 87, 69 ], [ 4, 69, 43, 1, 70, 44 ], [ 6, 43, 19, 2, 44, 20 ], [ 6, 43, 15, 2, 44, 16 ], [ 4, 101, 81 ], [ 1, 80, 50, 4, 81, 51 ], [ 4, 50, 22, 4, 51, 23 ], [ 3, 36, 12, 8, 37, 13 ], [ 2, 116, 92, 2, 117, 93 ], [ 6, 58, 36, 2, 59, 37 ], [ 4, 46, 20, 6, 47, 21 ], [ 7, 42, 14, 4, 43, 15 ], [ 4, 133, 107 ], [ 8, 59, 37, 1, 60, 38 ], [ 8, 44, 20, 4, 45, 21 ], [ 12, 33, 11, 4, 34, 12 ], [ 3, 145, 115, 1, 146, 116 ], [ 4, 64, 40, 5, 65, 41 ], [ 11, 36, 16, 5, 37, 17 ], [ 11, 36, 12, 5, 37, 13 ], [ 5, 109, 87, 1, 110, 88 ], [ 5, 65, 41, 5, 66, 42 ], [ 5, 54, 24, 7, 55, 25 ], [ 11, 36, 12 ], [ 5, 122, 98, 1, 123, 99 ], [ 7, 73, 45, 3, 74, 46 ], [ 15, 43, 19, 2, 44, 20 ], [ 3, 45, 15, 13, 46, 16 ], [ 1, 135, 107, 5, 136, 108 ], [ 10, 74, 46, 1, 75, 47 ], [ 1, 50, 22, 15, 51, 23 ], [ 2, 42, 14, 17, 43, 15 ], [ 5, 150, 120, 1, 151, 121 ], [ 9, 69, 43, 4, 70, 44 ], [ 17, 50, 22, 1, 51, 23 ], [ 2, 42, 14, 19, 43, 15 ], [ 3, 141, 113, 4, 142, 114 ], [ 3, 70, 44, 11, 71, 45 ], [ 17, 47, 21, 4, 48, 22 ], [ 9, 39, 13, 16, 40, 14 ], [ 3, 135, 107, 5, 136, 108 ], [ 3, 67, 41, 13, 68, 42 ], [ 15, 54, 24, 5, 55, 25 ], [ 15, 43, 15, 10, 44, 16 ], [ 4, 144, 116, 4, 145, 117 ], [ 17, 68, 42 ], [ 17, 50, 22, 6, 51, 23 ], [ 19, 46, 16, 6, 47, 17 ], [ 2, 139, 111, 7, 140, 112 ], [ 17, 74, 46 ], [ 7, 54, 24, 16, 55, 25 ], [ 34, 37, 13 ], [ 4, 151, 121, 5, 152, 122 ], [ 4, 75, 47, 14, 76, 48 ], [ 11, 54, 24, 14, 55, 25 ], [ 16, 45, 15, 14, 46, 16 ], [ 6, 147, 117, 4, 148, 118 ], [ 6, 73, 45, 14, 74, 46 ], [ 11, 54, 24, 16, 55, 25 ], [ 30, 46, 16, 2, 47, 17 ], [ 8, 132, 106, 4, 133, 107 ], [ 8, 75, 47, 13, 76, 48 ], [ 7, 54, 24, 22, 55, 25 ], [ 22, 45, 15, 13, 46, 16 ], [ 10, 142, 114, 2, 143, 115 ], [ 19, 74, 46, 4, 75, 47 ], [ 28, 50, 22, 6, 51, 23 ], [ 33, 46, 16, 4, 47, 17 ], [ 8, 152, 122, 4, 153, 123 ], [ 22, 73, 45, 3, 74, 46 ], [ 8, 53, 23, 26, 54, 24 ], [ 12, 45, 15, 28, 46, 16 ], [ 3, 147, 117, 10, 148, 118 ], [ 3, 73, 45, 23, 74, 46 ], [ 4, 54, 24, 31, 55, 25 ], [ 11, 45, 15, 31, 46, 16 ], [ 7, 146, 116, 7, 147, 117 ], [ 21, 73, 45, 7, 74, 46 ], [ 1, 53, 23, 37, 54, 24 ], [ 19, 45, 15, 26, 46, 16 ], [ 5, 145, 115, 10, 146, 116 ], [ 19, 75, 47, 10, 76, 48 ], [ 15, 54, 24, 25, 55, 25 ], [ 23, 45, 15, 25, 46, 16 ], [ 13, 145, 115, 3, 146, 116 ], [ 2, 74, 46, 29, 75, 47 ], [ 42, 54, 24, 1, 55, 25 ], [ 23, 45, 15, 28, 46, 16 ], [ 17, 145, 115 ], [ 10, 74, 46, 23, 75, 47 ], [ 10, 54, 24, 35, 55, 25 ], [ 19, 45, 15, 35, 46, 16 ], [ 17, 145, 115, 1, 146, 116 ], [ 14, 74, 46, 21, 75, 47 ], [ 29, 54, 24, 19, 55, 25 ], [ 11, 45, 15, 46, 46, 16 ], [ 13, 145, 115, 6, 146, 116 ], [ 14, 74, 46, 23, 75, 47 ], [ 44, 54, 24, 7, 55, 25 ], [ 59, 46, 16, 1, 47, 17 ], [ 12, 151, 121, 7, 152, 122 ], [ 12, 75, 47, 26, 76, 48 ], [ 39, 54, 24, 14, 55, 25 ], [ 22, 45, 15, 41, 46, 16 ], [ 6, 151, 121, 14, 152, 122 ], [ 6, 75, 47, 34, 76, 48 ], [ 46, 54, 24, 10, 55, 25 ], [ 2, 45, 15, 64, 46, 16 ], [ 17, 152, 122, 4, 153, 123 ], [ 29, 74, 46, 14, 75, 47 ], [ 49, 54, 24, 10, 55, 25 ], [ 24, 45, 15, 46, 46, 16 ], [ 4, 152, 122, 18, 153, 123 ], [ 13, 74, 46, 32, 75, 47 ], [ 48, 54, 24, 14, 55, 25 ], [ 42, 45, 15, 32, 46, 16 ], [ 20, 147, 117, 4, 148, 118 ], [ 40, 75, 47, 7, 76, 48 ], [ 43, 54, 24, 22, 55, 25 ], [ 10, 45, 15, 67, 46, 16 ], [ 19, 148, 118, 6, 149, 119 ], [ 18, 75, 47, 31, 76, 48 ], [ 34, 54, 24, 34, 55, 25 ], [ 20, 45, 15, 61, 46, 16 ] ], QRRSBlock.getRSBlocks = function(typeNumber, errorCorrectLevel) {
-        var rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);
-        if (rsBlock == undefined) throw new Error("bad rs block @ typeNumber:" + typeNumber + "/errorCorrectLevel:" + errorCorrectLevel);
-        var length = rsBlock.length / 3, list = [];
-        for (var i = 0; i < length; i++) {
-            var count = rsBlock[i * 3 + 0], totalCount = rsBlock[i * 3 + 1], dataCount = rsBlock[i * 3 + 2];
-            for (var j = 0; j < count; j++) list.push(new QRRSBlock(totalCount, dataCount));
-        }
-        return list;
-    }, QRRSBlock.getRsBlockTable = function(typeNumber, errorCorrectLevel) {
-        switch (errorCorrectLevel) {
-          case QRErrorCorrectLevel.L:
-            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
-          case QRErrorCorrectLevel.M:
-            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
-          case QRErrorCorrectLevel.Q:
-            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
-          case QRErrorCorrectLevel.H:
-            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
-          default:
-            return undefined;
-        }
-    }, QRBitBuffer.prototype = {
-        "get": function(index) {
-            var bufIndex = Math.floor(index / 8);
-            return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;
-        },
-        "put": function(num, length) {
-            for (var i = 0; i < length; i++) this.putBit((num >>> length - i - 1 & 1) == 1);
-        },
-        "getLengthInBits": function() {
-            return this.length;
-        },
-        "putBit": function(bit) {
-            var bufIndex = Math.floor(this.length / 8);
-            this.buffer.length <= bufIndex && this.buffer.push(0), bit && (this.buffer[bufIndex] |= 128 >>> this.length % 8), this.length++;
-        }
-    };
-    var QRCodeLimitLength=[[17,14,11,7],[32,26,20,14],[53,42,32,24],[78,62,46,34],[106,84,60,44],[134,106,74,58],[154,122,86,64],[192,152,108,84],[230,180,130,98],[271,213,151,119],[321,251,177,137],[367,287,203,155],[425,331,241,177],[458,362,258,194],[520,412,292,220],[586,450,322,250],[644,504,364,280],[718,560,394,310],[792,624,442,338],[858,666,482,382],[929,711,509,403],[1003,779,565,439],[1091,857,611,461],[1171,911,661,511],[1273,997,715,535],[1367,1059,751,593],[1465,1125,805,625],[1528,1190,868,658],[1628,1264,908,698],[1732,1370,982,742],[1840,1452,1030,790],[1952,1538,1112,842],[2068,1628,1168,898],[2188,1722,1228,958],[2303,1809,1283,983],[2431,1911,1351,1051],[2563,1989,1423,1093],[2699,2099,1499,1139],[2809,2213,1579,1219],[2953,2331,1663,1273]];
-    
-    function _isSupportCanvas() {
-        return typeof CanvasRenderingContext2D != "undefined";
-    }
-    
-    // android 2.x doesn't support Data-URI spec
-    function _getAndroid() {
-        var android = false;
-        var sAgent = navigator.userAgent;
-        
-        if (/android/i.test(sAgent)) { // android
-            android = true;
-            aMat = sAgent.toString().match(/android ([0-9]\.[0-9])/i);
-            
-            if (aMat && aMat[1]) {
-                android = parseFloat(aMat[1]);
-            }
-        }
-        
-        return android;
-    }
-    
-    var svgDrawer = (function() {
-
-        var Drawing = function (el, htOption) {
-            this._el = el;
-            this._htOption = htOption;
-        };
-
-        Drawing.prototype.draw = function (oQRCode) {
-            var _htOption = this._htOption;
-            var _el = this._el;
-            var nCount = oQRCode.getModuleCount();
-            var nWidth = Math.floor(_htOption.width / nCount);
-            var nHeight = Math.floor(_htOption.height / nCount);
-
-            this.clear();
-
-            function makeSVG(tag, attrs) {
-                var el = document.createElementNS('http://www.w3.org/2000/svg', tag);
-                for (var k in attrs)
-                    if (attrs.hasOwnProperty(k)) el.setAttribute(k, attrs[k]);
-                return el;
-            }
-
-            var svg = makeSVG("svg" , {'viewBox': '0 0 ' + String(nCount) + " " + String(nCount), 'width': '100%', 'height': '100%', 'fill': _htOption.colorLight});
-            svg.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", "http://www.w3.org/1999/xlink");
-            _el.appendChild(svg);
-
-            svg.appendChild(makeSVG("rect", {"fill": _htOption.colorDark, "width": "1", "height": "1", "id": "template"}));
-
-            for (var row = 0; row < nCount; row++) {
-                for (var col = 0; col < nCount; col++) {
-                    if (oQRCode.isDark(row, col)) {
-                        var child = makeSVG("use", {"x": String(row), "y": String(col)});
-                        child.setAttributeNS("http://www.w3.org/1999/xlink", "href", "#template")
-                        svg.appendChild(child);
-                    }
-                }
-            }
-        };
-        Drawing.prototype.clear = function () {
-            while (this._el.hasChildNodes())
-                this._el.removeChild(this._el.lastChild);
-        };
-        return Drawing;
-    })();
-
-    var useSVG = document.documentElement.tagName.toLowerCase() === "svg";
-
-    // Drawing in DOM by using Table tag
-    var Drawing = useSVG ? svgDrawer : !_isSupportCanvas() ? (function () {
-        var Drawing = function (el, htOption) {
-            this._el = el;
-            this._htOption = htOption;
-        };
-            
-        /**
-         * Draw the QRCode
-         * 
-         * @param {QRCode} oQRCode
-         */
-        Drawing.prototype.draw = function (oQRCode) {
-            var _htOption = this._htOption;
-            var _el = this._el;
-            var nCount = oQRCode.getModuleCount();
-            var nWidth = Math.floor(_htOption.width / nCount);
-            var nHeight = Math.floor(_htOption.height / nCount);
-            var aHTML = ['<table style="border:0;border-collapse:collapse;">'];
-            
-            for (var row = 0; row < nCount; row++) {
-                aHTML.push('<tr>');
-                
-                for (var col = 0; col < nCount; col++) {
-                    aHTML.push('<td style="border:0;border-collapse:collapse;padding:0;margin:0;width:' + nWidth + 'px;height:' + nHeight + 'px;background-color:' + (oQRCode.isDark(row, col) ? _htOption.colorDark : _htOption.colorLight) + ';"></td>');
-                }
-                
-                aHTML.push('</tr>');
-            }
-            
-            aHTML.push('</table>');
-            _el.innerHTML = aHTML.join('');
-            
-            // Fix the margin values as real size.
-            var elTable = _el.childNodes[0];
-            var nLeftMarginTable = (_htOption.width - elTable.offsetWidth) / 2;
-            var nTopMarginTable = (_htOption.height - elTable.offsetHeight) / 2;
-            if (nLeftMarginTable > 0 && nTopMarginTable > 0) {
-                elTable.style.margin = nTopMarginTable + "px " + nLeftMarginTable + "px";    
-            }
-        };
-        
-        /**
-         * Clear the QRCode
-         */
-        Drawing.prototype.clear = function () {
-            this._el.innerHTML = '';
-        };
-        
-        return Drawing;
-    })() : (function () { // Drawing in Canvas
-        function _onMakeImage() {
-            this._elImage.src = this._elCanvas.toDataURL("image/png");
-            this._elImage.style.display = "block";
-            this._elCanvas.style.display = "none";            
-        }
-        
-        // Android 2.1 bug workaround
-        // http://code.google.com/p/android/issues/detail?id=5141
-        if (this._android && this._android <= 2.1) {
-            var factor = 1 / window.devicePixelRatio;
-            var drawImage = CanvasRenderingContext2D.prototype.drawImage; 
-            CanvasRenderingContext2D.prototype.drawImage = function (image, sx, sy, sw, sh, dx, dy, dw, dh) {
-                if (("nodeName" in image) && /img/i.test(image.nodeName)) {
-                    for (var i = arguments.length - 1; i >= 1; i--) {
-                        arguments[i] = arguments[i] * factor;
-                    }
-                } else if (typeof dw == "undefined") {
-                    arguments[1] *= factor;
-                    arguments[2] *= factor;
-                    arguments[3] *= factor;
-                    arguments[4] *= factor;
-                }
-                
-                drawImage.apply(this, arguments); 
-            };
-        }
-        
-        /**
-         * Check whether the user's browser supports Data URI or not
-         * 
-         * @private
-         * @param {Function} fSuccess Occurs if it supports Data URI
-         * @param {Function} fFail Occurs if it doesn't support Data URI
-         */
-        function _safeSetDataURI(fSuccess, fFail) {
-            var self = this;
-            self._fFail = fFail;
-            self._fSuccess = fSuccess;
-
-            // Check it just once
-            if (self._bSupportDataURI === null) {
-                var el = document.createElement("img");
-                var fOnError = function() {
-                    self._bSupportDataURI = false;
-
-                    if (self._fFail) {
-                        _fFail.call(self);
-                    }
-                };
-                var fOnSuccess = function() {
-                    self._bSupportDataURI = true;
-
-                    if (self._fSuccess) {
-                        self._fSuccess.call(self);
-                    }
-                };
-
-                el.onabort = fOnError;
-                el.onerror = fOnError;
-                el.onload = fOnSuccess;
-                el.src = "data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=="; // the Image contains 1px data.
-                return;
-            } else if (self._bSupportDataURI === true && self._fSuccess) {
-                self._fSuccess.call(self);
-            } else if (self._bSupportDataURI === false && self._fFail) {
-                self._fFail.call(self);
-            }
-        };
-        
-        /**
-         * Drawing QRCode by using canvas
-         * 
-         * @constructor
-         * @param {HTMLElement} el
-         * @param {Object} htOption QRCode Options 
-         */
-        var Drawing = function (el, htOption) {
-            this._bIsPainted = false;
-            this._android = _getAndroid();
-        
-            this._htOption = htOption;
-            this._elCanvas = document.createElement("canvas");
-            this._elCanvas.width = htOption.width;
-            this._elCanvas.height = htOption.height;
-            el.appendChild(this._elCanvas);
-            this._el = el;
-            this._oContext = this._elCanvas.getContext("2d");
-            this._bIsPainted = false;
-            this._elImage = document.createElement("img");
-            this._elImage.alt = "Scan me!";
-            this._elImage.style.display = "none";
-            this._el.appendChild(this._elImage);
-            this._bSupportDataURI = null;
-        };
-            
-        /**
-         * Draw the QRCode
-         * 
-         * @param {QRCode} oQRCode 
-         */
-        Drawing.prototype.draw = function (oQRCode) {
-            var _elImage = this._elImage;
-            var _oContext = this._oContext;
-            var _htOption = this._htOption;
-            
-            var nCount = oQRCode.getModuleCount();
-            var nWidth = _htOption.width / nCount;
-            var nHeight = _htOption.height / nCount;
-            var nRoundedWidth = Math.round(nWidth);
-            var nRoundedHeight = Math.round(nHeight);
-
-            _elImage.style.display = "none";
-            this.clear();
-            
-            for (var row = 0; row < nCount; row++) {
-                for (var col = 0; col < nCount; col++) {
-                    var bIsDark = oQRCode.isDark(row, col);
-                    var nLeft = col * nWidth;
-                    var nTop = row * nHeight;
-                    _oContext.strokeStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;
-                    _oContext.lineWidth = 1;
-                    _oContext.fillStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;                    
-                    _oContext.fillRect(nLeft, nTop, nWidth, nHeight);
-
-                    _oContext.strokeRect(
-                        Math.floor(nLeft) + 0.5,
-                        Math.floor(nTop) + 0.5,
-                        nRoundedWidth,
-                        nRoundedHeight
-                    );
-                    
-                    _oContext.strokeRect(
-                        Math.ceil(nLeft) - 0.5,
-                        Math.ceil(nTop) - 0.5,
-                        nRoundedWidth,
-                        nRoundedHeight
-                    );
-                }
-            }
-            
-            this._bIsPainted = true;
-        };
-            
-        /**
-         * Make the image from Canvas if the browser supports Data URI.
-         */
-        Drawing.prototype.makeImage = function () {
-            if (this._bIsPainted) {
-                _safeSetDataURI.call(this, _onMakeImage);
-            }
-        };
-            
-        /**
-         * Return whether the QRCode is painted or not
-         * 
-         * @return {Boolean}
-         */
-        Drawing.prototype.isPainted = function () {
-            return this._bIsPainted;
-        };
-        
-        /**
-         * Clear the QRCode
-         */
-        Drawing.prototype.clear = function () {
-            this._oContext.clearRect(0, 0, this._elCanvas.width, this._elCanvas.height);
-            this._bIsPainted = false;
-        };
-        
-        /**
-         * @private
-         * @param {Number} nNumber
-         */
-        Drawing.prototype.round = function (nNumber) {
-            if (!nNumber) {
-                return nNumber;
-            }
-            
-            return Math.floor(nNumber * 1000) / 1000;
-        };
-        
-        return Drawing;
-    })();
-    
-    /**
-     * Get the type by string length
-     * 
-     * @private
-     * @param {String} sText
-     * @param {Number} nCorrectLevel
-     * @return {Number} type
-     */
-    function _getTypeNumber(sText, nCorrectLevel) {            
-        var nType = 1;
-        var length = _getUTF8Length(sText);
-        
-        for (var i = 0, len = QRCodeLimitLength.length; i <= len; i++) {
-            var nLimit = 0;
-            
-            switch (nCorrectLevel) {
-                case QRErrorCorrectLevel.L :
-                    nLimit = QRCodeLimitLength[i][0];
-                    break;
-                case QRErrorCorrectLevel.M :
-                    nLimit = QRCodeLimitLength[i][1];
-                    break;
-                case QRErrorCorrectLevel.Q :
-                    nLimit = QRCodeLimitLength[i][2];
-                    break;
-                case QRErrorCorrectLevel.H :
-                    nLimit = QRCodeLimitLength[i][3];
-                    break;
-            }
-            
-            if (length <= nLimit) {
-                break;
-            } else {
-                nType++;
-            }
-        }
-        
-        if (nType > QRCodeLimitLength.length) {
-            throw new Error("Too long data");
-        }
-        
-        return nType;
-    }
-
-    function _getUTF8Length(sText) {
-        var replacedText = encodeURI(sText).toString().replace(/\%[0-9a-fA-F]{2}/g, 'a');
-        return replacedText.length + (replacedText.length != sText ? 3 : 0);
-    }
-    
-    /**
-     * @class QRCode
-     * @constructor
-     * @example 
-     * new QRCode(document.getElementById("test"), "http://jindo.dev.naver.com/collie");
-     *
-     * @example
-     * var oQRCode = new QRCode("test", {
-     *    text : "http://naver.com",
-     *    width : 128,
-     *    height : 128
-     * });
-     * 
-     * oQRCode.clear(); // Clear the QRCode.
-     * oQRCode.makeCode("http://map.naver.com"); // Re-create the QRCode.
-     *
-     * @param {HTMLElement|String} el target element or 'id' attribute of element.
-     * @param {Object|String} vOption
-     * @param {String} vOption.text QRCode link data
-     * @param {Number} [vOption.width=256]
-     * @param {Number} [vOption.height=256]
-     * @param {String} [vOption.colorDark="#000000"]
-     * @param {String} [vOption.colorLight="#ffffff"]
-     * @param {QRCode.CorrectLevel} [vOption.correctLevel=QRCode.CorrectLevel.H] [L|M|Q|H] 
-     */
-    QRCode = function (el, vOption) {
-        this._htOption = {
-            width : 256, 
-            height : 256,
-            typeNumber : 4,
-            colorDark : "#000000",
-            colorLight : "#ffffff",
-            correctLevel : QRErrorCorrectLevel.H
-        };
-        
-        if (typeof vOption === 'string') {
-            vOption    = {
-                text : vOption
-            };
-        }
-        
-        // Overwrites options
-        if (vOption) {
-            for (var i in vOption) {
-                this._htOption[i] = vOption[i];
-            }
-        }
-        
-        if (typeof el == "string") {
-            el = document.getElementById(el);
-        }
-        
-        this._android = _getAndroid();
-        this._el = el;
-        this._oQRCode = null;
-        this._oDrawing = new Drawing(this._el, this._htOption);
-        
-        if (this._htOption.text) {
-            this.makeCode(this._htOption.text);    
-        }
-    };
-    
-    /**
-     * Make the QRCode
-     * 
-     * @param {String} sText link data
-     */
-    QRCode.prototype.makeCode = function (sText) {
-        this._oQRCode = new QRCodeModel(_getTypeNumber(sText, this._htOption.correctLevel), this._htOption.correctLevel);
-        this._oQRCode.addData(sText);
-        this._oQRCode.make();
-        this._el.title = sText;
-        this._oDrawing.draw(this._oQRCode);            
-        this.makeImage();
-    };
-    
-    /**
-     * Make the Image from Canvas element
-     * - It occurs automatically
-     * - Android below 3 doesn't support Data-URI spec.
-     * 
-     * @private
-     */
-    QRCode.prototype.makeImage = function () {
-        if (typeof this._oDrawing.makeImage == "function" && (!this._android || this._android >= 3)) {
-            this._oDrawing.makeImage();
-        }
-    };
-    
-    /**
-     * Clear the QRCode
-     */
-    QRCode.prototype.clear = function () {
-        this._el.innerHTML = '';
-        this._oDrawing.clear();
-    };
-    
-    /**
-     * @name QRCode.CorrectLevel
-     */
-    QRCode.CorrectLevel = QRErrorCorrectLevel;
+
+var QRCode;
+
+(function () {
+    //---------------------------------------------------------------------
+    // QRCode for JavaScript
+    //---------------------------------------------------------------------
+    function QR8bitByte(data) {
+        this.mode = QRMode.MODE_8BIT_BYTE;
+        this.data = data;
+        this.parsedData = [];
+
+        // Added to support UTF-8 Characters
+        for (var i = 0, l = this.data.length; i < l; i++) {
+            var byteArray = [];
+            var code = this.data.charCodeAt(i);
+
+            if (code > 0x10000) {
+                byteArray[0] = 0xF0 | ((code & 0x1C0000) >>> 18);
+                byteArray[1] = 0x80 | ((code & 0x3F000) >>> 12);
+                byteArray[2] = 0x80 | ((code & 0xFC0) >>> 6);
+                byteArray[3] = 0x80 | (code & 0x3F);
+            } else if (code > 0x800) {
+                byteArray[0] = 0xE0 | ((code & 0xF000) >>> 12);
+                byteArray[1] = 0x80 | ((code & 0xFC0) >>> 6);
+                byteArray[2] = 0x80 | (code & 0x3F);
+            } else if (code > 0x80) {
+                byteArray[0] = 0xC0 | ((code & 0x7C0) >>> 6);
+                byteArray[1] = 0x80 | (code & 0x3F);
+            } else {
+                byteArray[0] = code;
+            }
+
+            this.parsedData.push(byteArray);
+        }
+
+        this.parsedData = Array.prototype.concat.apply([], this.parsedData);
+
+        if (this.parsedData.length != this.data.length) {
+            this.parsedData.unshift(191);
+            this.parsedData.unshift(187);
+            this.parsedData.unshift(239);
+        }
+    }
+
+    QR8bitByte.prototype = {
+        getLength: function (buffer) {
+            return this.parsedData.length;
+        },
+        write: function (buffer) {
+            for (var i = 0, l = this.parsedData.length; i < l; i++) {
+                buffer.put(this.parsedData[i], 8);
+            }
+        }
+    };
+
+    function QRCodeModel(typeNumber, errorCorrectLevel) {
+        this.typeNumber = typeNumber;
+        this.errorCorrectLevel = errorCorrectLevel;
+        this.modules = null;
+        this.moduleCount = 0;
+        this.dataCache = null;
+        this.dataList = [];
+    }
+
+function QRPolynomial(num, shift) {
+    if (num.length == undefined) throw new Error(num.length + "/" + shift);
+    var offset = 0;
+    while (offset < num.length && num[offset] == 0) offset++;
+    this.num = new Array(num.length - offset + shift);
+    for (var i = 0; i < num.length - offset; i++) this.num[i] = num[i + offset];
+}
+
+function QRRSBlock(totalCount, dataCount) {
+    this.totalCount = totalCount, this.dataCount = dataCount;
+}
+
+function QRBitBuffer() {
+    this.buffer = [], this.length = 0;
+}
+
+    QRCodeModel.prototype = {
+        "addData": function(data) {
+            var newData = new QR8bitByte(data);
+            this.dataList.push(newData), this.dataCache = null;
+        },
+        "isDark": function(row, col) {
+            if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) throw new Error(row + "," + col);
+            return this.modules[row][col];
+        },
+        "getModuleCount": function() {
+            return this.moduleCount;
+        },
+        "make": function() {
+            this.makeImpl(!1, this.getBestMaskPattern());
+        },
+        "makeImpl": function(test, maskPattern) {
+            this.moduleCount = this.typeNumber * 4 + 17, this.modules = new Array(this.moduleCount);
+            for (var row = 0; row < this.moduleCount; row++) {
+                this.modules[row] = new Array(this.moduleCount);
+                for (var col = 0; col < this.moduleCount; col++) this.modules[row][col] = null;
+            }
+            this.setupPositionProbePattern(0, 0),
+            this.setupPositionProbePattern(this.moduleCount - 7, 0),
+            this.setupPositionProbePattern(0, this.moduleCount - 7),
+            this.setupPositionAdjustPattern(), this.setupTimingPattern(),
+            this.setupTypeInfo(test, maskPattern),
+            this.typeNumber >= 7 && this.setupTypeNumber(test),
+            this.dataCache == null && (this.dataCache = QRCodeModel.createData(this.typeNumber, this.errorCorrectLevel, this.dataList)), this.mapData(this.dataCache, maskPattern);
+        },
+        "setupPositionProbePattern": function(row, col) {
+            for (var r = -1; r <= 7; r++) {
+                if (row + r <= -1 || this.moduleCount <= row + r) continue;
+                for (var c = -1; c <= 7; c++) {
+                    if (col + c <= -1 || this.moduleCount <= col + c) continue;
+                    0 <= r && r <= 6 && (c == 0 || c == 6) || 0 <= c && c <= 6 && (r == 0 || r == 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4 ? this.modules[row + r][col + c] = !0 : this.modules[row + r][col + c] = !1;
+                }
+            }
+        },
+        "getBestMaskPattern": function() {
+            var minLostPoint = 0, pattern = 0;
+            for (var i = 0; i < 8; i++) {
+                this.makeImpl(!0, i);
+                var lostPoint = QRUtil.getLostPoint(this);
+                if (i == 0 || minLostPoint > lostPoint) minLostPoint = lostPoint, pattern = i;
+            }
+            return pattern;
+        },
+        "createMovieClip": function(target_mc, instance_name, depth) {
+            var qr_mc = target_mc.createEmptyMovieClip(instance_name, depth), cs = 1;
+            this.make();
+            for (var row = 0; row < this.modules.length; row++) {
+                var y = row * cs;
+                for (var col = 0; col < this.modules[row].length; col++) {
+                    var x = col * cs, dark = this.modules[row][col];
+                    dark && (qr_mc.beginFill(0, 100), qr_mc.moveTo(x, y), qr_mc.lineTo(x + cs, y), qr_mc.lineTo(x + cs, y + cs), qr_mc.lineTo(x, y + cs), qr_mc.endFill());
+                }
+            }
+            return qr_mc;
+        },
+        "setupTimingPattern": function() {
+            for (var r = 8; r < this.moduleCount - 8; r++) {
+                if (this.modules[r][6] != null) continue;
+                this.modules[r][6] = r % 2 == 0;
+            }
+            for (var c = 8; c < this.moduleCount - 8; c++) {
+                if (this.modules[6][c] != null) continue;
+                this.modules[6][c] = c % 2 == 0;
+            }
+        },
+        "setupPositionAdjustPattern": function() {
+            var pos = QRUtil.getPatternPosition(this.typeNumber);
+            for (var i = 0; i < pos.length; i++) for (var j = 0; j < pos.length; j++) {
+                var row = pos[i], col = pos[j];
+                if (this.modules[row][col] != null) continue;
+                for (var r = -2; r <= 2; r++) for (var c = -2; c <= 2; c++) r == -2 || r == 2 || c == -2 || c == 2 || r == 0 && c == 0 ? this.modules[row + r][col + c] = !0 : this.modules[row + r][col + c] = !1;
+            }
+        },
+        "setupTypeNumber": function(test) {
+            var bits = QRUtil.getBCHTypeNumber(this.typeNumber);
+            for (var i = 0; i < 18; i++) {
+                var mod = !test && (bits >> i & 1) == 1;
+                this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;
+            }
+            for (var i = 0; i < 18; i++) {
+                var mod = !test && (bits >> i & 1) == 1;
+                this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
+            }
+        },
+        "setupTypeInfo": function(test, maskPattern) {
+            var data = this.errorCorrectLevel << 3 | maskPattern, bits = QRUtil.getBCHTypeInfo(data);
+            for (var i = 0; i < 15; i++) {
+                var mod = !test && (bits >> i & 1) == 1;
+                i < 6 ? this.modules[i][8] = mod : i < 8 ? this.modules[i + 1][8] = mod : this.modules[this.moduleCount - 15 + i][8] = mod;
+            }
+            for (var i = 0; i < 15; i++) {
+                var mod = !test && (bits >> i & 1) == 1;
+                i < 8 ? this.modules[8][this.moduleCount - i - 1] = mod : i < 9 ? this.modules[8][15 - i - 1 + 1] = mod : this.modules[8][15 - i - 1] = mod;
+            }
+            this.modules[this.moduleCount - 8][8] = !test;
+        },
+        "mapData": function(data, maskPattern) {
+            var inc = -1, row = this.moduleCount - 1, bitIndex = 7, byteIndex = 0;
+            for (var col = this.moduleCount - 1; col > 0; col -= 2) {
+                col == 6 && col--;
+                for (;;) {
+                    for (var c = 0; c < 2; c++) if (this.modules[row][col - c] == null) {
+                        var dark = !1;
+                        byteIndex < data.length && (dark = (data[byteIndex] >>> bitIndex & 1) == 1);
+                        var mask = QRUtil.getMask(maskPattern, row, col - c);
+                        mask && (dark = !dark), this.modules[row][col - c] = dark, bitIndex--, bitIndex == -1 && (byteIndex++, bitIndex = 7);
+                    }
+                    row += inc;
+                    if (row < 0 || this.moduleCount <= row) {
+                        row -= inc, inc = -inc;
+                        break;
+                    }
+                }
+            }
+        }
+    }, QRCodeModel.PAD0 = 236, QRCodeModel.PAD1 = 17, QRCodeModel.createData = function(typeNumber, errorCorrectLevel, dataList) {
+        var rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel), buffer = new QRBitBuffer;
+        for (var i = 0; i < dataList.length; i++) {
+            var data = dataList[i];
+            buffer.put(data.mode, 4), buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber)), data.write(buffer);
+        }
+        var totalDataCount = 0;
+        for (var i = 0; i < rsBlocks.length; i++) totalDataCount += rsBlocks[i].dataCount;
+        if (buffer.getLengthInBits() > totalDataCount * 8) throw new Error("code length overflow. (" + buffer.getLengthInBits() + ">" + totalDataCount * 8 + ")");
+        buffer.getLengthInBits() + 4 <= totalDataCount * 8 && buffer.put(0, 4);
+        while (buffer.getLengthInBits() % 8 != 0) buffer.putBit(!1);
+        for (;;) {
+            if (buffer.getLengthInBits() >= totalDataCount * 8) break;
+            buffer.put(QRCodeModel.PAD0, 8);
+            if (buffer.getLengthInBits() >= totalDataCount * 8) break;
+            buffer.put(QRCodeModel.PAD1, 8);
+        }
+        return QRCodeModel.createBytes(buffer, rsBlocks);
+    }, QRCodeModel.createBytes = function(buffer, rsBlocks) {
+        var offset = 0, maxDcCount = 0, maxEcCount = 0, dcdata = new Array(rsBlocks.length), ecdata = new Array(rsBlocks.length);
+        for (var r = 0; r < rsBlocks.length; r++) {
+            var dcCount = rsBlocks[r].dataCount, ecCount = rsBlocks[r].totalCount - dcCount;
+            maxDcCount = Math.max(maxDcCount, dcCount), maxEcCount = Math.max(maxEcCount, ecCount), dcdata[r] = new Array(dcCount);
+            for (var i = 0; i < dcdata[r].length; i++) dcdata[r][i] = 255 & buffer.buffer[i + offset];
+            offset += dcCount;
+            var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount), rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1), modPoly = rawPoly.mod(rsPoly);
+            ecdata[r] = new Array(rsPoly.getLength() - 1);
+            for (var i = 0; i < ecdata[r].length; i++) {
+                var modIndex = i + modPoly.getLength() - ecdata[r].length;
+                ecdata[r][i] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
+            }
+        }
+        var totalCodeCount = 0;
+        for (var i = 0; i < rsBlocks.length; i++) totalCodeCount += rsBlocks[i].totalCount;
+        var data = new Array(totalCodeCount), index = 0;
+        for (var i = 0; i < maxDcCount; i++) for (var r = 0; r < rsBlocks.length; r++) i < dcdata[r].length && (data[index++] = dcdata[r][i]);
+        for (var i = 0; i < maxEcCount; i++) for (var r = 0; r < rsBlocks.length; r++) i < ecdata[r].length && (data[index++] = ecdata[r][i]);
+        return data;
+    };
+
+    var QRMode = {
+        "MODE_NUMBER": 1,
+        "MODE_ALPHA_NUM": 2,
+        "MODE_8BIT_BYTE": 4,
+        "MODE_KANJI": 8
+    }, QRErrorCorrectLevel = {
+        "L": 1,
+        "M": 0,
+        "Q": 3,
+        "H": 2
+    }, QRMaskPattern = {
+        "PATTERN000": 0,
+        "PATTERN001": 1,
+        "PATTERN010": 2,
+        "PATTERN011": 3,
+        "PATTERN100": 4,
+        "PATTERN101": 5,
+        "PATTERN110": 6,
+        "PATTERN111": 7
+    }, QRUtil = {
+        "PATTERN_POSITION_TABLE": [ [], [ 6, 18 ], [ 6, 22 ], [ 6, 26 ], [ 6, 30 ], [ 6, 34 ], [ 6, 22, 38 ], [ 6, 24, 42 ], [ 6, 26, 46 ], [ 6, 28, 50 ], [ 6, 30, 54 ], [ 6, 32, 58 ], [ 6, 34, 62 ], [ 6, 26, 46, 66 ], [ 6, 26, 48, 70 ], [ 6, 26, 50, 74 ], [ 6, 30, 54, 78 ], [ 6, 30, 56, 82 ], [ 6, 30, 58, 86 ], [ 6, 34, 62, 90 ], [ 6, 28, 50, 72, 94 ], [ 6, 26, 50, 74, 98 ], [ 6, 30, 54, 78, 102 ], [ 6, 28, 54, 80, 106 ], [ 6, 32, 58, 84, 110 ], [ 6, 30, 58, 86, 114 ], [ 6, 34, 62, 90, 118 ], [ 6, 26, 50, 74, 98, 122 ], [ 6, 30, 54, 78, 102, 126 ], [ 6, 26, 52, 78, 104, 130 ], [ 6, 30, 56, 82, 108, 134 ], [ 6, 34, 60, 86, 112, 138 ], [ 6, 30, 58, 86, 114, 142 ], [ 6, 34, 62, 90, 118, 146 ], [ 6, 30, 54, 78, 102, 126, 150 ], [ 6, 24, 50, 76, 102, 128, 154 ], [ 6, 28, 54, 80, 106, 132, 158 ], [ 6, 32, 58, 84, 110, 136, 162 ], [ 6, 26, 54, 82, 110, 138, 166 ], [ 6, 30, 58, 86, 114, 142, 170 ] ],
+        "G15": 1335,
+        "G18": 7973,
+        "G15_MASK": 21522,
+        "getBCHTypeInfo": function(data) {
+            var d = data << 10;
+            while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) d ^= QRUtil.G15 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15);
+            return (data << 10 | d) ^ QRUtil.G15_MASK;
+        },
+        "getBCHTypeNumber": function(data) {
+            var d = data << 12;
+            while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) d ^= QRUtil.G18 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18);
+            return data << 12 | d;
+        },
+        "getBCHDigit": function(data) {
+            var digit = 0;
+            while (data != 0) digit++, data >>>= 1;
+            return digit;
+        },
+        "getPatternPosition": function(typeNumber) {
+            return QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];
+        },
+        "getMask": function(maskPattern, i, j) {
+            switch (maskPattern) {
+              case QRMaskPattern.PATTERN000:
+                return (i + j) % 2 == 0;
+              case QRMaskPattern.PATTERN001:
+                return i % 2 == 0;
+              case QRMaskPattern.PATTERN010:
+                return j % 3 == 0;
+              case QRMaskPattern.PATTERN011:
+                return (i + j) % 3 == 0;
+              case QRMaskPattern.PATTERN100:
+                return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0;
+              case QRMaskPattern.PATTERN101:
+                return i * j % 2 + i * j % 3 == 0;
+              case QRMaskPattern.PATTERN110:
+                return (i * j % 2 + i * j % 3) % 2 == 0;
+              case QRMaskPattern.PATTERN111:
+                return (i * j % 3 + (i + j) % 2) % 2 == 0;
+              default:
+                throw new Error("bad maskPattern:" + maskPattern);
+            }
+        },
+        "getErrorCorrectPolynomial": function(errorCorrectLength) {
+            var a = new QRPolynomial([ 1 ], 0);
+            for (var i = 0; i < errorCorrectLength; i++) a = a.multiply(new QRPolynomial([ 1, QRMath.gexp(i) ], 0));
+            return a;
+        },
+        "getLengthInBits": function(mode, type) {
+            if (1 <= type && type < 10) switch (mode) {
+              case QRMode.MODE_NUMBER:
+                return 10;
+              case QRMode.MODE_ALPHA_NUM:
+                return 9;
+              case QRMode.MODE_8BIT_BYTE:
+                return 8;
+              case QRMode.MODE_KANJI:
+                return 8;
+              default:
+                throw new Error("mode:" + mode);
+            } else if (type < 27) switch (mode) {
+              case QRMode.MODE_NUMBER:
+                return 12;
+              case QRMode.MODE_ALPHA_NUM:
+                return 11;
+              case QRMode.MODE_8BIT_BYTE:
+                return 16;
+              case QRMode.MODE_KANJI:
+                return 10;
+              default:
+                throw new Error("mode:" + mode);
+            } else {
+                if (!(type < 41)) throw new Error("type:" + type);
+                switch (mode) {
+                  case QRMode.MODE_NUMBER:
+                    return 14;
+                  case QRMode.MODE_ALPHA_NUM:
+                    return 13;
+                  case QRMode.MODE_8BIT_BYTE:
+                    return 16;
+                  case QRMode.MODE_KANJI:
+                    return 12;
+                  default:
+                    throw new Error("mode:" + mode);
+                }
+            }
+        },
+        "getLostPoint": function(qrCode) {
+            var moduleCount = qrCode.getModuleCount(), lostPoint = 0;
+            for (var row = 0; row < moduleCount; row++) for (var col = 0; col < moduleCount; col++) {
+                var sameCount = 0, dark = qrCode.isDark(row, col);
+                for (var r = -1; r <= 1; r++) {
+                    if (row + r < 0 || moduleCount <= row + r) continue;
+                    for (var c = -1; c <= 1; c++) {
+                        if (col + c < 0 || moduleCount <= col + c) continue;
+                        if (r == 0 && c == 0) continue;
+                        dark == qrCode.isDark(row + r, col + c) && sameCount++;
+                    }
+                }
+                sameCount > 5 && (lostPoint += 3 + sameCount - 5);
+            }
+            for (var row = 0; row < moduleCount - 1; row++) for (var col = 0; col < moduleCount - 1; col++) {
+                var count = 0;
+                qrCode.isDark(row, col) && count++, qrCode.isDark(row + 1, col) && count++, qrCode.isDark(row, col + 1) && count++, qrCode.isDark(row + 1, col + 1) && count++;
+                if (count == 0 || count == 4) lostPoint += 3;
+            }
+            for (var row = 0; row < moduleCount; row++) for (var col = 0; col < moduleCount - 6; col++) qrCode.isDark(row, col) && !qrCode.isDark(row, col + 1) && qrCode.isDark(row, col + 2) && qrCode.isDark(row, col + 3) && qrCode.isDark(row, col + 4) && !qrCode.isDark(row, col + 5) && qrCode.isDark(row, col + 6) && (lostPoint += 40);
+            for (var col = 0; col < moduleCount; col++) for (var row = 0; row < moduleCount - 6; row++) qrCode.isDark(row, col) && !qrCode.isDark(row + 1, col) && qrCode.isDark(row + 2, col) && qrCode.isDark(row + 3, col) && qrCode.isDark(row + 4, col) && !qrCode.isDark(row + 5, col) && qrCode.isDark(row + 6, col) && (lostPoint += 40);
+            var darkCount = 0;
+            for (var col = 0; col < moduleCount; col++) for (var row = 0; row < moduleCount; row++) qrCode.isDark(row, col) && darkCount++;
+            var ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
+            return lostPoint += ratio * 10, lostPoint;
+        }
+    }, QRMath = {
+        "glog": function(n) {
+            if (n < 1) throw new Error("glog(" + n + ")");
+            return QRMath.LOG_TABLE[n];
+        },
+        "gexp": function(n) {
+            while (n < 0) n += 255;
+            while (n >= 256) n -= 255;
+            return QRMath.EXP_TABLE[n];
+        },
+        "EXP_TABLE": new Array(256),
+        "LOG_TABLE": new Array(256)
+    };
+
+    for (var i = 0; i < 8; i++) QRMath.EXP_TABLE[i] = 1 << i;
+
+    for (var i = 8; i < 256; i++) QRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4] ^ QRMath.EXP_TABLE[i - 5] ^ QRMath.EXP_TABLE[i - 6] ^ QRMath.EXP_TABLE[i - 8];
+
+    for (var i = 0; i < 255; i++) QRMath.LOG_TABLE[QRMath.EXP_TABLE[i]] = i;
+
+    QRPolynomial.prototype = {
+        "get": function(index) {
+            return this.num[index];
+        },
+        "getLength": function() {
+            return this.num.length;
+        },
+        "multiply": function(e) {
+            var num = new Array(this.getLength() + e.getLength() - 1);
+            for (var i = 0; i < this.getLength(); i++) for (var j = 0; j < e.getLength(); j++) num[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));
+            return new QRPolynomial(num, 0);
+        },
+        "mod": function(e) {
+            if (this.getLength() - e.getLength() < 0) return this;
+            var ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0)), num = new Array(this.getLength());
+            for (var i = 0; i < this.getLength(); i++) num[i] = this.get(i);
+            for (var i = 0; i < e.getLength(); i++) num[i] ^= QRMath.gexp(QRMath.glog(e.get(i)) + ratio);
+            return (new QRPolynomial(num, 0)).mod(e);
+        }
+    }, QRRSBlock.RS_BLOCK_TABLE = [ [ 1, 26, 19 ], [ 1, 26, 16 ], [ 1, 26, 13 ], [ 1, 26, 9 ], [ 1, 44, 34 ], [ 1, 44, 28 ], [ 1, 44, 22 ], [ 1, 44, 16 ], [ 1, 70, 55 ], [ 1, 70, 44 ], [ 2, 35, 17 ], [ 2, 35, 13 ], [ 1, 100, 80 ], [ 2, 50, 32 ], [ 2, 50, 24 ], [ 4, 25, 9 ], [ 1, 134, 108 ], [ 2, 67, 43 ], [ 2, 33, 15, 2, 34, 16 ], [ 2, 33, 11, 2, 34, 12 ], [ 2, 86, 68 ], [ 4, 43, 27 ], [ 4, 43, 19 ], [ 4, 43, 15 ], [ 2, 98, 78 ], [ 4, 49, 31 ], [ 2, 32, 14, 4, 33, 15 ], [ 4, 39, 13, 1, 40, 14 ], [ 2, 121, 97 ], [ 2, 60, 38, 2, 61, 39 ], [ 4, 40, 18, 2, 41, 19 ], [ 4, 40, 14, 2, 41, 15 ], [ 2, 146, 116 ], [ 3, 58, 36, 2, 59, 37 ], [ 4, 36, 16, 4, 37, 17 ], [ 4, 36, 12, 4, 37, 13 ], [ 2, 86, 68, 2, 87, 69 ], [ 4, 69, 43, 1, 70, 44 ], [ 6, 43, 19, 2, 44, 20 ], [ 6, 43, 15, 2, 44, 16 ], [ 4, 101, 81 ], [ 1, 80, 50, 4, 81, 51 ], [ 4, 50, 22, 4, 51, 23 ], [ 3, 36, 12, 8, 37, 13 ], [ 2, 116, 92, 2, 117, 93 ], [ 6, 58, 36, 2, 59, 37 ], [ 4, 46, 20, 6, 47, 21 ], [ 7, 42, 14, 4, 43, 15 ], [ 4, 133, 107 ], [ 8, 59, 37, 1, 60, 38 ], [ 8, 44, 20, 4, 45, 21 ], [ 12, 33, 11, 4, 34, 12 ], [ 3, 145, 115, 1, 146, 116 ], [ 4, 64, 40, 5, 65, 41 ], [ 11, 36, 16, 5, 37, 17 ], [ 11, 36, 12, 5, 37, 13 ], [ 5, 109, 87, 1, 110, 88 ], [ 5, 65, 41, 5, 66, 42 ], [ 5, 54, 24, 7, 55, 25 ], [ 11, 36, 12 ], [ 5, 122, 98, 1, 123, 99 ], [ 7, 73, 45, 3, 74, 46 ], [ 15, 43, 19, 2, 44, 20 ], [ 3, 45, 15, 13, 46, 16 ], [ 1, 135, 107, 5, 136, 108 ], [ 10, 74, 46, 1, 75, 47 ], [ 1, 50, 22, 15, 51, 23 ], [ 2, 42, 14, 17, 43, 15 ], [ 5, 150, 120, 1, 151, 121 ], [ 9, 69, 43, 4, 70, 44 ], [ 17, 50, 22, 1, 51, 23 ], [ 2, 42, 14, 19, 43, 15 ], [ 3, 141, 113, 4, 142, 114 ], [ 3, 70, 44, 11, 71, 45 ], [ 17, 47, 21, 4, 48, 22 ], [ 9, 39, 13, 16, 40, 14 ], [ 3, 135, 107, 5, 136, 108 ], [ 3, 67, 41, 13, 68, 42 ], [ 15, 54, 24, 5, 55, 25 ], [ 15, 43, 15, 10, 44, 16 ], [ 4, 144, 116, 4, 145, 117 ], [ 17, 68, 42 ], [ 17, 50, 22, 6, 51, 23 ], [ 19, 46, 16, 6, 47, 17 ], [ 2, 139, 111, 7, 140, 112 ], [ 17, 74, 46 ], [ 7, 54, 24, 16, 55, 25 ], [ 34, 37, 13 ], [ 4, 151, 121, 5, 152, 122 ], [ 4, 75, 47, 14, 76, 48 ], [ 11, 54, 24, 14, 55, 25 ], [ 16, 45, 15, 14, 46, 16 ], [ 6, 147, 117, 4, 148, 118 ], [ 6, 73, 45, 14, 74, 46 ], [ 11, 54, 24, 16, 55, 25 ], [ 30, 46, 16, 2, 47, 17 ], [ 8, 132, 106, 4, 133, 107 ], [ 8, 75, 47, 13, 76, 48 ], [ 7, 54, 24, 22, 55, 25 ], [ 22, 45, 15, 13, 46, 16 ], [ 10, 142, 114, 2, 143, 115 ], [ 19, 74, 46, 4, 75, 47 ], [ 28, 50, 22, 6, 51, 23 ], [ 33, 46, 16, 4, 47, 17 ], [ 8, 152, 122, 4, 153, 123 ], [ 22, 73, 45, 3, 74, 46 ], [ 8, 53, 23, 26, 54, 24 ], [ 12, 45, 15, 28, 46, 16 ], [ 3, 147, 117, 10, 148, 118 ], [ 3, 73, 45, 23, 74, 46 ], [ 4, 54, 24, 31, 55, 25 ], [ 11, 45, 15, 31, 46, 16 ], [ 7, 146, 116, 7, 147, 117 ], [ 21, 73, 45, 7, 74, 46 ], [ 1, 53, 23, 37, 54, 24 ], [ 19, 45, 15, 26, 46, 16 ], [ 5, 145, 115, 10, 146, 116 ], [ 19, 75, 47, 10, 76, 48 ], [ 15, 54, 24, 25, 55, 25 ], [ 23, 45, 15, 25, 46, 16 ], [ 13, 145, 115, 3, 146, 116 ], [ 2, 74, 46, 29, 75, 47 ], [ 42, 54, 24, 1, 55, 25 ], [ 23, 45, 15, 28, 46, 16 ], [ 17, 145, 115 ], [ 10, 74, 46, 23, 75, 47 ], [ 10, 54, 24, 35, 55, 25 ], [ 19, 45, 15, 35, 46, 16 ], [ 17, 145, 115, 1, 146, 116 ], [ 14, 74, 46, 21, 75, 47 ], [ 29, 54, 24, 19, 55, 25 ], [ 11, 45, 15, 46, 46, 16 ], [ 13, 145, 115, 6, 146, 116 ], [ 14, 74, 46, 23, 75, 47 ], [ 44, 54, 24, 7, 55, 25 ], [ 59, 46, 16, 1, 47, 17 ], [ 12, 151, 121, 7, 152, 122 ], [ 12, 75, 47, 26, 76, 48 ], [ 39, 54, 24, 14, 55, 25 ], [ 22, 45, 15, 41, 46, 16 ], [ 6, 151, 121, 14, 152, 122 ], [ 6, 75, 47, 34, 76, 48 ], [ 46, 54, 24, 10, 55, 25 ], [ 2, 45, 15, 64, 46, 16 ], [ 17, 152, 122, 4, 153, 123 ], [ 29, 74, 46, 14, 75, 47 ], [ 49, 54, 24, 10, 55, 25 ], [ 24, 45, 15, 46, 46, 16 ], [ 4, 152, 122, 18, 153, 123 ], [ 13, 74, 46, 32, 75, 47 ], [ 48, 54, 24, 14, 55, 25 ], [ 42, 45, 15, 32, 46, 16 ], [ 20, 147, 117, 4, 148, 118 ], [ 40, 75, 47, 7, 76, 48 ], [ 43, 54, 24, 22, 55, 25 ], [ 10, 45, 15, 67, 46, 16 ], [ 19, 148, 118, 6, 149, 119 ], [ 18, 75, 47, 31, 76, 48 ], [ 34, 54, 24, 34, 55, 25 ], [ 20, 45, 15, 61, 46, 16 ] ], QRRSBlock.getRSBlocks = function(typeNumber, errorCorrectLevel) {
+        var rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);
+        if (rsBlock == undefined) throw new Error("bad rs block @ typeNumber:" + typeNumber + "/errorCorrectLevel:" + errorCorrectLevel);
+        var length = rsBlock.length / 3, list = [];
+        for (var i = 0; i < length; i++) {
+            var count = rsBlock[i * 3 + 0], totalCount = rsBlock[i * 3 + 1], dataCount = rsBlock[i * 3 + 2];
+            for (var j = 0; j < count; j++) list.push(new QRRSBlock(totalCount, dataCount));
+        }
+        return list;
+    }, QRRSBlock.getRsBlockTable = function(typeNumber, errorCorrectLevel) {
+        switch (errorCorrectLevel) {
+          case QRErrorCorrectLevel.L:
+            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
+          case QRErrorCorrectLevel.M:
+            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
+          case QRErrorCorrectLevel.Q:
+            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
+          case QRErrorCorrectLevel.H:
+            return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
+          default:
+            return undefined;
+        }
+    }, QRBitBuffer.prototype = {
+        "get": function(index) {
+            var bufIndex = Math.floor(index / 8);
+            return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;
+        },
+        "put": function(num, length) {
+            for (var i = 0; i < length; i++) this.putBit((num >>> length - i - 1 & 1) == 1);
+        },
+        "getLengthInBits": function() {
+            return this.length;
+        },
+        "putBit": function(bit) {
+            var bufIndex = Math.floor(this.length / 8);
+            this.buffer.length <= bufIndex && this.buffer.push(0), bit && (this.buffer[bufIndex] |= 128 >>> this.length % 8), this.length++;
+        }
+    };
+    var QRCodeLimitLength=[[17,14,11,7],[32,26,20,14],[53,42,32,24],[78,62,46,34],[106,84,60,44],[134,106,74,58],[154,122,86,64],[192,152,108,84],[230,180,130,98],[271,213,151,119],[321,251,177,137],[367,287,203,155],[425,331,241,177],[458,362,258,194],[520,412,292,220],[586,450,322,250],[644,504,364,280],[718,560,394,310],[792,624,442,338],[858,666,482,382],[929,711,509,403],[1003,779,565,439],[1091,857,611,461],[1171,911,661,511],[1273,997,715,535],[1367,1059,751,593],[1465,1125,805,625],[1528,1190,868,658],[1628,1264,908,698],[1732,1370,982,742],[1840,1452,1030,790],[1952,1538,1112,842],[2068,1628,1168,898],[2188,1722,1228,958],[2303,1809,1283,983],[2431,1911,1351,1051],[2563,1989,1423,1093],[2699,2099,1499,1139],[2809,2213,1579,1219],[2953,2331,1663,1273]];
+    
+    function _isSupportCanvas() {
+        return typeof CanvasRenderingContext2D != "undefined";
+    }
+    
+    // android 2.x doesn't support Data-URI spec
+    function _getAndroid() {
+        var android = false;
+        var sAgent = navigator.userAgent;
+        
+        if (/android/i.test(sAgent)) { // android
+            android = true;
+            aMat = sAgent.toString().match(/android ([0-9]\.[0-9])/i);
+            
+            if (aMat && aMat[1]) {
+                android = parseFloat(aMat[1]);
+            }
+        }
+        
+        return android;
+    }
+    
+    var svgDrawer = (function() {
+
+        var Drawing = function (el, htOption) {
+            this._el = el;
+            this._htOption = htOption;
+        };
+
+        Drawing.prototype.draw = function (oQRCode) {
+            var _htOption = this._htOption;
+            var _el = this._el;
+            var nCount = oQRCode.getModuleCount();
+            var nWidth = Math.floor(_htOption.width / nCount);
+            var nHeight = Math.floor(_htOption.height / nCount);
+
+            this.clear();
+
+            function makeSVG(tag, attrs) {
+                var el = document.createElementNS('http://www.w3.org/2000/svg', tag);
+                for (var k in attrs)
+                    if (attrs.hasOwnProperty(k)) el.setAttribute(k, attrs[k]);
+                return el;
+            }
+
+            var svg = makeSVG("svg" , {'viewBox': '0 0 ' + String(nCount) + " " + String(nCount), 'width': '100%', 'height': '100%', 'fill': _htOption.colorLight});
+            svg.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", "http://www.w3.org/1999/xlink");
+            _el.appendChild(svg);
+
+            svg.appendChild(makeSVG("rect", {"fill": _htOption.colorDark, "width": "1", "height": "1", "id": "template"}));
+
+            for (var row = 0; row < nCount; row++) {
+                for (var col = 0; col < nCount; col++) {
+                    if (oQRCode.isDark(row, col)) {
+                        var child = makeSVG("use", {"x": String(row), "y": String(col)});
+                        child.setAttributeNS("http://www.w3.org/1999/xlink", "href", "#template")
+                        svg.appendChild(child);
+                    }
+                }
+            }
+        };
+        Drawing.prototype.clear = function () {
+            while (this._el.hasChildNodes())
+                this._el.removeChild(this._el.lastChild);
+        };
+        return Drawing;
+    })();
+
+    var useSVG = document.documentElement.tagName.toLowerCase() === "svg";
+
+    // Drawing in DOM by using Table tag
+    var Drawing = useSVG ? svgDrawer : !_isSupportCanvas() ? (function () {
+        var Drawing = function (el, htOption) {
+            this._el = el;
+            this._htOption = htOption;
+        };
+            
+        /**
+         * Draw the QRCode
+         * 
+         * @param {QRCode} oQRCode
+         */
+        Drawing.prototype.draw = function (oQRCode) {
+            var _htOption = this._htOption;
+            var _el = this._el;
+            var nCount = oQRCode.getModuleCount();
+            var nWidth = Math.floor(_htOption.width / nCount);
+            var nHeight = Math.floor(_htOption.height / nCount);
+            var aHTML = ['<table style="border:0;border-collapse:collapse;">'];
+            
+            for (var row = 0; row < nCount; row++) {
+                aHTML.push('<tr>');
+                
+                for (var col = 0; col < nCount; col++) {
+                    aHTML.push('<td style="border:0;border-collapse:collapse;padding:0;margin:0;width:' + nWidth + 'px;height:' + nHeight + 'px;background-color:' + (oQRCode.isDark(row, col) ? _htOption.colorDark : _htOption.colorLight) + ';"></td>');
+                }
+                
+                aHTML.push('</tr>');
+            }
+            
+            aHTML.push('</table>');
+            _el.innerHTML = aHTML.join('');
+            
+            // Fix the margin values as real size.
+            var elTable = _el.childNodes[0];
+            var nLeftMarginTable = (_htOption.width - elTable.offsetWidth) / 2;
+            var nTopMarginTable = (_htOption.height - elTable.offsetHeight) / 2;
+            if (nLeftMarginTable > 0 && nTopMarginTable > 0) {
+                elTable.style.margin = nTopMarginTable + "px " + nLeftMarginTable + "px";    
+            }
+        };
+        
+        /**
+         * Clear the QRCode
+         */
+        Drawing.prototype.clear = function () {
+            this._el.innerHTML = '';
+        };
+        
+        return Drawing;
+    })() : (function () { // Drawing in Canvas
+        function _onMakeImage() {
+            this._elImage.src = this._elCanvas.toDataURL("image/png");
+            this._elImage.style.display = "block";
+            this._elCanvas.style.display = "none";            
+        }
+        
+        // Android 2.1 bug workaround
+        // http://code.google.com/p/android/issues/detail?id=5141
+        if (this._android && this._android <= 2.1) {
+            var factor = 1 / window.devicePixelRatio;
+            var drawImage = CanvasRenderingContext2D.prototype.drawImage; 
+            CanvasRenderingContext2D.prototype.drawImage = function (image, sx, sy, sw, sh, dx, dy, dw, dh) {
+                if (("nodeName" in image) && /img/i.test(image.nodeName)) {
+                    for (var i = arguments.length - 1; i >= 1; i--) {
+                        arguments[i] = arguments[i] * factor;
+                    }
+                } else if (typeof dw == "undefined") {
+                    arguments[1] *= factor;
+                    arguments[2] *= factor;
+                    arguments[3] *= factor;
+                    arguments[4] *= factor;
+                }
+                
+                drawImage.apply(this, arguments); 
+            };
+        }
+        
+        /**
+         * Check whether the user's browser supports Data URI or not
+         * 
+         * @private
+         * @param {Function} fSuccess Occurs if it supports Data URI
+         * @param {Function} fFail Occurs if it doesn't support Data URI
+         */
+        function _safeSetDataURI(fSuccess, fFail) {
+            var self = this;
+            self._fFail = fFail;
+            self._fSuccess = fSuccess;
+
+            // Check it just once
+            if (self._bSupportDataURI === null) {
+                var el = document.createElement("img");
+                var fOnError = function() {
+                    self._bSupportDataURI = false;
+
+                    if (self._fFail) {
+                        _fFail.call(self);
+                    }
+                };
+                var fOnSuccess = function() {
+                    self._bSupportDataURI = true;
+
+                    if (self._fSuccess) {
+                        self._fSuccess.call(self);
+                    }
+                };
+
+                el.onabort = fOnError;
+                el.onerror = fOnError;
+                el.onload = fOnSuccess;
+                el.src = "data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=="; // the Image contains 1px data.
+                return;
+            } else if (self._bSupportDataURI === true && self._fSuccess) {
+                self._fSuccess.call(self);
+            } else if (self._bSupportDataURI === false && self._fFail) {
+                self._fFail.call(self);
+            }
+        };
+        
+        /**
+         * Drawing QRCode by using canvas
+         * 
+         * @constructor
+         * @param {HTMLElement} el
+         * @param {Object} htOption QRCode Options 
+         */
+        var Drawing = function (el, htOption) {
+            this._bIsPainted = false;
+            this._android = _getAndroid();
+        
+            this._htOption = htOption;
+            this._elCanvas = document.createElement("canvas");
+            this._elCanvas.width = htOption.width;
+            this._elCanvas.height = htOption.height;
+            el.appendChild(this._elCanvas);
+            this._el = el;
+            this._oContext = this._elCanvas.getContext("2d");
+            this._bIsPainted = false;
+            this._elImage = document.createElement("img");
+            this._elImage.alt = "Scan me!";
+            this._elImage.style.display = "none";
+            this._el.appendChild(this._elImage);
+            this._bSupportDataURI = null;
+        };
+            
+        /**
+         * Draw the QRCode
+         * 
+         * @param {QRCode} oQRCode 
+         */
+        Drawing.prototype.draw = function (oQRCode) {
+            var _elImage = this._elImage;
+            var _oContext = this._oContext;
+            var _htOption = this._htOption;
+            
+            var nCount = oQRCode.getModuleCount();
+            var nWidth = _htOption.width / nCount;
+            var nHeight = _htOption.height / nCount;
+            var nRoundedWidth = Math.round(nWidth);
+            var nRoundedHeight = Math.round(nHeight);
+
+            _elImage.style.display = "none";
+            this.clear();
+            
+            for (var row = 0; row < nCount; row++) {
+                for (var col = 0; col < nCount; col++) {
+                    var bIsDark = oQRCode.isDark(row, col);
+                    var nLeft = col * nWidth;
+                    var nTop = row * nHeight;
+                    _oContext.strokeStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;
+                    _oContext.lineWidth = 1;
+                    _oContext.fillStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;                    
+                    _oContext.fillRect(nLeft, nTop, nWidth, nHeight);
+
+                    _oContext.strokeRect(
+                        Math.floor(nLeft) + 0.5,
+                        Math.floor(nTop) + 0.5,
+                        nRoundedWidth,
+                        nRoundedHeight
+                    );
+                    
+                    _oContext.strokeRect(
+                        Math.ceil(nLeft) - 0.5,
+                        Math.ceil(nTop) - 0.5,
+                        nRoundedWidth,
+                        nRoundedHeight
+                    );
+                }
+            }
+            
+            this._bIsPainted = true;
+        };
+            
+        /**
+         * Make the image from Canvas if the browser supports Data URI.
+         */
+        Drawing.prototype.makeImage = function () {
+            if (this._bIsPainted) {
+                _safeSetDataURI.call(this, _onMakeImage);
+            }
+        };
+            
+        /**
+         * Return whether the QRCode is painted or not
+         * 
+         * @return {Boolean}
+         */
+        Drawing.prototype.isPainted = function () {
+            return this._bIsPainted;
+        };
+        
+        /**
+         * Clear the QRCode
+         */
+        Drawing.prototype.clear = function () {
+            this._oContext.clearRect(0, 0, this._elCanvas.width, this._elCanvas.height);
+            this._bIsPainted = false;
+        };
+        
+        /**
+         * @private
+         * @param {Number} nNumber
+         */
+        Drawing.prototype.round = function (nNumber) {
+            if (!nNumber) {
+                return nNumber;
+            }
+            
+            return Math.floor(nNumber * 1000) / 1000;
+        };
+        
+        return Drawing;
+    })();
+    
+    /**
+     * Get the type by string length
+     * 
+     * @private
+     * @param {String} sText
+     * @param {Number} nCorrectLevel
+     * @return {Number} type
+     */
+    function _getTypeNumber(sText, nCorrectLevel) {            
+        var nType = 1;
+        var length = _getUTF8Length(sText);
+        
+        for (var i = 0, len = QRCodeLimitLength.length; i <= len; i++) {
+            var nLimit = 0;
+            
+            switch (nCorrectLevel) {
+                case QRErrorCorrectLevel.L :
+                    nLimit = QRCodeLimitLength[i][0];
+                    break;
+                case QRErrorCorrectLevel.M :
+                    nLimit = QRCodeLimitLength[i][1];
+                    break;
+                case QRErrorCorrectLevel.Q :
+                    nLimit = QRCodeLimitLength[i][2];
+                    break;
+                case QRErrorCorrectLevel.H :
+                    nLimit = QRCodeLimitLength[i][3];
+                    break;
+            }
+            
+            if (length <= nLimit) {
+                break;
+            } else {
+                nType++;
+            }
+        }
+        
+        if (nType > QRCodeLimitLength.length) {
+            throw new Error("Too long data");
+        }
+        
+        return nType;
+    }
+
+    function _getUTF8Length(sText) {
+        var replacedText = encodeURI(sText).toString().replace(/\%[0-9a-fA-F]{2}/g, 'a');
+        return replacedText.length + (replacedText.length != sText ? 3 : 0);
+    }
+    
+    /**
+     * @class QRCode
+     * @constructor
+     * @example 
+     * new QRCode(document.getElementById("test"), "http://jindo.dev.naver.com/collie");
+     *
+     * @example
+     * var oQRCode = new QRCode("test", {
+     *    text : "http://naver.com",
+     *    width : 128,
+     *    height : 128
+     * });
+     * 
+     * oQRCode.clear(); // Clear the QRCode.
+     * oQRCode.makeCode("http://map.naver.com"); // Re-create the QRCode.
+     *
+     * @param {HTMLElement|String} el target element or 'id' attribute of element.
+     * @param {Object|String} vOption
+     * @param {String} vOption.text QRCode link data
+     * @param {Number} [vOption.width=256]
+     * @param {Number} [vOption.height=256]
+     * @param {String} [vOption.colorDark="#000000"]
+     * @param {String} [vOption.colorLight="#ffffff"]
+     * @param {QRCode.CorrectLevel} [vOption.correctLevel=QRCode.CorrectLevel.H] [L|M|Q|H] 
+     */
+    QRCode = function (el, vOption) {
+        this._htOption = {
+            width : 256, 
+            height : 256,
+            typeNumber : 4,
+            colorDark : "#000000",
+            colorLight : "#ffffff",
+            correctLevel : QRErrorCorrectLevel.H
+        };
+        
+        if (typeof vOption === 'string') {
+            vOption    = {
+                text : vOption
+            };
+        }
+        
+        // Overwrites options
+        if (vOption) {
+            for (var i in vOption) {
+                this._htOption[i] = vOption[i];
+            }
+        }
+        
+        if (typeof el == "string") {
+            el = document.getElementById(el);
+        }
+        
+        this._android = _getAndroid();
+        this._el = el;
+        this._oQRCode = null;
+        this._oDrawing = new Drawing(this._el, this._htOption);
+        
+        if (this._htOption.text) {
+            this.makeCode(this._htOption.text);    
+        }
+    };
+    
+    /**
+     * Make the QRCode
+     * 
+     * @param {String} sText link data
+     */
+    QRCode.prototype.makeCode = function (sText) {
+        this._oQRCode = new QRCodeModel(_getTypeNumber(sText, this._htOption.correctLevel), this._htOption.correctLevel);
+        this._oQRCode.addData(sText);
+        this._oQRCode.make();
+        this._el.title = sText;
+        this._oDrawing.draw(this._oQRCode);            
+        this.makeImage();
+    };
+    
+    /**
+     * Make the Image from Canvas element
+     * - It occurs automatically
+     * - Android below 3 doesn't support Data-URI spec.
+     * 
+     * @private
+     */
+    QRCode.prototype.makeImage = function () {
+        if (typeof this._oDrawing.makeImage == "function" && (!this._android || this._android >= 3)) {
+            this._oDrawing.makeImage();
+        }
+    };
+    
+    /**
+     * Clear the QRCode
+     */
+    QRCode.prototype.clear = function () {
+        this._el.innerHTML = '';
+        this._oDrawing.clear();
+    };
+    
+    /**
+     * @name QRCode.CorrectLevel
+     */
+    QRCode.CorrectLevel = QRErrorCorrectLevel;
 })();
\ No newline at end of file
diff --git "a/14 - Front-end/react/01 \345\237\272\346\234\254.txt" "b/14 - Front-end \345\211\215\347\253\257/react/01 \345\237\272\346\234\254.txt"
similarity index 97%
rename from "14 - Front-end/react/01 \345\237\272\346\234\254.txt"
rename to "14 - Front-end \345\211\215\347\253\257/react/01 \345\237\272\346\234\254.txt"
index f281df2f..23622022 100644
--- "a/14 - Front-end/react/01 \345\237\272\346\234\254.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/01 \345\237\272\346\234\254.txt"	
@@ -1,35 +1,35 @@
-React 是一个用于构建用户界面的 JAVASCRIPT 库。
-React主要用于构建UI，很多人认为 React 是 MVC 中的 V（视图）。
-React 起源于 Facebook 的内部项目，用来架设 Instagram 的网站，并于 2013 年 5 月开源。
-React 拥有较高的性能，代码逻辑非常简单，越来越多的人已开始关注和使用它。
-
-React 特点
-1.声明式设计 −React采用声明范式，可以轻松描述应用。
-2.高效 −React通过对DOM的模拟，最大限度地减少与DOM的交互。
-3.灵活 −React可以与已知的库或框架很好地配合。
-4.JSX − JSX 是 JavaScript 语法的扩展。React 开发不一定使用 JSX ，但我们建议使用它。
-5.组件 − 通过 React 构建组件，使得代码更加容易得到复用，能够很好的应用在大项目的开发中。
-6.单向响应的数据流 − React 实现了单向响应的数据流，从而减少了重复代码，这也是它为什么比传统数据绑定更简单。
-
-
-
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8" />
-    <title>Hello React!</title>
-    <script src="https://cdn.bootcss.com/react/15.4.2/react.min.js"></script>
-    <script src="https://cdn.bootcss.com/react/15.4.2/react-dom.min.js"></script>
-    <script src="https://cdn.bootcss.com/babel-standalone/6.22.1/babel.min.js"></script>
-  </head>
-  <body>
-    <div id="example"></div>
-    <script type="text/babel">
-      ReactDOM.render(
-        <h1>Hello, world!</h1>,
-        document.getElementById('example')
-      );
-    </script>
-  </body>
-</html>
-
+React 是一个用于构建用户界面的 JAVASCRIPT 库。
+React主要用于构建UI，很多人认为 React 是 MVC 中的 V（视图）。
+React 起源于 Facebook 的内部项目，用来架设 Instagram 的网站，并于 2013 年 5 月开源。
+React 拥有较高的性能，代码逻辑非常简单，越来越多的人已开始关注和使用它。
+
+React 特点
+1.声明式设计 −React采用声明范式，可以轻松描述应用。
+2.高效 −React通过对DOM的模拟，最大限度地减少与DOM的交互。
+3.灵活 −React可以与已知的库或框架很好地配合。
+4.JSX − JSX 是 JavaScript 语法的扩展。React 开发不一定使用 JSX ，但我们建议使用它。
+5.组件 − 通过 React 构建组件，使得代码更加容易得到复用，能够很好的应用在大项目的开发中。
+6.单向响应的数据流 − React 实现了单向响应的数据流，从而减少了重复代码，这也是它为什么比传统数据绑定更简单。
+
+
+
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>Hello React!</title>
+    <script src="https://cdn.bootcss.com/react/15.4.2/react.min.js"></script>
+    <script src="https://cdn.bootcss.com/react/15.4.2/react-dom.min.js"></script>
+    <script src="https://cdn.bootcss.com/babel-standalone/6.22.1/babel.min.js"></script>
+  </head>
+  <body>
+    <div id="example"></div>
+    <script type="text/babel">
+      ReactDOM.render(
+        <h1>Hello, world!</h1>,
+        document.getElementById('example')
+      );
+    </script>
+  </body>
+</html>
+
diff --git "a/14 - Front-end/react/02 \345\256\211\350\243\205.txt" "b/14 - Front-end \345\211\215\347\253\257/react/02 \345\256\211\350\243\205.txt"
similarity index 97%
rename from "14 - Front-end/react/02 \345\256\211\350\243\205.txt"
rename to "14 - Front-end \345\211\215\347\253\257/react/02 \345\256\211\350\243\205.txt"
index d71e53fd..10798cfe 100644
--- "a/14 - Front-end/react/02 \345\256\211\350\243\205.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/02 \345\256\211\350\243\205.txt"	
@@ -1,51 +1,51 @@
-React 可以直接下载使用，下载包中也提供了很多学习的实例。
-
-本教程使用了 React 的版本为 15.4.2，你可以在官网 http://facebook.github.io/react/ 下载最新版。
-
-你也可以直接使用 BootCDN 的 React CDN 库，地址如下：
-
-<script src="https://cdn.bootcss.com/react/15.4.2/react.min.js"></script>
-<script src="https://cdn.bootcss.com/react/15.4.2/react-dom.min.js"></script>
-<script src="https://cdn.bootcss.com/babel-standalone/6.22.1/babel.min.js"></script>
-
-react.min.js - React 的核心库
-react-dom.min.js - 提供与 DOM 相关的功能
-babel.min.js - Babel 可以将 ES6 代码转为 ES5 代码，这样我们就能在目前不支持 ES6 浏览器上执行 React 代码。
-			   Babel 内嵌了对 JSX 的支持。通过将 Babel 和 babel-sublime 包（package）一同使用可以让源码的语法渲染上升到一个全新的水平。
-			   
-
-通过 npm 使用 React
-我们建议在 React 中使用 CommonJS 模块系统，比如 browserify 或 webpack，本教程使用 webpack。
-国内使用 npm 速度很慢，你可以使用淘宝定制的 cnpm (gzip 压缩支持) 命令行工具代替默认的 npm:
-$ npm install -g cnpm --registry=https://registry.npm.taobao.org
-$ npm config set registry https://registry.npm.taobao.org
-这样就可以使用 cnpm 命令来安装模块了：
-$ cnpm install [name]
-更多信息可以查阅：http://npm.taobao.org/。
-
-
-使用 create-react-app 快速构建 React 开发环境
-create-react-app 是来自于 Facebook，通过该命令我们无需配置就能快速构建 React 开发环境。
-create-react-app 自动创建的项目是基于 Webpack + ES6 。
-执行以下命令创建项目：
-$ cnpm install -g create-react-app
-$ create-react-app my-app
-$ cd my-app/
-$ npm start
-
-项目的目录结构如下：
-my-app/
-  README.md
-  node_modules/
-  package.json
-  .gitignore
-  public/
-    favicon.ico
-    index.html
-  src/
-    App.css
-    App.js
-    App.test.js
-    index.css
-    index.js
+React 可以直接下载使用，下载包中也提供了很多学习的实例。
+
+本教程使用了 React 的版本为 15.4.2，你可以在官网 http://facebook.github.io/react/ 下载最新版。
+
+你也可以直接使用 BootCDN 的 React CDN 库，地址如下：
+
+<script src="https://cdn.bootcss.com/react/15.4.2/react.min.js"></script>
+<script src="https://cdn.bootcss.com/react/15.4.2/react-dom.min.js"></script>
+<script src="https://cdn.bootcss.com/babel-standalone/6.22.1/babel.min.js"></script>
+
+react.min.js - React 的核心库
+react-dom.min.js - 提供与 DOM 相关的功能
+babel.min.js - Babel 可以将 ES6 代码转为 ES5 代码，这样我们就能在目前不支持 ES6 浏览器上执行 React 代码。
+			   Babel 内嵌了对 JSX 的支持。通过将 Babel 和 babel-sublime 包（package）一同使用可以让源码的语法渲染上升到一个全新的水平。
+			   
+
+通过 npm 使用 React
+我们建议在 React 中使用 CommonJS 模块系统，比如 browserify 或 webpack，本教程使用 webpack。
+国内使用 npm 速度很慢，你可以使用淘宝定制的 cnpm (gzip 压缩支持) 命令行工具代替默认的 npm:
+$ npm install -g cnpm --registry=https://registry.npm.taobao.org
+$ npm config set registry https://registry.npm.taobao.org
+这样就可以使用 cnpm 命令来安装模块了：
+$ cnpm install [name]
+更多信息可以查阅：http://npm.taobao.org/。
+
+
+使用 create-react-app 快速构建 React 开发环境
+create-react-app 是来自于 Facebook，通过该命令我们无需配置就能快速构建 React 开发环境。
+create-react-app 自动创建的项目是基于 Webpack + ES6 。
+执行以下命令创建项目：
+$ cnpm install -g create-react-app
+$ create-react-app my-app
+$ cd my-app/
+$ npm start
+
+项目的目录结构如下：
+my-app/
+  README.md
+  node_modules/
+  package.json
+  .gitignore
+  public/
+    favicon.ico
+    index.html
+  src/
+    App.css
+    App.js
+    App.test.js
+    index.css
+    index.js
     logo.svg
\ No newline at end of file
diff --git a/14 - Front-end/react/03 React JSX.txt "b/14 - Front-end \345\211\215\347\253\257/react/03 React JSX.txt"
similarity index 98%
rename from 14 - Front-end/react/03 React JSX.txt
rename to "14 - Front-end \345\211\215\347\253\257/react/03 React JSX.txt"
index cb9de682..14a546b1 100644
--- a/14 - Front-end/react/03 React JSX.txt	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/03 React JSX.txt"	
@@ -1,7 +1,7 @@
-React 使用 JSX 来替代常规的 JavaScript。
-JSX 是一个看起来很像 XML 的 JavaScript 语法扩展。
-我们不需要一定使用 JSX，但它有以下优点：
-JSX 执行更快，因为它在编译为 JavaScript 代码后进行了优化。
-它是类型安全的，在编译过程中就能发现错误。
-使用 JSX 编写模板更加简单快速。
-
+React 使用 JSX 来替代常规的 JavaScript。
+JSX 是一个看起来很像 XML 的 JavaScript 语法扩展。
+我们不需要一定使用 JSX，但它有以下优点：
+JSX 执行更快，因为它在编译为 JavaScript 代码后进行了优化。
+它是类型安全的，在编译过程中就能发现错误。
+使用 JSX 编写模板更加简单快速。
+
diff --git "a/14 - Front-end/react/04 React \347\273\204\344\273\266.txt" "b/14 - Front-end \345\211\215\347\253\257/react/04 React \347\273\204\344\273\266.txt"
similarity index 96%
rename from "14 - Front-end/react/04 React \347\273\204\344\273\266.txt"
rename to "14 - Front-end \345\211\215\347\253\257/react/04 React \347\273\204\344\273\266.txt"
index 08583399..f1fdb518 100644
--- "a/14 - Front-end/react/04 React \347\273\204\344\273\266.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/04 React \347\273\204\344\273\266.txt"	
@@ -1,26 +1,26 @@
-本章节我们将讨论如何使用组件使得我们的应用更容易来管理。
-
-接下来我们封装一个输出 "Hello World！" 的组件，组件名为 HelloMessage：
-
-React 实例
-var HelloMessage = React.createClass({
-  render: function() {
-    return <h1>Hello World！</h1>;
-  }
-});
- 
-ReactDOM.render(
-  <HelloMessage />,
-  document.getElementById('example')
-);
-
-实例解析：
-React.createClass 方法用于生成一个组件类 HelloMessage。
-
-<HelloMessage /> 实例组件类并输出信息。
-
-注意，原生 HTML 元素名以小写字母开头，
-而自定义的 React 类名以大写字母开头，
-比如 HelloMessage 不能写成 helloMessage。
-除此之外还需要注意组件类只能包含一个顶层标签，否则也会报错。
-
+本章节我们将讨论如何使用组件使得我们的应用更容易来管理。
+
+接下来我们封装一个输出 "Hello World！" 的组件，组件名为 HelloMessage：
+
+React 实例
+var HelloMessage = React.createClass({
+  render: function() {
+    return <h1>Hello World！</h1>;
+  }
+});
+ 
+ReactDOM.render(
+  <HelloMessage />,
+  document.getElementById('example')
+);
+
+实例解析：
+React.createClass 方法用于生成一个组件类 HelloMessage。
+
+<HelloMessage /> 实例组件类并输出信息。
+
+注意，原生 HTML 元素名以小写字母开头，
+而自定义的 React 类名以大写字母开头，
+比如 HelloMessage 不能写成 helloMessage。
+除此之外还需要注意组件类只能包含一个顶层标签，否则也会报错。
+
diff --git "a/14 - Front-end/react/05 React State(\347\212\266\346\200\201).txt" "b/14 - Front-end \345\211\215\347\253\257/react/05 React State(\347\212\266\346\200\201).txt"
similarity index 97%
rename from "14 - Front-end/react/05 React State(\347\212\266\346\200\201).txt"
rename to "14 - Front-end \345\211\215\347\253\257/react/05 React State(\347\212\266\346\200\201).txt"
index 4e199193..40bc55f0 100644
--- "a/14 - Front-end/react/05 React State(\347\212\266\346\200\201).txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/05 React State(\347\212\266\346\200\201).txt"	
@@ -1,33 +1,33 @@
-React 把组件看成是一个状态机（State Machines）。通过与用户的交互，实现不同状态，然后渲染 UI，让用户界面和数据保持一致。
-
-React 里，只需更新组件的 state，然后根据新的 state 重新渲染用户界面（不要操作 DOM）。
-
-以下实例中创建了 LikeButton 组件， getInitialState 方法用于定义初始状态，也就是一个对象，这个对象可以通过 this.state 属性读取。
-当用户点击组件，导致状态变化，this.setState 方法就修改状态值，每次修改以后，自动调用 this.render 方法，再次渲染组件。
-
-	var LikeButton = React.createClass({
-        getInitialState: function() {
-          return {liked: false};
-        },
-        handleClick: function(event) {
-          this.setState({liked: !this.state.liked});
-        },
-        render: function() {
-          var text = this.state.liked ? '喜欢' : '不喜欢';
-          return (
-            <p onClick={this.handleClick}>
-              你<b>{text}</b>我。点我切换状态。
-            </p>
-          );
-        }
-    });
-
-    ReactDOM.render(
-        <LikeButton />,
-        document.getElementById('example')
-    );
-	
-
-	onClick 等事件，与原生 HTML 不同，on 之后第一个字母是大写的！
-
+React 把组件看成是一个状态机（State Machines）。通过与用户的交互，实现不同状态，然后渲染 UI，让用户界面和数据保持一致。
+
+React 里，只需更新组件的 state，然后根据新的 state 重新渲染用户界面（不要操作 DOM）。
+
+以下实例中创建了 LikeButton 组件， getInitialState 方法用于定义初始状态，也就是一个对象，这个对象可以通过 this.state 属性读取。
+当用户点击组件，导致状态变化，this.setState 方法就修改状态值，每次修改以后，自动调用 this.render 方法，再次渲染组件。
+
+	var LikeButton = React.createClass({
+        getInitialState: function() {
+          return {liked: false};
+        },
+        handleClick: function(event) {
+          this.setState({liked: !this.state.liked});
+        },
+        render: function() {
+          var text = this.state.liked ? '喜欢' : '不喜欢';
+          return (
+            <p onClick={this.handleClick}>
+              你<b>{text}</b>我。点我切换状态。
+            </p>
+          );
+        }
+    });
+
+    ReactDOM.render(
+        <LikeButton />,
+        document.getElementById('example')
+    );
+	
+
+	onClick 等事件，与原生 HTML 不同，on 之后第一个字母是大写的！
+
 	比如本章实例中，如果将 onClick={this.handleClick} 换成 onclick={this.handleClick} 则点击事件不再生效。
\ No newline at end of file
diff --git a/14 - Front-end/react/06 React Props.txt "b/14 - Front-end \345\211\215\347\253\257/react/06 React Props.txt"
similarity index 97%
rename from 14 - Front-end/react/06 React Props.txt
rename to "14 - Front-end \345\211\215\347\253\257/react/06 React Props.txt"
index 8f347f0e..62f992a5 100644
--- a/14 - Front-end/react/06 React Props.txt	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/06 React Props.txt"	
@@ -1,48 +1,48 @@
-state 和 props 主要的区别在于 props 是不可变的，而 state 可以根据与用户交互来改变。
-这就是为什么有些容器组件需要定义 state 来更新和修改数据。 而子组件只能通过 props 来传递数据。
-
-使用 Props
-以下实例演示了如何在组件中使用 props：
-
-      var HelloMessage = React.createClass({
-        render: function() {
-          return <h1>Hello {this.props.name}</h1>;
-        }
-      });
-
-      ReactDOM.render(
-        <HelloMessage name="Runoob" />,
-        document.getElementById('example')
-      );
-	  
-	  实例中 name 属性通过 this.props.name 来获取。
-	  
-默认 Props
-你可以通过 getDefaultProps() 方法为 props 设置默认值，实例如下：
-
-      var HelloMessage = React.createClass({
-      getDefaultProps: function() {
-        return {
-          name: 'Runoob'
-        };
-      },
-      render: function() {
-        return <h1>Hello {this.props.name}</h1>;
-      }
-    });
-
-    ReactDOM.render(
-      <HelloMessage />,
-      document.getElementById('example')
-    );
-	
-State 和 Props
-以下实例演示了如何在应用中组合使用 state 和 props 。我们可以在父组件中设置 state， 并通过在子组件上使用 props 将其传递到子组件上。
-在 render 函数中, 我们设置 name 和 site 来获取父组件传递过来的数据。
-
-
-Props 验证
-Props 验证使用 propTypes，它可以保证我们的应用组件被正确使用，React.PropTypes 提供很多验证器 (validator) 来验证传入数据是否有效。
-当向 props 传入无效数据时，JavaScript 控制台会抛出警告。
-
+state 和 props 主要的区别在于 props 是不可变的，而 state 可以根据与用户交互来改变。
+这就是为什么有些容器组件需要定义 state 来更新和修改数据。 而子组件只能通过 props 来传递数据。
+
+使用 Props
+以下实例演示了如何在组件中使用 props：
+
+      var HelloMessage = React.createClass({
+        render: function() {
+          return <h1>Hello {this.props.name}</h1>;
+        }
+      });
+
+      ReactDOM.render(
+        <HelloMessage name="Runoob" />,
+        document.getElementById('example')
+      );
+	  
+	  实例中 name 属性通过 this.props.name 来获取。
+	  
+默认 Props
+你可以通过 getDefaultProps() 方法为 props 设置默认值，实例如下：
+
+      var HelloMessage = React.createClass({
+      getDefaultProps: function() {
+        return {
+          name: 'Runoob'
+        };
+      },
+      render: function() {
+        return <h1>Hello {this.props.name}</h1>;
+      }
+    });
+
+    ReactDOM.render(
+      <HelloMessage />,
+      document.getElementById('example')
+    );
+	
+State 和 Props
+以下实例演示了如何在应用中组合使用 state 和 props 。我们可以在父组件中设置 state， 并通过在子组件上使用 props 将其传递到子组件上。
+在 render 函数中, 我们设置 name 和 site 来获取父组件传递过来的数据。
+
+
+Props 验证
+Props 验证使用 propTypes，它可以保证我们的应用组件被正确使用，React.PropTypes 提供很多验证器 (validator) 来验证传入数据是否有效。
+当向 props 传入无效数据时，JavaScript 控制台会抛出警告。
+
 以下实例创建一个 Mytitle 组件，属性 title 是必须的且是字符串，非字符串类型会自动转换为字符串 ：
\ No newline at end of file
diff --git "a/14 - Front-end/react/07 React \347\273\204\344\273\266 API.txt" "b/14 - Front-end \345\211\215\347\253\257/react/07 React \347\273\204\344\273\266 API.txt"
similarity index 98%
rename from "14 - Front-end/react/07 React \347\273\204\344\273\266 API.txt"
rename to "14 - Front-end \345\211\215\347\253\257/react/07 React \347\273\204\344\273\266 API.txt"
index 21c2f370..81ff63d1 100644
--- "a/14 - Front-end/react/07 React \347\273\204\344\273\266 API.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/react/07 React \347\273\204\344\273\266 API.txt"	
@@ -1,25 +1,25 @@
-http://www.runoob.com/react/react-component-api.html
-在本章节中我们将讨论 React 组件 API。我们将讲解以下7个方法:
-
-设置状态：setState
-替换状态：replaceState
-设置属性：setProps
-替换属性：replaceProps
-强制更新：forceUpdate
-获取DOM节点：findDOMNode
-判断组件挂载状态：isMounted
-
-
-设置状态:setState
-setState(object nextState[, function callback])
-参数说明
-nextState，将要设置的新状态，该状态会和当前的state合并
-callback，可选参数，回调函数。该函数会在setState设置成功，且组件重新渲染后调用。
-合并nextState和当前state，并重新渲染组件。setState是React事件处理函数中和请求回调函数中触发UI更新的主要方法。
-
-关于setState
-不能在组件内部通过this.state修改状态，因为该状态会在调用setState()后被替换。
-
-setState()并不会立即改变this.state，而是创建一个即将处理的state。setState()并不一定是同步的，为了提升性能React会批量执行state和DOM渲染。
-
+http://www.runoob.com/react/react-component-api.html
+在本章节中我们将讨论 React 组件 API。我们将讲解以下7个方法:
+
+设置状态：setState
+替换状态：replaceState
+设置属性：setProps
+替换属性：replaceProps
+强制更新：forceUpdate
+获取DOM节点：findDOMNode
+判断组件挂载状态：isMounted
+
+
+设置状态:setState
+setState(object nextState[, function callback])
+参数说明
+nextState，将要设置的新状态，该状态会和当前的state合并
+callback，可选参数，回调函数。该函数会在setState设置成功，且组件重新渲染后调用。
+合并nextState和当前state，并重新渲染组件。setState是React事件处理函数中和请求回调函数中触发UI更新的主要方法。
+
+关于setState
+不能在组件内部通过this.state修改状态，因为该状态会在调用setState()后被替换。
+
+setState()并不会立即改变this.state，而是创建一个即将处理的state。setState()并不一定是同步的，为了提升性能React会批量执行state和DOM渲染。
+
 setState()总是会触发一次组件重绘，除非在shouldComponentUpdate()中实现了一些条件渲染逻辑。
\ No newline at end of file
diff --git a/17 - Scripting language/lua.txt "b/14 - Front-end \345\211\215\347\253\257/react/08 React \347\273\204\344\273\266\347\224\237\345\221\275\345\221\250\346\234\237.txt"
similarity index 100%
rename from 17 - Scripting language/lua.txt
rename to "14 - Front-end \345\211\215\347\253\257/react/08 React \347\273\204\344\273\266\347\224\237\345\221\275\345\221\250\346\234\237.txt"
diff --git "a/14 - Front-end/vue/01 \350\265\267\346\255\245.md" "b/14 - Front-end \345\211\215\347\253\257/vue/01 \350\265\267\346\255\245.md"
similarity index 94%
rename from "14 - Front-end/vue/01 \350\265\267\346\255\245.md"
rename to "14 - Front-end \345\211\215\347\253\257/vue/01 \350\265\267\346\255\245.md"
index 165bf114..c30cbe5e 100644
--- "a/14 - Front-end/vue/01 \350\265\267\346\255\245.md"	
+++ "b/14 - Front-end \345\211\215\347\253\257/vue/01 \350\265\267\346\255\245.md"	
@@ -1,51 +1,51 @@
-``` html
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="utf-8">
-<title>Vue 测试实例 - 菜鸟教程(runoob.com)</title>
-<script src="https://cdn.bootcss.com/vue/2.4.2/vue.min.js"></script>
-</head>
-<body>
-<div id="app">
-  <p>{{ message }}</p>
-</div>
-
-<script>
-new Vue({
-  el: '#app',
-  data: {
-    message: 'Hello Vue.js!'
-  }
-})
-</script>
-</body>
-</html>
-```
-
-安装 我们可以在 Vue.js 的官网上直接下载 vue.min.js 并用 <script> 标签引入。
-
-
-
-以下推荐国外比较稳定的两个 CDN，国内还没发现哪一家比较好，目前还是建议下载到本地。
-
-BootCDN（国内） : https://cdn.bootcss.com/vue/2.2.2/vue.min.js
-
-unpkg：https://unpkg.com/vue/dist/vue.js, 会保持和 npm 发布的最新的版本一致。
-
-cdnjs : https://cdnjs.cloudflare.com/ajax/libs/vue/2.1.8/vue.min.js
-
-
-NPM 方法
-
-```
-# 查看版本
-$ npm -v
-2.3.0
-#升级 npm
-cnpm install npm -g
-# 最新稳定版
-$ cnpm install vue
-```
-
-Vue.js 目录结构
+``` html
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Vue 测试实例 - 菜鸟教程(runoob.com)</title>
+<script src="https://cdn.bootcss.com/vue/2.4.2/vue.min.js"></script>
+</head>
+<body>
+<div id="app">
+  <p>{{ message }}</p>
+</div>
+
+<script>
+new Vue({
+  el: '#app',
+  data: {
+    message: 'Hello Vue.js!'
+  }
+})
+</script>
+</body>
+</html>
+```
+
+安装 我们可以在 Vue.js 的官网上直接下载 vue.min.js 并用 <script> 标签引入。
+
+
+
+以下推荐国外比较稳定的两个 CDN，国内还没发现哪一家比较好，目前还是建议下载到本地。
+
+BootCDN（国内） : https://cdn.bootcss.com/vue/2.2.2/vue.min.js
+
+unpkg：https://unpkg.com/vue/dist/vue.js, 会保持和 npm 发布的最新的版本一致。
+
+cdnjs : https://cdnjs.cloudflare.com/ajax/libs/vue/2.1.8/vue.min.js
+
+
+NPM 方法
+
+```
+# 查看版本
+$ npm -v
+2.3.0
+#升级 npm
+cnpm install npm -g
+# 最新稳定版
+$ cnpm install vue
+```
+
+Vue.js 目录结构
diff --git "a/14 - Front-end/\346\267\261\345\205\245\347\220\206\350\247\243 CSS\357\274\232\345\255\227\344\275\223\345\272\246\351\207\217\343\200\201line-height \345\222\214 vertical-align.txt" "b/14 - Front-end \345\211\215\347\253\257/\346\267\261\345\205\245\347\220\206\350\247\243 CSS\357\274\232\345\255\227\344\275\223\345\272\246\351\207\217\343\200\201line-height \345\222\214 vertical-align.txt"
similarity index 96%
rename from "14 - Front-end/\346\267\261\345\205\245\347\220\206\350\247\243 CSS\357\274\232\345\255\227\344\275\223\345\272\246\351\207\217\343\200\201line-height \345\222\214 vertical-align.txt"
rename to "14 - Front-end \345\211\215\347\253\257/\346\267\261\345\205\245\347\220\206\350\247\243 CSS\357\274\232\345\255\227\344\275\223\345\272\246\351\207\217\343\200\201line-height \345\222\214 vertical-align.txt"
index 48b049bf..ee1b6efb 100644
--- "a/14 - Front-end/\346\267\261\345\205\245\347\220\206\350\247\243 CSS\357\274\232\345\255\227\344\275\223\345\272\246\351\207\217\343\200\201line-height \345\222\214 vertical-align.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/\346\267\261\345\205\245\347\220\206\350\247\243 CSS\357\274\232\345\255\227\344\275\223\345\272\246\351\207\217\343\200\201line-height \345\222\214 vertical-align.txt"	
@@ -1,5 +1,5 @@
-深入理解 CSS：字体度量、line-height 和 vertical-align
-
-
-
+深入理解 CSS：字体度量、line-height 和 vertical-align
+
+
+
 vertical-align 有效控制行高
\ No newline at end of file
diff --git "a/14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Desktop.lnk" "b/14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Desktop.lnk"
similarity index 100%
rename from "14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Desktop.lnk"
rename to "14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Desktop.lnk"
diff --git "a/14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Thymeleaf.txt" "b/14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Thymeleaf.txt"
similarity index 99%
rename from "14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Thymeleaf.txt"
rename to "14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Thymeleaf.txt"
index 066765d9..c025b815 100644
--- "a/14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Thymeleaf.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/Thymeleaf.txt"	
@@ -1,8 +1,8 @@
-一.Thymeleaf简介
-简单说， Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。相较与其他的模板引擎，它有如下三个极吸引人的特点：
-
-    1.Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。
-
-    2.Thymeleaf 开箱即用的特性。它提供标准和spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果，避免每天套模板、改jstl、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。
-
+一.Thymeleaf简介
+简单说， Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。相较与其他的模板引擎，它有如下三个极吸引人的特点：
+
+    1.Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。
+
+    2.Thymeleaf 开箱即用的特性。它提供标准和spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果，避免每天套模板、改jstl、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。
+
     3. Thymeleaf 提供spring标准方言和一个与 SpringMVC 完美集成的可选模块，可以快速的实现表单绑定、属性编辑器、国际化等功能。
\ No newline at end of file
diff --git "a/14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/\346\265\205\350\260\210jsp\343\200\201freemarker\343\200\201velocity\345\214\272\345\210\253.txt" "b/14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/\346\265\205\350\260\210jsp\343\200\201freemarker\343\200\201velocity\345\214\272\345\210\253.txt"
similarity index 97%
rename from "14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/\346\265\205\350\260\210jsp\343\200\201freemarker\343\200\201velocity\345\214\272\345\210\253.txt"
rename to "14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/\346\265\205\350\260\210jsp\343\200\201freemarker\343\200\201velocity\345\214\272\345\210\253.txt"
index eb1b56a5..feb43e23 100644
--- "a/14 - Front-end/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/\346\265\205\350\260\210jsp\343\200\201freemarker\343\200\201velocity\345\214\272\345\210\253.txt"	
+++ "b/14 - Front-end \345\211\215\347\253\257/\351\241\265\351\235\242 view\350\247\206\345\233\276\345\261\202/\346\265\205\350\260\210jsp\343\200\201freemarker\343\200\201velocity\345\214\272\345\210\253.txt"	
@@ -1,49 +1,49 @@
-
-http://blog.csdn.net/tjcyjd/article/details/16803877
-
-以前做web开发页面层用的基本就是就是，最近公司java项目页面层用的技术是velocity。听说jsp要淘汰，也不知道是真是假，但本人还是比较喜欢jsp的，下面是网上查找的javaweb项目页面3种技术的区别。
-
-在java领域，表现层技术主要有三种：jsp、freemarker（.ftl）、velocity（.vm）。
-
-
-jsp是大家最熟悉的技术
-优点：
-1、功能强大，可以写java代码
-2、支持jsp标签（jsp tag）
-3、支持表达式语言（el）
-4、官方标准，用户群广，丰富的第三方jsp标签库
-5、性能良好。jsp编译成class文件执行，有很好的性能表现
-缺点：
-jsp没有明显缺点，非要挑点骨头那就是，由于可以编写java代码，如使用不当容易破坏mvc结构。
-
-
-velocity是较早出现的用于代替jsp的模板语言
-优点：
-1、不能编写java代码，可以实现严格的mvc分离
-2、性能良好，据说比jsp性能还要好些
-3、使用表达式语言，据说jsp的表达式语言就是学velocity的
-缺点：
-1、不是官方标准
-2、用户群体和第三方标签库没有jsp多。
-3、对jsp标签支持不够好
-
-
-freemarker
-优点：
-1、不能编写java代码，可以实现严格的mvc分离
-2、性能非常不错
-3、对jsp标签支持良好
-4、内置大量常用功能，使用非常方便
-5、宏定义（类似jsp标签）非常方便
-6、使用表达式语言
-缺点：
-1、不是官方标准
-2、用户群体和第三方标签库没有jsp多
-
-
-选择freemarker的原因：
-1、性能。velocity应该是最好的，其次是jsp，普通的页面freemarker性能最差（虽然只是几毫秒到十几毫秒的差距）。但是在复杂页面上（包含大量判断、日期金额格式化）的页面上，freemarker的性能比使用tag和el的jsp好。
-2、宏定义比jsp tag方便
-3、内置大量常用功能。比如html过滤，日期金额格式化等等，使用非常方便
-4、支持jsp标签
+
+http://blog.csdn.net/tjcyjd/article/details/16803877
+
+以前做web开发页面层用的基本就是就是，最近公司java项目页面层用的技术是velocity。听说jsp要淘汰，也不知道是真是假，但本人还是比较喜欢jsp的，下面是网上查找的javaweb项目页面3种技术的区别。
+
+在java领域，表现层技术主要有三种：jsp、freemarker（.ftl）、velocity（.vm）。
+
+
+jsp是大家最熟悉的技术
+优点：
+1、功能强大，可以写java代码
+2、支持jsp标签（jsp tag）
+3、支持表达式语言（el）
+4、官方标准，用户群广，丰富的第三方jsp标签库
+5、性能良好。jsp编译成class文件执行，有很好的性能表现
+缺点：
+jsp没有明显缺点，非要挑点骨头那就是，由于可以编写java代码，如使用不当容易破坏mvc结构。
+
+
+velocity是较早出现的用于代替jsp的模板语言
+优点：
+1、不能编写java代码，可以实现严格的mvc分离
+2、性能良好，据说比jsp性能还要好些
+3、使用表达式语言，据说jsp的表达式语言就是学velocity的
+缺点：
+1、不是官方标准
+2、用户群体和第三方标签库没有jsp多。
+3、对jsp标签支持不够好
+
+
+freemarker
+优点：
+1、不能编写java代码，可以实现严格的mvc分离
+2、性能非常不错
+3、对jsp标签支持良好
+4、内置大量常用功能，使用非常方便
+5、宏定义（类似jsp标签）非常方便
+6、使用表达式语言
+缺点：
+1、不是官方标准
+2、用户群体和第三方标签库没有jsp多
+
+
+选择freemarker的原因：
+1、性能。velocity应该是最好的，其次是jsp，普通的页面freemarker性能最差（虽然只是几毫秒到十几毫秒的差距）。但是在复杂页面上（包含大量判断、日期金额格式化）的页面上，freemarker的性能比使用tag和el的jsp好。
+2、宏定义比jsp tag方便
+3、内置大量常用功能。比如html过滤，日期金额格式化等等，使用非常方便
+4、支持jsp标签
 5、可以实现严格的mvc分离
\ No newline at end of file
diff --git a/15 - Distributed/img/xl1.png "b/15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl1.png"
similarity index 100%
rename from 15 - Distributed/img/xl1.png
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl1.png"
diff --git a/15 - Distributed/img/xl2.png "b/15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl2.png"
similarity index 100%
rename from 15 - Distributed/img/xl2.png
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl2.png"
diff --git a/15 - Distributed/img/xl3.png "b/15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl3.png"
similarity index 100%
rename from 15 - Distributed/img/xl3.png
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl3.png"
diff --git a/15 - Distributed/img/xl4.png "b/15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl4.png"
similarity index 100%
rename from 15 - Distributed/img/xl4.png
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/img/xl4.png"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217 \346\234\215\345\212\241\345\214\226.txt" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217 \346\234\215\345\212\241\345\214\226.txt"
similarity index 97%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217 \346\234\215\345\212\241\345\214\226.txt"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217 \346\234\215\345\212\241\345\214\226.txt"
index 5cbfd361..23af3535 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217 \346\234\215\345\212\241\345\214\226.txt"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217 \346\234\215\345\212\241\345\214\226.txt"	
@@ -1,13 +1,13 @@
-分拆一个大系统，做成一个个小系统。然后通过系统接口让这些小系统相互通信。
-这样来组成一个大系统，具体来说就是“分布式”、“服务化”的互联网思维。
-
-让系统在架构设计上就是一个先天支持高度可扩展的系统。
-
-
-这些子系统可以单独设计开发，对外暴露出各种其他子系统需求的数据接口即可。
-
-
-分布式：一个业务分拆多个子业务，部署在不同的服务器上
-集群：同一个业务，部署在多个服务器上
-
+分拆一个大系统，做成一个个小系统。然后通过系统接口让这些小系统相互通信。
+这样来组成一个大系统，具体来说就是“分布式”、“服务化”的互联网思维。
+
+让系统在架构设计上就是一个先天支持高度可扩展的系统。
+
+
+这些子系统可以单独设计开发，对外暴露出各种其他子系统需求的数据接口即可。
+
+
+分布式：一个业务分拆多个子业务，部署在不同的服务器上
+集群：同一个业务，部署在多个服务器上
+
 	
\ No newline at end of file
diff --git "a/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
new file mode 100644
index 00000000..efdb2c30
--- /dev/null
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"	
@@ -0,0 +1,21 @@
+https://mp.weixin.qq.com/s/LmKqrK9jyi_MFIvFoHsg2Q
+分布式事物常见的5种解决方案
+
+### 分布式事务的产生的原因
+1、数据库分库分表
+由于单表的数据量巨大导致的分库分表，则会涉及到多个数据库的一致性问题。
+
+2、应用SOA化
+业务的服务化。多个业务中心有各自的数据库，也会涉及多个数据库的一致性问题
+
+### 分布式事务的 5 种方案
+
+1、XA 方案：即“全票通过方案”，要求所有的事务系统必须全部准备好，才可以进行事务处理，这种方案其实是将事务问题抛给了各个数据库本身，好处是数据一致性很高，缺点是耗费性能，所以这种方案一般用的不多。
+
+2、TCC 方案：即“局部通过方案”，要求部分事务系统准备好处理事务即可，相对比XA方案灵活了许多，同时它的处理方式是将事务问题交给系统本身处理，需要用大量的代码控制，优点是数据一致性也很高，缺点是控制事务的逻辑代码复杂冗余，性能也很差。所以这种方案也不常用。
+
+3、本地消息表：这是一种基于数据库：这种方案是基于数据库表的一种方案，由各个系统分建自己的消息表，记录数据的发起及接收，并给数据做状态标记，借助MQ，观察消息的状态来决定事务是否需要回滚。有点是代码量少，数据可以保持最终一致性，缺点是表需要维护，且对高并发的支持不怎么好。
+
+4、可靠消息最终一致性方案：这是一种目前市面上比较常用的方案，其原理与上述方法类似，也需要借助MQ，只是不再借助数据库的消息表，而是由系统发起一条预发送消息，当系统本身的事务执行完毕后再将MQ中的消息变为确认消息，同样其他系统接收到MQ的消息后开始处理本地事务，根据处理情况决定事务是否需要回滚。相对来说优点是事务控制较为灵活，确定是不稳定因素较多。
+
+5、最大努力通知方案：这种方案目前还不太成熟，用的也不多，其原理与上述方案类似，只是预发送消息也没有了，有系统处理完本地事务后直接发起MQ，而接受方是本地的一套专门处理事务的服务，此服务调用待接收系统的接口，以此处理事务。优点是事务节点较少，缺点是事务处理服务的维护成本较高，同时需要多个系统的接口才行。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc1.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc1.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc1.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc1.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc2.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc2.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc2.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc2.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc3.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc3.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc3.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc3.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc4.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc4.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc4.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc4.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc5.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc5.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc5.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/2pc5.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/3pc.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/3pc.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/3pc.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/3pc.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap1.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap1.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap1.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap1.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap2.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap2.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap2.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap2.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap3.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap3.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap3.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/cap3.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos1.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos1.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos1.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos1.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos10.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos10.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos10.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos10.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos2.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos2.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos2.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos2.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos3.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos3.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos3.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos3.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos4.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos4.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos4.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos4.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos5.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos5.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos5.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos5.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos6.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos6.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos6.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos6.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos7.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos7.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos7.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos7.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos8.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos8.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos8.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos8.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos9.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos9.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos9.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/paxos9.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft1.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft1.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft1.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft1.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft10.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft10.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft10.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft10.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft11.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft11.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft11.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft11.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft2.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft2.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft2.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft2.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft3.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft3.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft3.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft3.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft4.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft4.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft4.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft4.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft5.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft5.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft5.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft5.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft6.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft6.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft6.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft6.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft7.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft7.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft7.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft7.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft8.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft8.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft8.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft8.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft9.jpg" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft9.jpg"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft9.jpg"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/img/raft9.jpg"
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 1 - CAP\345\256\232\347\220\206.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 1 - CAP\345\256\232\347\220\206.md"
similarity index 98%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 1 - CAP\345\256\232\347\220\206.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 1 - CAP\345\256\232\347\220\206.md"
index 1a2b6c22..42d1b4f0 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 1 - CAP\345\256\232\347\220\206.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 1 - CAP\345\256\232\347\220\206.md"	
@@ -1,77 +1,77 @@
-https://juejin.im/post/5b26634b6fb9a00e765e75d1
-
-### 前言
-CAP原则又称CAP定理，指的是在一个分布式系统中，`Consistency（一致性）`、 `Availability（可用性）`、`Partition tolerance（分区容错性）`这三个基本需求，最多只能同时满足其中的2个。
-
-### 1. CAP原则简介
-
-**Consistency（一致性）**
-指数据在多个副本之间能够保持一致的特性（严格的一致性）
-
-**Availability（可用性）**
-指系统提供的服务必须一直处于可用的状态，每次请求都能获取到非错的响应（不保证获取的数据为最新数据）
-
-**Partition tolerance（分区容错性）**
-分布式系统在遇到任何网络分区故障的时候，仍然能够对外提供满足一致性和可用性的服务，除非整个网络环境都发生了故障
-
-**什么是分区？**
-
-在分布式系统中，不同的节点分布在不同的子网络中，由于一些特殊的原因，这些子节点之间出现了网络不通的状态，但他们的内部子网络是正常的。从而导致了整个系统的环境被切分成了若干个孤立的区域，这就是分区。
-
-### 2. CAP原则论证
-
-如图所示，是我们证明CAP的基本场景，网络中有两个节点N1和N2，可以简单的理解N1和N2分别是两台计算机，他们之间网络可以连通，N1中有一个应用程序A，和一个数据库V，N2也有一个应用程序B和一个数据库V。现在，A和B是分布式系统的两个部分，V是分布式系统的数据存储的两个子数据库。
-
-<div align="center"> <img src="img/cap1.jpg" > </div>
-
-* 在满足一致性的时候，N1和N2中的数据是一样的，V0=V0。
-* 在满足可用性的时候，用户不管是请求N1或者N2，都会得到立即响应。
-* 在满足分区容错性的情况下，N1和N2有任何一方宕机，或者网络不通的时候，都不会影响N1和N2彼此之间的正常运作。
-
-如图所示，这是分布式系统正常运转的流程，用户向N1机器请求数据更新，程序A更新数据库V0为V1。分布式系统将数据进行同步操作M，将V1同步的N2中V0，使得N2中的数据V0也更新为V1，N2中的数据再响应N2的请求。
-
-<div align="center"> <img src="img/cap2.jpg" > </div>
-
-根据CAP原则定义，系统的一致性、可用性和分区容错性细分如下：
-
-* 一致性：N1和N2的数据库V之间的数据是否完全一样。
-* 可用性：N1和N2的对外部的请求能否做出正常的响应。
-* 分区容错性：N1和N2之间的网络是否互通。
-
-这是正常运作的场景，也是理想的场景。作为一个分布式系统，它和单机系统的最大区别，就在于网络。现在假设一种极端情况，N1和N2之间的网络断开了，我们要支持这种网络异常。相当于要满足分区容错性，能不能同时满足一致性和可用性呢？还是说要对他们进行取舍？
-
-<div align="center"> <img src="img/cap3.jpg" > </div>
-
-假设在N1和N2之间网络断开的时候，有用户向N1发送数据更新请求，那N1中的数据V0将被更新为V1。由于网络是断开的，所以分布式系统同步操作M，所以N2中的数据依旧是V0。这个时候，有用户向N2发送数据读取请求，由于数据还没有进行同步，应用程序没办法立即给用户返回最新的数据V1，怎么办呢？
-这里有两种选择：
-
-* 第一：牺牲数据一致性，保证可用性。响应旧的数据V0给用户。
-* 第二：牺牲可用性，保证数据一致性。阻塞等待，直到网络连接恢复，数据更新操作M完成之后，再给用户响应最新的数据V1。
-
-这个过程，证明了要满足分区容错性的分布式系统，只能在一致性和可用性两者中，选择其中一个。
-
-### 3. CAP原则权衡
-
-通过CAP理论，我们知道无法同时满足一致性、可用性和分区容错性这三个特性，那要舍弃哪个呢？
-
-#### 3.1. CA without P
-
-如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但其实分区不是你想不想的问题，而是始终会存在，因此CA的系统更多的是允许分区后各子系统依然保持CA。
-
-#### 3.2. CP without A
-
-如果不要求A（可用），相当于每个请求都需要在Server之间强一致，而P（分区）会导致同步时间无限延长，如此CP也是可以保证的。**很多传统的数据库分布式事务都属于这种模式。**
-
-#### 3.3. AP wihtout C
-
-要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。**现在众多的NoSQL都属于此类。**
-
-### 小结
-
-对于多数大型互联网应用的场景，主机众多、部署分散。而且现在的集群规模越来越大，所以节点故障、网络故障是常态。这种应用一般要保证服务可用性(Availability)达到N个9，即保证P和A，**只有舍弃C（退而求其次保证最终一致性）。** 虽然某些地方会影响客户体验，但没达到造成用户流程的严重程度。
-
-对于涉及到钱财这样不能有一丝让步的场景，C必须保证。网络发生故障宁可停止服务，这是保证CA，舍弃P。貌似这几年国内银行业发生了不下10起事故，但影响面不大，报道也不多，广大群众知道的少。
-
-还有一种是保证CP，舍弃A，例如网络故障时只读不写。
-
-孰优孰劣，没有定论，只能根据场景定夺，适合的才是最好的。
+https://juejin.im/post/5b26634b6fb9a00e765e75d1
+
+### 前言
+CAP原则又称CAP定理，指的是在一个分布式系统中，`Consistency（一致性）`、 `Availability（可用性）`、`Partition tolerance（分区容错性）`这三个基本需求，最多只能同时满足其中的2个。
+
+### 1. CAP原则简介
+
+**Consistency（一致性）**
+指数据在多个副本之间能够保持一致的特性（严格的一致性）
+
+**Availability（可用性）**
+指系统提供的服务必须一直处于可用的状态，每次请求都能获取到非错的响应（不保证获取的数据为最新数据）
+
+**Partition tolerance（分区容错性）**
+分布式系统在遇到任何网络分区故障的时候，仍然能够对外提供满足一致性和可用性的服务，除非整个网络环境都发生了故障
+
+**什么是分区？**
+
+在分布式系统中，不同的节点分布在不同的子网络中，由于一些特殊的原因，这些子节点之间出现了网络不通的状态，但他们的内部子网络是正常的。从而导致了整个系统的环境被切分成了若干个孤立的区域，这就是分区。
+
+### 2. CAP原则论证
+
+如图所示，是我们证明CAP的基本场景，网络中有两个节点N1和N2，可以简单的理解N1和N2分别是两台计算机，他们之间网络可以连通，N1中有一个应用程序A，和一个数据库V，N2也有一个应用程序B和一个数据库V。现在，A和B是分布式系统的两个部分，V是分布式系统的数据存储的两个子数据库。
+
+<div align="center"> <img src="img/cap1.jpg" > </div>
+
+* 在满足一致性的时候，N1和N2中的数据是一样的，V0=V0。
+* 在满足可用性的时候，用户不管是请求N1或者N2，都会得到立即响应。
+* 在满足分区容错性的情况下，N1和N2有任何一方宕机，或者网络不通的时候，都不会影响N1和N2彼此之间的正常运作。
+
+如图所示，这是分布式系统正常运转的流程，用户向N1机器请求数据更新，程序A更新数据库V0为V1。分布式系统将数据进行同步操作M，将V1同步的N2中V0，使得N2中的数据V0也更新为V1，N2中的数据再响应N2的请求。
+
+<div align="center"> <img src="img/cap2.jpg" > </div>
+
+根据CAP原则定义，系统的一致性、可用性和分区容错性细分如下：
+
+* 一致性：N1和N2的数据库V之间的数据是否完全一样。
+* 可用性：N1和N2的对外部的请求能否做出正常的响应。
+* 分区容错性：N1和N2之间的网络是否互通。
+
+这是正常运作的场景，也是理想的场景。作为一个分布式系统，它和单机系统的最大区别，就在于网络。现在假设一种极端情况，N1和N2之间的网络断开了，我们要支持这种网络异常。相当于要满足分区容错性，能不能同时满足一致性和可用性呢？还是说要对他们进行取舍？
+
+<div align="center"> <img src="img/cap3.jpg" > </div>
+
+假设在N1和N2之间网络断开的时候，有用户向N1发送数据更新请求，那N1中的数据V0将被更新为V1。由于网络是断开的，所以分布式系统同步操作M，所以N2中的数据依旧是V0。这个时候，有用户向N2发送数据读取请求，由于数据还没有进行同步，应用程序没办法立即给用户返回最新的数据V1，怎么办呢？
+这里有两种选择：
+
+* 第一：牺牲数据一致性，保证可用性。响应旧的数据V0给用户。
+* 第二：牺牲可用性，保证数据一致性。阻塞等待，直到网络连接恢复，数据更新操作M完成之后，再给用户响应最新的数据V1。
+
+这个过程，证明了要满足分区容错性的分布式系统，只能在一致性和可用性两者中，选择其中一个。
+
+### 3. CAP原则权衡
+
+通过CAP理论，我们知道无法同时满足一致性、可用性和分区容错性这三个特性，那要舍弃哪个呢？
+
+#### 3.1. CA without P
+
+如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但其实分区不是你想不想的问题，而是始终会存在，因此CA的系统更多的是允许分区后各子系统依然保持CA。
+
+#### 3.2. CP without A
+
+如果不要求A（可用），相当于每个请求都需要在Server之间强一致，而P（分区）会导致同步时间无限延长，如此CP也是可以保证的。**很多传统的数据库分布式事务都属于这种模式。**
+
+#### 3.3. AP wihtout C
+
+要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。**现在众多的NoSQL都属于此类。**
+
+### 小结
+
+对于多数大型互联网应用的场景，主机众多、部署分散。而且现在的集群规模越来越大，所以节点故障、网络故障是常态。这种应用一般要保证服务可用性(Availability)达到N个9，即保证P和A，**只有舍弃C（退而求其次保证最终一致性）。** 虽然某些地方会影响客户体验，但没达到造成用户流程的严重程度。
+
+对于涉及到钱财这样不能有一丝让步的场景，C必须保证。网络发生故障宁可停止服务，这是保证CA，舍弃P。貌似这几年国内银行业发生了不下10起事故，但影响面不大，报道也不多，广大群众知道的少。
+
+还有一种是保证CP，舍弃A，例如网络故障时只读不写。
+
+孰优孰劣，没有定论，只能根据场景定夺，适合的才是最好的。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 2 - BASE\347\220\206\350\256\272.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 2 - BASE\347\220\206\350\256\272.md"
similarity index 98%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 2 - BASE\347\220\206\350\256\272.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 2 - BASE\347\220\206\350\256\272.md"
index 302fdab9..06a0f126 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 2 - BASE\347\220\206\350\256\272.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 2 - BASE\347\220\206\350\256\272.md"	
@@ -1,62 +1,62 @@
-https://juejin.im/post/5b2663fcf265da59a401e6f8
-### 前言
-BASE理论是由eBay架构师提出的。**BASE是对CAP中一致性和可用性权衡的结果**，其来源于对大规模互联网分布式系统实践的总结，是基于CAP定律逐步演化而来。其核心思想是即使无法做到强一致性，但每个应用都可以根据自身业务特点，才用适当的方式来使系统打到最终一致性。
-
-### 1. CAP的3选2伪命题
-实际上，不是为了P（分区容错性），必须在C（一致性）和A（可用性）之间任选其一。分区的情况很少出现，CAP在大多时间能够同时满足C和A。
-对于分区存在或者探知其影响的情况下，需要提供一种预备策略做出处理：
-
-* 探知分区的发生；
-* 进入显示的分区模式，限制某些操作；
-* 启动恢复过程，恢复数据一致性，补偿分区发生期间的错误。
-
-### 2. BASE理论简介
-
-BASE理论是 `Basically Available(基本可用)`，`Soft State（软状态）`和`Eventually Consistent（最终一致性）`三个短语的缩写。
-其核心思想是：
-
-既是无法做到强一致性（Strong consistency），但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性（Eventual consistency）。
-
-### 3. BASE理论的内容
-
-基本可用（Basically Available）
-软状态（Soft State）
-最终一致性（Eventually Consistent）
-
-下面展开讨论：
-
-#### 3.1. 基本可用
-
-什么是基本可用呢？假设系统，出现了不可预知的故障，但还是能用，相比较正常的系统而言：
-
-响应时间上的损失：正常情况下的搜索引擎0.5秒即返回给用户结果，而基本可用的搜索引擎可以在2秒作用返回结果。
-
-功能上的损失：在一个电商网站上，正常情况下，用户可以顺利完成每一笔订单。但是到了大促期间，为了保护购物系统的稳定性，部分消费者可能会被引导到一个降级页面。
-
-#### 3.2. 软状态
-
-什么是软状态呢？相对于原子性而言，要求多个节点的数据副本都是一致的，这是一种“硬状态”。
-软状态指的是：**允许系统中的数据存在中间状态，并认为该状态不影响系统的整体可用性，即允许系统在多个不同节点的数据副本存在数据延时。**
-
-#### 3.3. 最终一致性
-
-上面说软状态，然后不可能一直是软状态，必须有个时间期限。在期限过后，应当保证所有副本保持数据一致性，从而达到数据的最终一致性。
-这个时间期限取决于网络延时、系统负载、数据复制方案设计等等因素。
-而在实际工程实践中，最终一致性分为5种：
-##### 3.3.1. 因果一致性（Causal consistency）
-因果一致性指的是：如果节点A在更新完某个数据后通知了节点B，那么节点B之后对该数据的访问和修改都是基于A更新后的值。于此同时，和节点A无因果关系的节点C的数据访问则没有这样的限制。
-##### 3.3.2. 读己之所写（Read your writes）
-读己之所写指的是：节点A更新一个数据后，它自身总是能访问到自身更新过的最新值，而不会看到旧值。其实也算一种因果一致性。
-##### 3.3.3. 会话一致性（Session consistency）
-会话一致性将对系统数据的访问过程框定在了一个会话当中：系统能保证在同一个有效的会话中实现 “读己之所写” 的一致性，也就是说，执行更新操作之后，客户端能够在同一个会话中始终读取到该数据项的最新值。
-##### 3.3.4. 单调读一致性（Monotonic read consistency）
-单调读一致性指的是：如果一个节点从系统中读取出一个数据项的某个值后，那么系统对于该节点后续的任何数据访问都不应该返回更旧的值。
-##### 3.3.5. 单调写一致性（Monotonic write consistency）
-单调写一致性指的是：一个系统要能够保证来自同一个节点的写操作被顺序的执行。
-
-在实际的实践中，这5种系统往往会结合使用，以构建一个具有最终一致性的分布式系统。
-
-实际上，不只是分布式系统使用最终一致性，关系型数据库在某个功能上，也是使用最终一致性的。比如备份，数据库的复制过程是需要时间的，这个复制过程中，业务读取到的值就是旧的。当然，最终还是达成了数据一致性。这也算是一个最终一致性的经典案例。
-
-### 小结
-总体来说BASE理论面向的是大型高可用、可扩展的分布式系统。与传统ACID特性相反，不同于ACID的强一致性模型，BASE提出通过牺牲强一致性来获得可用性，并允许数据段时间内的不一致，但是最终达到一致状态。同时，在实际分布式场景中，不同业务对数据的一致性要求不一样。因此在设计中，ACID和BASE理论往往又会结合使用。
+https://juejin.im/post/5b2663fcf265da59a401e6f8
+### 前言
+BASE理论是由eBay架构师提出的。**BASE是对CAP中一致性和可用性权衡的结果**，其来源于对大规模互联网分布式系统实践的总结，是基于CAP定律逐步演化而来。其核心思想是即使无法做到强一致性，但每个应用都可以根据自身业务特点，才用适当的方式来使系统打到最终一致性。
+
+### 1. CAP的3选2伪命题
+实际上，不是为了P（分区容错性），必须在C（一致性）和A（可用性）之间任选其一。分区的情况很少出现，CAP在大多时间能够同时满足C和A。
+对于分区存在或者探知其影响的情况下，需要提供一种预备策略做出处理：
+
+* 探知分区的发生；
+* 进入显示的分区模式，限制某些操作；
+* 启动恢复过程，恢复数据一致性，补偿分区发生期间的错误。
+
+### 2. BASE理论简介
+
+BASE理论是 `Basically Available(基本可用)`，`Soft State（软状态）`和`Eventually Consistent（最终一致性）`三个短语的缩写。
+其核心思想是：
+
+既是无法做到强一致性（Strong consistency），但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性（Eventual consistency）。
+
+### 3. BASE理论的内容
+
+基本可用（Basically Available）
+软状态（Soft State）
+最终一致性（Eventually Consistent）
+
+下面展开讨论：
+
+#### 3.1. 基本可用
+
+什么是基本可用呢？假设系统，出现了不可预知的故障，但还是能用，相比较正常的系统而言：
+
+响应时间上的损失：正常情况下的搜索引擎0.5秒即返回给用户结果，而基本可用的搜索引擎可以在2秒作用返回结果。
+
+功能上的损失：在一个电商网站上，正常情况下，用户可以顺利完成每一笔订单。但是到了大促期间，为了保护购物系统的稳定性，部分消费者可能会被引导到一个降级页面。
+
+#### 3.2. 软状态
+
+什么是软状态呢？相对于原子性而言，要求多个节点的数据副本都是一致的，这是一种“硬状态”。
+软状态指的是：**允许系统中的数据存在中间状态，并认为该状态不影响系统的整体可用性，即允许系统在多个不同节点的数据副本存在数据延时。**
+
+#### 3.3. 最终一致性
+
+上面说软状态，然后不可能一直是软状态，必须有个时间期限。在期限过后，应当保证所有副本保持数据一致性，从而达到数据的最终一致性。
+这个时间期限取决于网络延时、系统负载、数据复制方案设计等等因素。
+而在实际工程实践中，最终一致性分为5种：
+##### 3.3.1. 因果一致性（Causal consistency）
+因果一致性指的是：如果节点A在更新完某个数据后通知了节点B，那么节点B之后对该数据的访问和修改都是基于A更新后的值。于此同时，和节点A无因果关系的节点C的数据访问则没有这样的限制。
+##### 3.3.2. 读己之所写（Read your writes）
+读己之所写指的是：节点A更新一个数据后，它自身总是能访问到自身更新过的最新值，而不会看到旧值。其实也算一种因果一致性。
+##### 3.3.3. 会话一致性（Session consistency）
+会话一致性将对系统数据的访问过程框定在了一个会话当中：系统能保证在同一个有效的会话中实现 “读己之所写” 的一致性，也就是说，执行更新操作之后，客户端能够在同一个会话中始终读取到该数据项的最新值。
+##### 3.3.4. 单调读一致性（Monotonic read consistency）
+单调读一致性指的是：如果一个节点从系统中读取出一个数据项的某个值后，那么系统对于该节点后续的任何数据访问都不应该返回更旧的值。
+##### 3.3.5. 单调写一致性（Monotonic write consistency）
+单调写一致性指的是：一个系统要能够保证来自同一个节点的写操作被顺序的执行。
+
+在实际的实践中，这5种系统往往会结合使用，以构建一个具有最终一致性的分布式系统。
+
+实际上，不只是分布式系统使用最终一致性，关系型数据库在某个功能上，也是使用最终一致性的。比如备份，数据库的复制过程是需要时间的，这个复制过程中，业务读取到的值就是旧的。当然，最终还是达成了数据一致性。这也算是一个最终一致性的经典案例。
+
+### 小结
+总体来说BASE理论面向的是大型高可用、可扩展的分布式系统。与传统ACID特性相反，不同于ACID的强一致性模型，BASE提出通过牺牲强一致性来获得可用性，并允许数据段时间内的不一致，但是最终达到一致状态。同时，在实际分布式场景中，不同业务对数据的一致性要求不一样。因此在设计中，ACID和BASE理论往往又会结合使用。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 3 - 2PC\345\215\217\350\256\256.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 3 - 2PC\345\215\217\350\256\256.md"
similarity index 97%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 3 - 2PC\345\215\217\350\256\256.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 3 - 2PC\345\215\217\350\256\256.md"
index 6a427d9a..6b65bdbf 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 3 - 2PC\345\215\217\350\256\256.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 3 - 2PC\345\215\217\350\256\256.md"	
@@ -1,148 +1,148 @@
-https://juejin.im/post/5b2664446fb9a00e4a53136e
-
-### 前言
-
-由于BASE理论需要在一致性和可用性方面做出权衡，因此涌现了很多关于一致性的算法和协议。
-其中比较著名的有二阶提交协议（2 Phase Commitment Protocol），三阶提交协议（3 Phase Commitment Protocol）和Paxos算法。
-
-本文要介绍的2PC协议，分为两个阶段提交一个事务。并通过协调者和各个参与者的配合，实现分布式一致性。
-
-<div align="center"> <img src="img/2pc1.jpg" > </div>
-
-两个阶段事务提交协议，由协调者和参与者共同完成。
-
-`协调者`:`事务管理器`:协调各个参与者，对分布式事务进行提交或回滚
-
-`参与者`:`资源管理器`:分布式集群中的节点
-
-### 1. 分布式事务
-
-分布式事务是指会涉及到操作多个数据库的事务，其实就是将对同一库事务的概念扩大到了对多个库的事务。目的是为了保证分布式系统中的数据一致性。
-
-分布式事务处理的关键是：
-
-  1. 需要记录事务在任何节点所做的所有动作；
-  2. 事务进行的所有操作要么全部提交，要么全部回滚。
-
-### 2. XA规范
-#### 2.1. XA规范的组成
-
-XA规范是由 X/Open组织（即现在的 Open Group ）定义的分布式事务处理模型。 X/Open DTP 模型（ 1994 ）包括：
-
-* 应用程序（ AP ）
-* 事务管理器（ TM ）：交易中间件等
-* 资源管理器（ RM ）：关系型数据库等
-* 通信资源管理器（ CRM ）：消息中间件等
-
-#### 2.2. XA规范的定义
-
-XA规范定义了交易中间件与数据库之间的接口规范（即接口函数），交易中间件用它来通知数据库事务的开始、结束以及提交、回滚等。而XA接口函数由数据库厂商提供。
-
-二阶提交协议和三阶提交协议就是基于XA规范提出的其中，二阶段提交就是实现XA分布式事务的关键。
-
-#### 2.3. XA规范编程规范
-
-1. 配置TM，给TM注册RM作为数据源。其中，一个TM可以注册多个RM。
-
-2. AP向TM发起一个全局事务。这时，TM会发送一个XID（全局事务ID）通知各个RM。
-
-3. AP从TM获取资源管理器的代理（例如：使用JTA接口，从TM管理的上下文中，获取出这个TM所管理的RM的JDBC连接或JMS连接）。
-
-4. AP通过从TM中获取的连接，间接操作RM进行业务操作。TM在每次AP操作时把XID传递给RM，RM正是通过这个XID关联来操作和事务的关系的。
-
-5. AP结束全局事务时，TM会通知RM全局事务结束。开始二段提交，也就是prepare - commit的过程。
-
-XA规范的流程，大致如图所示：
-<div align="center"> <img src="img/2pc2.jpg" > </div>
-
-### 3. 二阶段提交（2PC）
-#### 3.1. 二阶段提交的定义
-二阶段提交的算法思路可以概括为：每个参与者将操作成败通知协调者，再由协调者根据所有参与者的反馈情报，决定各参与者是否要提交操作还是中止操作。
-所谓的两个阶段分别是：
-
-* 第一阶段：准备阶段（投票阶段）
-* 第二阶段：提交阶段（执行阶段）
-
-#### 3.1.1. 准备阶段
-准备阶段分为三个步骤：
-
-<div align="center"> <img src="img/2pc3.jpg" > </div>
-
-a. 事务询问
-
-    协调者向所有的参与者询问，是否准备好了执行事务，并开始等待各参与者的响应。
-
-b. 执行事务
-
-    各参与者节点执行事务操作。如果本地事务成功，将Undo和Redo信息记入事务日志中，但不提交；否则，直接返回失败，退出执行。
-
-c. 各参与者向协调者反馈事务询问的响应
-
-    如果参与者成功执行了事务操作，那么就反馈给协调者 Yes响应，表示事务可以执行提交；如果参与者没有成功执行事务，就返回No给协调者，表示事务不可以执行提交。
-
-### 3.1.2. 提交阶段
-在提交阶段中，会根据准备阶段的投票结果执行2种操作：执行事务提交，中断事务。
-
-**提交事务过程如下：**
-
-<div align="center"> <img src="img/2pc4.jpg" > </div>
-
-a. 发送提交请求
-
-    协调者向所有参与者发出commit请求。
-
-b. 事务提交
-
-    参与者收到commit请求后，会正式执行事务提交操作，并在完成提交之后，释放整个事务执行期间占用的事务资源。
-
-c. 反馈事务提交结果
-
-    参与者在完成事务提交之后，向协调者发送Ack信息。
-
-d. 事务提交确认
-
-    协调者接收到所有参与者反馈的Ack信息后，完成事务。
-
-**中断事务过程如下：**
-
-<div align="center"> <img src="img/2pc5.jpg" > </div>
-
-a. 发送回滚请求
-
-    协调者向所有参与者发出Rollback请求。
-
-b. 事务回滚
-
-    参与者接收到Rollback请求后，会利用其在提交阶段种记录的Undo信息，来执行事务回滚操作。在完成回滚之后，释放在整个事务执行期间占用的资源。
-
-c. 反馈事务回滚结果
-
-    参与者在完成事务回滚之后，想协调者发送Ack信息。
-
-d. 事务中断确认
-
-    协调者接收到所有参与者反馈的Ack信息后，完成事务中断。
-
-### 4. 二阶段提交的优缺点
-
-* 优点：原理简单，实现方便。
-* 缺点：同步阻塞，单点问题，数据不一致，容错性不好。
-
-**同步阻塞**
-
-在二阶段提交的过程中，所有的节点都在等待其他节点的响应，无法进行其他操作。这种同步阻塞极大的限制了分布式系统的性能。
-
-**单点问题**
-
-协调者在整个二阶段提交过程中很重要，如果协调者在提交阶段出现问题，那么整个流程将无法运转。更重要的是，其他参与者将会处于一直锁定事务资源的状态中，而无法继续完成事务操作。
-
-**数据不一致**
-
-假设当协调者向所有的参与者发送commit请求之后，发生了局部网络异常，或者是协调者在尚未发送完所有 commit请求之前自身发生了崩溃，导致最终只有部分参与者收到了commit请求。这将导致严重的数据不一致问题。
-
-**容错性不好**
-
-如果在二阶段提交的提交询问阶段中，参与者出现故障，导致协调者始终无法获取到所有参与者的确认信息，这时协调者只能依靠其自身的超时机制，判断是否需要中断事务。显然，这种策略过于保守。换句话说，二阶段提交协议没有设计较为完善的容错机制，任意一个节点是失败都会导致整个事务的失败。
-
-### 小结
-对于2PC协议存在的同步阻塞、单点问题，将在下一篇文章的3PC协议中引入解决方案。
+https://juejin.im/post/5b2664446fb9a00e4a53136e
+
+### 前言
+
+由于BASE理论需要在一致性和可用性方面做出权衡，因此涌现了很多关于一致性的算法和协议。
+其中比较著名的有二阶提交协议（2 Phase Commitment Protocol），三阶提交协议（3 Phase Commitment Protocol）和Paxos算法。
+
+本文要介绍的2PC协议，分为两个阶段提交一个事务。并通过协调者和各个参与者的配合，实现分布式一致性。
+
+<div align="center"> <img src="img/2pc1.jpg" > </div>
+
+两个阶段事务提交协议，由协调者和参与者共同完成。
+
+`协调者`:`事务管理器`:协调各个参与者，对分布式事务进行提交或回滚
+
+`参与者`:`资源管理器`:分布式集群中的节点
+
+### 1. 分布式事务
+
+分布式事务是指会涉及到操作多个数据库的事务，其实就是将对同一库事务的概念扩大到了对多个库的事务。目的是为了保证分布式系统中的数据一致性。
+
+分布式事务处理的关键是：
+
+  1. 需要记录事务在任何节点所做的所有动作；
+  2. 事务进行的所有操作要么全部提交，要么全部回滚。
+
+### 2. XA规范
+#### 2.1. XA规范的组成
+
+XA规范是由 X/Open组织（即现在的 Open Group ）定义的分布式事务处理模型。 X/Open DTP 模型（ 1994 ）包括：
+
+* 应用程序（ AP ）
+* 事务管理器（ TM ）：交易中间件等
+* 资源管理器（ RM ）：关系型数据库等
+* 通信资源管理器（ CRM ）：消息中间件等
+
+#### 2.2. XA规范的定义
+
+XA规范定义了交易中间件与数据库之间的接口规范（即接口函数），交易中间件用它来通知数据库事务的开始、结束以及提交、回滚等。而XA接口函数由数据库厂商提供。
+
+二阶提交协议和三阶提交协议就是基于XA规范提出的其中，二阶段提交就是实现XA分布式事务的关键。
+
+#### 2.3. XA规范编程规范
+
+1. 配置TM，给TM注册RM作为数据源。其中，一个TM可以注册多个RM。
+
+2. AP向TM发起一个全局事务。这时，TM会发送一个XID（全局事务ID）通知各个RM。
+
+3. AP从TM获取资源管理器的代理（例如：使用JTA接口，从TM管理的上下文中，获取出这个TM所管理的RM的JDBC连接或JMS连接）。
+
+4. AP通过从TM中获取的连接，间接操作RM进行业务操作。TM在每次AP操作时把XID传递给RM，RM正是通过这个XID关联来操作和事务的关系的。
+
+5. AP结束全局事务时，TM会通知RM全局事务结束。开始二段提交，也就是prepare - commit的过程。
+
+XA规范的流程，大致如图所示：
+<div align="center"> <img src="img/2pc2.jpg" > </div>
+
+### 3. 二阶段提交（2PC）
+#### 3.1. 二阶段提交的定义
+二阶段提交的算法思路可以概括为：每个参与者将操作成败通知协调者，再由协调者根据所有参与者的反馈情报，决定各参与者是否要提交操作还是中止操作。
+所谓的两个阶段分别是：
+
+* 第一阶段：准备阶段（投票阶段）
+* 第二阶段：提交阶段（执行阶段）
+
+#### 3.1.1. 准备阶段
+准备阶段分为三个步骤：
+
+<div align="center"> <img src="img/2pc3.jpg" > </div>
+
+a. 事务询问
+
+    协调者向所有的参与者询问，是否准备好了执行事务，并开始等待各参与者的响应。
+
+b. 执行事务
+
+    各参与者节点执行事务操作。如果本地事务成功，将Undo和Redo信息记入事务日志中，但不提交；否则，直接返回失败，退出执行。
+
+c. 各参与者向协调者反馈事务询问的响应
+
+    如果参与者成功执行了事务操作，那么就反馈给协调者 Yes响应，表示事务可以执行提交；如果参与者没有成功执行事务，就返回No给协调者，表示事务不可以执行提交。
+
+### 3.1.2. 提交阶段
+在提交阶段中，会根据准备阶段的投票结果执行2种操作：执行事务提交，中断事务。
+
+**提交事务过程如下：**
+
+<div align="center"> <img src="img/2pc4.jpg" > </div>
+
+a. 发送提交请求
+
+    协调者向所有参与者发出commit请求。
+
+b. 事务提交
+
+    参与者收到commit请求后，会正式执行事务提交操作，并在完成提交之后，释放整个事务执行期间占用的事务资源。
+
+c. 反馈事务提交结果
+
+    参与者在完成事务提交之后，向协调者发送Ack信息。
+
+d. 事务提交确认
+
+    协调者接收到所有参与者反馈的Ack信息后，完成事务。
+
+**中断事务过程如下：**
+
+<div align="center"> <img src="img/2pc5.jpg" > </div>
+
+a. 发送回滚请求
+
+    协调者向所有参与者发出Rollback请求。
+
+b. 事务回滚
+
+    参与者接收到Rollback请求后，会利用其在提交阶段种记录的Undo信息，来执行事务回滚操作。在完成回滚之后，释放在整个事务执行期间占用的资源。
+
+c. 反馈事务回滚结果
+
+    参与者在完成事务回滚之后，想协调者发送Ack信息。
+
+d. 事务中断确认
+
+    协调者接收到所有参与者反馈的Ack信息后，完成事务中断。
+
+### 4. 二阶段提交的优缺点
+
+* 优点：原理简单，实现方便。
+* 缺点：同步阻塞，单点问题，数据不一致，容错性不好。
+
+**同步阻塞**
+
+在二阶段提交的过程中，所有的节点都在等待其他节点的响应，无法进行其他操作。这种同步阻塞极大的限制了分布式系统的性能。
+
+**单点问题**
+
+协调者在整个二阶段提交过程中很重要，如果协调者在提交阶段出现问题，那么整个流程将无法运转。更重要的是，其他参与者将会处于一直锁定事务资源的状态中，而无法继续完成事务操作。
+
+**数据不一致**
+
+假设当协调者向所有的参与者发送commit请求之后，发生了局部网络异常，或者是协调者在尚未发送完所有 commit请求之前自身发生了崩溃，导致最终只有部分参与者收到了commit请求。这将导致严重的数据不一致问题。
+
+**容错性不好**
+
+如果在二阶段提交的提交询问阶段中，参与者出现故障，导致协调者始终无法获取到所有参与者的确认信息，这时协调者只能依靠其自身的超时机制，判断是否需要中断事务。显然，这种策略过于保守。换句话说，二阶段提交协议没有设计较为完善的容错机制，任意一个节点是失败都会导致整个事务的失败。
+
+### 小结
+对于2PC协议存在的同步阻塞、单点问题，将在下一篇文章的3PC协议中引入解决方案。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 4 - 3PC\345\215\217\350\256\256.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 4 - 3PC\345\215\217\350\256\256.md"
similarity index 97%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 4 - 3PC\345\215\217\350\256\256.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 4 - 3PC\345\215\217\350\256\256.md"
index 38e68659..1f39d8d8 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 4 - 3PC\345\215\217\350\256\256.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 4 - 3PC\345\215\217\350\256\256.md"	
@@ -1,115 +1,115 @@
-https://juejin.im/post/5b26648e5188257494641b9f
-### 前言
-由于二阶段提交存在着诸如同步阻塞、单点问题、脑裂等缺陷。所以，研究者们在二阶段提交的基础上做了改进，提出了三阶段提交。
-<div align="center"> <img src="img/3pc.jpg" > </div>
-
-与两阶段提交不同的是，三阶段提交有两个改动点。
-
-1. 引入超时机制 - 同时在协调者和参与者中都引入超时机制。
-2. 在第一阶段和第二阶段中插入一个准备阶段，保证了在最后提交阶段之前各参与节点的状态是一致的。
-
-### 1. 三阶段提交的定义
-三阶段提交（Three-phase commit），也叫三阶段提交协议（Three-phase commit protocol），是二阶段提交（2PC）的改进版本。
-所谓的三个阶段分别是：询问，然后再锁资源，最后真正提交。
-
-* 第一阶段：CanCommit
-* 第二阶段：PreCommit
-* 第三阶段：Do Commit
-
-### 2. 三阶段提交的过程
-
-#### 2.1. 阶段一：CanCommit
-
-3PC的CanCommit阶段其实和2PC的准备阶段很像。协调者向参与者发送commit请求，参与者如果可以提交就返回Yes响应，否则返回No响应。
-
-a. 事务询问
-
-    协调者向参与者发送CanCommit请求。询问是否可以执行事务提交操作。然后开始等待参与者的响应。
-
-b. 响应反馈
-
-    参与者接到CanCommit请求之后，正常情况下，如果其自身认为可以顺利执行事务，则返回Yes响应，并进入预备状态；否则反馈No。
-
-#### 2.2. 阶段二：PreCommit
-
-协调者在得到所有参与者的响应之后，会根据结果执行2种操作：执行事务预提交，或者中断事务。
-
-##### 2.2.1. 执行事务预提交
-
-a. 发送预提交请求
-
-    协调者向所有参与者节点发出 preCommit 的请求，并进入 prepared 状态。
-
-b. 事务预提交
-
-    参与者受到 preCommit 请求后，会执行事务操作，对应 2PC 准备阶段中的 “执行事务”，也会 Undo 和 Redo 信息记录到事务日志中。
-
-c. 各参与者响应反馈
-
-    如果参与者成功执行了事务，就反馈 ACK 响应，同时等待指令：提交（commit） 或终止（abort）。
-
-##### 2.2.2. 中断事务
-
-a. 发送中断请求
-
-    协调者向所有参与者节点发出 abort 请求 。
-
-b. 中断事务
-
-    参与者如果收到 abort 请求或者超时了，都会中断事务。
-
-#### 2.3. 阶段三：Do Commit
-
-该阶段进行真正的事务提交，也可以分为以下两种情况。
-
-##### 2.3.1. 执行提交
-
-a. 发送提交请求
-
-    协调者接收到各参与者发送的ACK响应，那么他将从预提交状态进入到提交状态。并向所有参与者发送 doCommit 请求。
-
-b. 事务提交
-
-    参与者接收到 doCommit 请求之后，执行正式的事务提交。并在完成事务提交之后释放所有事务资源。
-
-c. 响应反馈
-
-    事务提交完之后，向协调者发送 ACK 响应。
-
-d. 完成事务
-
-    协调者接收到所有参与者的 ACK 响应之后，完成事务。
-
-##### 2.3.2. 中断事务
-
-协调者没有接收到参与者发送的 ACK 响应（可能是接受者发送的不是ACK响应，也可能响应超时），那么就会执行中断事务。
-
-a. 发送中断请求
-
-    协调者向所有参与者发送 abort 请求。
-
-b. 事务回滚
-
-    参与者接收到 abort 请求之后，利用其在阶段二记录的 undo 信息来执行事务的回滚操作，并在完成回滚之后释放所有的事务资源。
-
-c. 反馈结果
-
-    参与者完成事务回滚之后，向协调者发送 ACK 消息。
-
-d. 中断事务
-
-    协调者接收到参与者反馈的 ACK 消息之后，完成事务的中断。
-
-### 3. 小结
-
-#### 3.1. 三阶段提交的优点
-
-相对于二阶段提交，三阶段提交主要解决的 **单点故障问题，并减少了阻塞的时间。**
-
-因为一旦参与者无法及时收到来自协调者的信息之后，他会默认执行 commit。而不会一直持有事务资源并处于阻塞状态。
-
-#### 3.2. 三阶段提交的缺点
-
-三阶段提交也会导致 **数据一致性问题**。由于网络原因，协调者发送的 abort 响应没有及时被参与者接收到，那么参与者在等待超时之后执行了 commit 操作。
-
-这样就和其他接到 abort 命令并执行回滚的参与者之间存在数据不一致的情况。
+https://juejin.im/post/5b26648e5188257494641b9f
+### 前言
+由于二阶段提交存在着诸如同步阻塞、单点问题、脑裂等缺陷。所以，研究者们在二阶段提交的基础上做了改进，提出了三阶段提交。
+<div align="center"> <img src="img/3pc.jpg" > </div>
+
+与两阶段提交不同的是，三阶段提交有两个改动点。
+
+1. 引入超时机制 - 同时在协调者和参与者中都引入超时机制。
+2. 在第一阶段和第二阶段中插入一个准备阶段，保证了在最后提交阶段之前各参与节点的状态是一致的。
+
+### 1. 三阶段提交的定义
+三阶段提交（Three-phase commit），也叫三阶段提交协议（Three-phase commit protocol），是二阶段提交（2PC）的改进版本。
+所谓的三个阶段分别是：询问，然后再锁资源，最后真正提交。
+
+* 第一阶段：CanCommit
+* 第二阶段：PreCommit
+* 第三阶段：Do Commit
+
+### 2. 三阶段提交的过程
+
+#### 2.1. 阶段一：CanCommit
+
+3PC的CanCommit阶段其实和2PC的准备阶段很像。协调者向参与者发送commit请求，参与者如果可以提交就返回Yes响应，否则返回No响应。
+
+a. 事务询问
+
+    协调者向参与者发送CanCommit请求。询问是否可以执行事务提交操作。然后开始等待参与者的响应。
+
+b. 响应反馈
+
+    参与者接到CanCommit请求之后，正常情况下，如果其自身认为可以顺利执行事务，则返回Yes响应，并进入预备状态；否则反馈No。
+
+#### 2.2. 阶段二：PreCommit
+
+协调者在得到所有参与者的响应之后，会根据结果执行2种操作：执行事务预提交，或者中断事务。
+
+##### 2.2.1. 执行事务预提交
+
+a. 发送预提交请求
+
+    协调者向所有参与者节点发出 preCommit 的请求，并进入 prepared 状态。
+
+b. 事务预提交
+
+    参与者受到 preCommit 请求后，会执行事务操作，对应 2PC 准备阶段中的 “执行事务”，也会 Undo 和 Redo 信息记录到事务日志中。
+
+c. 各参与者响应反馈
+
+    如果参与者成功执行了事务，就反馈 ACK 响应，同时等待指令：提交（commit） 或终止（abort）。
+
+##### 2.2.2. 中断事务
+
+a. 发送中断请求
+
+    协调者向所有参与者节点发出 abort 请求 。
+
+b. 中断事务
+
+    参与者如果收到 abort 请求或者超时了，都会中断事务。
+
+#### 2.3. 阶段三：Do Commit
+
+该阶段进行真正的事务提交，也可以分为以下两种情况。
+
+##### 2.3.1. 执行提交
+
+a. 发送提交请求
+
+    协调者接收到各参与者发送的ACK响应，那么他将从预提交状态进入到提交状态。并向所有参与者发送 doCommit 请求。
+
+b. 事务提交
+
+    参与者接收到 doCommit 请求之后，执行正式的事务提交。并在完成事务提交之后释放所有事务资源。
+
+c. 响应反馈
+
+    事务提交完之后，向协调者发送 ACK 响应。
+
+d. 完成事务
+
+    协调者接收到所有参与者的 ACK 响应之后，完成事务。
+
+##### 2.3.2. 中断事务
+
+协调者没有接收到参与者发送的 ACK 响应（可能是接受者发送的不是ACK响应，也可能响应超时），那么就会执行中断事务。
+
+a. 发送中断请求
+
+    协调者向所有参与者发送 abort 请求。
+
+b. 事务回滚
+
+    参与者接收到 abort 请求之后，利用其在阶段二记录的 undo 信息来执行事务的回滚操作，并在完成回滚之后释放所有的事务资源。
+
+c. 反馈结果
+
+    参与者完成事务回滚之后，向协调者发送 ACK 消息。
+
+d. 中断事务
+
+    协调者接收到参与者反馈的 ACK 消息之后，完成事务的中断。
+
+### 3. 小结
+
+#### 3.1. 三阶段提交的优点
+
+相对于二阶段提交，三阶段提交主要解决的 **单点故障问题，并减少了阻塞的时间。**
+
+因为一旦参与者无法及时收到来自协调者的信息之后，他会默认执行 commit。而不会一直持有事务资源并处于阻塞状态。
+
+#### 3.2. 三阶段提交的缺点
+
+三阶段提交也会导致 **数据一致性问题**。由于网络原因，协调者发送的 abort 响应没有及时被参与者接收到，那么参与者在等待超时之后执行了 commit 操作。
+
+这样就和其他接到 abort 命令并执行回滚的参与者之间存在数据不一致的情况。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 5 - \344\270\200\350\207\264\346\200\247\347\256\227\346\263\225Paxos.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 5 - \344\270\200\350\207\264\346\200\247\347\256\227\346\263\225Paxos.md"
similarity index 98%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 5 - \344\270\200\350\207\264\346\200\247\347\256\227\346\263\225Paxos.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 5 - \344\270\200\350\207\264\346\200\247\347\256\227\346\263\225Paxos.md"
index e30dac36..78efe857 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 5 - \344\270\200\350\207\264\346\200\247\347\256\227\346\263\225Paxos.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 5 - \344\270\200\350\207\264\346\200\247\347\256\227\346\263\225Paxos.md"	
@@ -1,179 +1,179 @@
-https://juejin.im/post/5b2664bd51882574874d8a76
-
-### 前言
-
-世界上只有一种一致性算法，就是 Paxos。出自一位 Google 大神之口。Paxos 也是出名的 晦涩难懂，推理过程极其复杂。
-
-Paxos 有点类似之前说的 2PC，3PC，但是解决了这两种算法各种硬伤。
-该算法在很多大厂都得到了工程实践，
-比如阿里的 `OceanBase` 的 分布式数据库，底层就是使用的 Paxos 算法。
-再比如 Google 的 chubby 分布式锁 也是用的这个算法。
-可见该算法在分布式系统中的地位，甚至于，Paxos 就是 分布式一致性 的代名词。
-
-### 1. Paxos算法是什么
-
-Paxos 算法是 `基于消息传递` 且具有 `高效容错特性` 的一致性算法，目前公认的解决 分布式一致性问题 最有效的算法之一.
-
-### 2. Paxos算法产生背景
-#### 2.1. 拜占庭将军问题
-拜占庭是古代东罗马帝国的首都，由于地域宽广，守卫边境的多个将军（系统中的多个节点）需要通过信使来传递消息，达成某些一致的决定。但由于信使中可能存在叛徒（系统中节点出错），这些叛徒将努力向不同的将军发送不同的消息，试图会干扰一致性的达成。
-#### 2.2. Paxos算法由来
-故事背景是古希腊 Paxos 岛上的多个法官在一个大厅内对一个议案进行表决，如何达成统一的结果。他们之间通过服务人员来传递纸条，但法官可能离开或进入大厅，服务人员可能偷懒去睡觉。
-#### 2.3 产生背景
-在常见的 分布式系统 中，总会发生 **节点宕机** 或 **网络异常** (包括消息的 重复、丢失、延迟、乱序、网络分区) 等情况。
-Paxos 算法主要就是解决如何在一个 **发生如上故障** 的分布式系统中，快速正确的在集群内 对某个值达成一致，并且保证 **整个系统的一致性**。
-
-<div align="center"> <img src="img/paxos1.jpg" > </div>
-
-### 3. 算法详解
-
-#### 3.1 角色 & 提案
-提案 (Proposal)
-
-注意：提案的范围>value.后面会讲到，[提案=编号+Value].也可表示为[M,V].
-以下描述中暂定: 提案=P，Value=V.
-
-角色
-
-`Proposer` : Proposer 可以 提出提案 (Proposal)。
-
-`Accecptor` : Acceptor 可以 接受提案。一旦接受提案，提案 里面的 value 值就被选定了。
-
-`Learner` : Acceptor 告诉 Learner 哪个提案被选定了，那么 Learner 就学习这个被选择的 value。
-
-<div align="center"> <img src="img/paxos2.jpg" > </div>
-
-
-在具体的实现中，一个进程即可能是Proposer,也可能是Acceptor，也可能是Learner。
-
-#### 3.2. 问题描述
-
-Paxos 算法的核心是 一致性。所以将从一致性问题的描述来讲解该算法怎么解决实际问题。
-
-##### 3.2.1. 一致性算法的前置条件
-
-在被提出的 P 中，只有一个 V 被选中。
-如果没有 P 被提出，就没有 V 被选中。
-在 P 被选定后，进程都可以学习被选中的 P。
-
-##### 3.2.2. 不同角色通过发送消息进行通信
-
-1. 每个角色以任意的速度执行，可能因出错而停止，也可能会重启。一个 value 被选定后，所有的角色可能失败然后重启，除非那些失败后重启的角色能记录某些信息，否则等他们重启后无法确定被选定的值。
-
-2. 消息在传递过程中可能出现 任意时长的延迟，可能会 重复，也可能 丢失，但是消息不会被 损坏。
-
-#### 3.3. 推导过程
-
-##### 3.3.1. 只有一个Acceptor
-
-<div align="center"> <img src="img/paxos3.jpg" > </div>
-一个 Acceptor 接受一个 P，那么只有一个 V 被选定。
-
-问题：如果这个 Acceptor 宕机，那么整个系统服务不可用。
-
-##### 3.3.2. 多个Acceptor
-
-<div align="center"> <img src="img/paxos4.jpg" > </div>
-
-问题：如何在多 Proposer 和多 Acceptor 情况下，选定一个 value？
-
-讲解步骤分两阶段：约定 P1 和 约定 P2。
-
-###### 3.3.2.1. 约定P1
-
-**P1 ：一个 Acceptor 必须接受一个它收到的第一个 P。**
-
-如果每个 Proposer 会产生不同的 P，那么多个 Proposer 必定产生多个 P，发给多个 Acceptor。根据 约定 P1，Acceptor 分别接受到 P，就会导致不同的 V 被选定，如下图所示：
-<div align="center"> <img src="img/paxos5.jpg" > </div>
-如上图所示，P1 会产生的问题: v1、v2、v3 都没有被选定，因为他们只有被一个 Acceptor 接受。
-对于上述问题，我们需要一个额外的约定:
-
-**P1a : 一个提案 P 被选定，需要被半数以上 Acceptor 接受.**
-
-对于 P1a，其实就意味着 一个Acceptor必须接受不止一个提案。
-显然，这与 P1 相矛盾，所以需要重新设计提案。原来的设计是: [提案P = value]，现在重新设计 [提案P = 提案编号 + value]，可表示为 [M，V]。
-
-新问题：多提案被选定，如何保证被选定的提案 P 具有相同的value?
-
-###### 3.3.2.2. 约定P2
-
-**P2 : 如果提案 P[M0,V0] 被选定了，那么所有比 M0 编号更高的，且被选定的 P，其 value 的值也是 V0。**
-
-对于 P2 中的 “被选定”：一个提案要被选定，首先至少要被一个 Acceptor 批准。因此，可以理解 P2 为：
-
-**P2a : 如果提案 P[M0,V0] 被选定了，那么所有比 M0 编号更高的，且 [被Acceptor批准] 的P，其 value 值也是 V0。**
-
-只要满足 P2a，就能满足 P2。多提案被选择 的问题解决了，但是由于 网络不稳定 或者 宕机 的原因（不可避免），会产生新问题：
-<div align="center"> <img src="img/paxos6.jpg" > </div>
-
-假设有 5 个 Acceptor。Proposer2 提出 [M1,V1]的提案，Acceptor2~5（半数以上）均接受了该提案，于是对于 Acceptor2~5 和 Proposer2 来讲，它们都认为 V1 被选定。Acceptor1 刚刚从 宕机状态 恢复过来（之前 Acceptor1 没有收到过任何提案），此时 Proposer1 向 Acceptor1 发送了 [M2,V2] 的提案 （V2≠V1且M2>M1）。对于 Acceptor1 来讲，这是它收到的 第一个提案。根据 P1（一个 Acceptor 必须接受它收到的 第一个提案），Acceptor1 必须接受该提案。同时 Acceptor1 认为 V2 被选定。
-这就出现了两个问题：
-
-1. Acceptor1 认为 V2 被选定，Acceptor2~5 和Proposer2 认为 V1 被选定。出现了不一致。
-
-2. V1 被选定了，但是 编号更高 的被 Acceptor1 接受的提案 [M2,V2] 的 value 为 V2，且 V2≠V1。这就跟 P2a（如果某个 value 为 v的提案被选定了，那么每个 编号更高 的被 Acceptor 接受的提案的 value 必须也是 v）矛盾了。
-
-
-基于以上问题，所有就有了 P2b:
-
-**P2b : 如果 P[M0,V0] 被选定后，任何 Proposer 产生的 P，其值也是 V0。**
-
-对于 P2b 中的描述，怎样保证 任何Proposer产生的P，其值也是V0 ？只要满足 P2c 即可：
-
-**P2c: 对于任意的 M、V，如果 [M,V] 被提出，那么存在一个半数以上的 Acceptor 组成的组合 S，满足以下两个条件中的任何一个：
-① S 中没有一个接受过编号小于 M 的提案。
-② S 中的 Acceptor 接受过的最大编号的提案的 value 为 V。**
-
-推导完毕。。。
-#### 3.4. 算法流程
-##### 3.4.1. Proposer提出提案
-总体思路如下：
-**(一). 学习阶段：Prepare请求**
-
-Proposer 选择一个新的提案 P[MN,?] 向 Acceptor 集合 S（数目在半数以上）发送请求，要求 S 中的每一个 Acceptor 做出如下响应：
-
-如果 Acceptor 没有接受过提案，则向 Proposer 保证 不再接受编号小于N的提案。
-
-如果 Acceptor 接受过请求，则向 Proposer 返回 已经接受过的编号小于N的编号最大的提案。
-
-
-**(二). 接受阶段：Acceptor请求**
-
-如果 Proposer 收到 半数以上 的 Acceptor 响应，则 生成编号为 N，value 为 V 的提案 [MN,V]，V 为所有响应中 编号最大 的提案的 value。
-
-如果 Proposer 收到的响应中 没有提案，那么 value 由 Proposer 自己生成，生成后将此提案发给 S，并期望 Acceptor 能接受此提案。
-
-##### 3.4.2. Acceptor接受提案
-Acceptor 可以忽略任何请求（包括 Prepare 请求和 Accept 请求）而不用担心破坏 算法的安全性。因此，我们这里要讨论的是什么时候 Acceptor 可以响应一个请求。
-对 Acceptor 接受提案给出如下约束：
-
-**P1b：一个 Acceptor 只要尚未响应过任何编号大于 N 的 Prepare 请求，那么就可以接受这个编号为 N 的提案。**
-
-如果 Acceptor 收到一个编号为 N 的 Prepare 请求，在此之前它已经 响应过 编号大于 N 的 Prepare 请求。根据 P1b，该 Acceptor 不可能接受编号为 N 的提案。因此，该 Acceptor 可以 忽略 编号为 N 的 Prepare 请求。当然，也可以回复一个 error，让 Proposer 尽早知道自己的提案 不会被接受。
-因此，一个 Acceptor 只需记住：
-
-1. 已接受的编号最大的提案；
-2. 已响应的请求的最大编号。
-
-<div align="center"> <img src="img/paxos7.jpg" > </div>
-
-### 4. Paxos算法描述
-
-<div align="center"> <img src="img/paxos8.jpg" > </div>
-
-### 5. Learner学习提案
-
-Learner 学习（获取）被选定的 value 有如下三种方案:
-<div align="center"> <img src="img/paxos9.jpg" > </div>
-
-### 6. 如何保证Paxos算法的活性
-
-<div align="center"> <img src="img/paxos10.jpg" > </div>
-
-### 小结
-
-Paxos 在 节点宕机恢复、消息无序或丢失、网络分化 的场景下能保证 数据的一致性。而 Paxos 的描述侧重于 理论，在实际项目应用中，处理了 N 多实际细节后，可能已经变成了另外一种算法，这时候正确性已经无法得到理论的保证。
-
-要证明分布式一致性算法的正确性通常比实现算法还困难。所以很多系统实际中使用的都是以 Paxos 理论 为基础而 衍生 出来的变种和简化版。例如 Google 的 Chubby、MegaStore、Spanner 等系统，ZooKeeper 的 ZAB 协议，还有更加容易理解的 Raft 协议。
-
-大部分系统都是靠在实践中运行很长一段时间，经过验证发现系统已可以基本运行，没有发现大的问题才能上生产环境。
+https://juejin.im/post/5b2664bd51882574874d8a76
+
+### 前言
+
+世界上只有一种一致性算法，就是 Paxos。出自一位 Google 大神之口。Paxos 也是出名的 晦涩难懂，推理过程极其复杂。
+
+Paxos 有点类似之前说的 2PC，3PC，但是解决了这两种算法各种硬伤。
+该算法在很多大厂都得到了工程实践，
+比如阿里的 `OceanBase` 的 分布式数据库，底层就是使用的 Paxos 算法。
+再比如 Google 的 chubby 分布式锁 也是用的这个算法。
+可见该算法在分布式系统中的地位，甚至于，Paxos 就是 分布式一致性 的代名词。
+
+### 1. Paxos算法是什么
+
+Paxos 算法是 `基于消息传递` 且具有 `高效容错特性` 的一致性算法，目前公认的解决 分布式一致性问题 最有效的算法之一.
+
+### 2. Paxos算法产生背景
+#### 2.1. 拜占庭将军问题
+拜占庭是古代东罗马帝国的首都，由于地域宽广，守卫边境的多个将军（系统中的多个节点）需要通过信使来传递消息，达成某些一致的决定。但由于信使中可能存在叛徒（系统中节点出错），这些叛徒将努力向不同的将军发送不同的消息，试图会干扰一致性的达成。
+#### 2.2. Paxos算法由来
+故事背景是古希腊 Paxos 岛上的多个法官在一个大厅内对一个议案进行表决，如何达成统一的结果。他们之间通过服务人员来传递纸条，但法官可能离开或进入大厅，服务人员可能偷懒去睡觉。
+#### 2.3 产生背景
+在常见的 分布式系统 中，总会发生 **节点宕机** 或 **网络异常** (包括消息的 重复、丢失、延迟、乱序、网络分区) 等情况。
+Paxos 算法主要就是解决如何在一个 **发生如上故障** 的分布式系统中，快速正确的在集群内 对某个值达成一致，并且保证 **整个系统的一致性**。
+
+<div align="center"> <img src="img/paxos1.jpg" > </div>
+
+### 3. 算法详解
+
+#### 3.1 角色 & 提案
+提案 (Proposal)
+
+注意：提案的范围>value.后面会讲到，[提案=编号+Value].也可表示为[M,V].
+以下描述中暂定: 提案=P，Value=V.
+
+角色
+
+`Proposer` : Proposer 可以 提出提案 (Proposal)。
+
+`Accecptor` : Acceptor 可以 接受提案。一旦接受提案，提案 里面的 value 值就被选定了。
+
+`Learner` : Acceptor 告诉 Learner 哪个提案被选定了，那么 Learner 就学习这个被选择的 value。
+
+<div align="center"> <img src="img/paxos2.jpg" > </div>
+
+
+在具体的实现中，一个进程即可能是Proposer,也可能是Acceptor，也可能是Learner。
+
+#### 3.2. 问题描述
+
+Paxos 算法的核心是 一致性。所以将从一致性问题的描述来讲解该算法怎么解决实际问题。
+
+##### 3.2.1. 一致性算法的前置条件
+
+在被提出的 P 中，只有一个 V 被选中。
+如果没有 P 被提出，就没有 V 被选中。
+在 P 被选定后，进程都可以学习被选中的 P。
+
+##### 3.2.2. 不同角色通过发送消息进行通信
+
+1. 每个角色以任意的速度执行，可能因出错而停止，也可能会重启。一个 value 被选定后，所有的角色可能失败然后重启，除非那些失败后重启的角色能记录某些信息，否则等他们重启后无法确定被选定的值。
+
+2. 消息在传递过程中可能出现 任意时长的延迟，可能会 重复，也可能 丢失，但是消息不会被 损坏。
+
+#### 3.3. 推导过程
+
+##### 3.3.1. 只有一个Acceptor
+
+<div align="center"> <img src="img/paxos3.jpg" > </div>
+一个 Acceptor 接受一个 P，那么只有一个 V 被选定。
+
+问题：如果这个 Acceptor 宕机，那么整个系统服务不可用。
+
+##### 3.3.2. 多个Acceptor
+
+<div align="center"> <img src="img/paxos4.jpg" > </div>
+
+问题：如何在多 Proposer 和多 Acceptor 情况下，选定一个 value？
+
+讲解步骤分两阶段：约定 P1 和 约定 P2。
+
+###### 3.3.2.1. 约定P1
+
+**P1 ：一个 Acceptor 必须接受一个它收到的第一个 P。**
+
+如果每个 Proposer 会产生不同的 P，那么多个 Proposer 必定产生多个 P，发给多个 Acceptor。根据 约定 P1，Acceptor 分别接受到 P，就会导致不同的 V 被选定，如下图所示：
+<div align="center"> <img src="img/paxos5.jpg" > </div>
+如上图所示，P1 会产生的问题: v1、v2、v3 都没有被选定，因为他们只有被一个 Acceptor 接受。
+对于上述问题，我们需要一个额外的约定:
+
+**P1a : 一个提案 P 被选定，需要被半数以上 Acceptor 接受.**
+
+对于 P1a，其实就意味着 一个Acceptor必须接受不止一个提案。
+显然，这与 P1 相矛盾，所以需要重新设计提案。原来的设计是: [提案P = value]，现在重新设计 [提案P = 提案编号 + value]，可表示为 [M，V]。
+
+新问题：多提案被选定，如何保证被选定的提案 P 具有相同的value?
+
+###### 3.3.2.2. 约定P2
+
+**P2 : 如果提案 P[M0,V0] 被选定了，那么所有比 M0 编号更高的，且被选定的 P，其 value 的值也是 V0。**
+
+对于 P2 中的 “被选定”：一个提案要被选定，首先至少要被一个 Acceptor 批准。因此，可以理解 P2 为：
+
+**P2a : 如果提案 P[M0,V0] 被选定了，那么所有比 M0 编号更高的，且 [被Acceptor批准] 的P，其 value 值也是 V0。**
+
+只要满足 P2a，就能满足 P2。多提案被选择 的问题解决了，但是由于 网络不稳定 或者 宕机 的原因（不可避免），会产生新问题：
+<div align="center"> <img src="img/paxos6.jpg" > </div>
+
+假设有 5 个 Acceptor。Proposer2 提出 [M1,V1]的提案，Acceptor2~5（半数以上）均接受了该提案，于是对于 Acceptor2~5 和 Proposer2 来讲，它们都认为 V1 被选定。Acceptor1 刚刚从 宕机状态 恢复过来（之前 Acceptor1 没有收到过任何提案），此时 Proposer1 向 Acceptor1 发送了 [M2,V2] 的提案 （V2≠V1且M2>M1）。对于 Acceptor1 来讲，这是它收到的 第一个提案。根据 P1（一个 Acceptor 必须接受它收到的 第一个提案），Acceptor1 必须接受该提案。同时 Acceptor1 认为 V2 被选定。
+这就出现了两个问题：
+
+1. Acceptor1 认为 V2 被选定，Acceptor2~5 和Proposer2 认为 V1 被选定。出现了不一致。
+
+2. V1 被选定了，但是 编号更高 的被 Acceptor1 接受的提案 [M2,V2] 的 value 为 V2，且 V2≠V1。这就跟 P2a（如果某个 value 为 v的提案被选定了，那么每个 编号更高 的被 Acceptor 接受的提案的 value 必须也是 v）矛盾了。
+
+
+基于以上问题，所有就有了 P2b:
+
+**P2b : 如果 P[M0,V0] 被选定后，任何 Proposer 产生的 P，其值也是 V0。**
+
+对于 P2b 中的描述，怎样保证 任何Proposer产生的P，其值也是V0 ？只要满足 P2c 即可：
+
+**P2c: 对于任意的 M、V，如果 [M,V] 被提出，那么存在一个半数以上的 Acceptor 组成的组合 S，满足以下两个条件中的任何一个：
+① S 中没有一个接受过编号小于 M 的提案。
+② S 中的 Acceptor 接受过的最大编号的提案的 value 为 V。**
+
+推导完毕。。。
+#### 3.4. 算法流程
+##### 3.4.1. Proposer提出提案
+总体思路如下：
+**(一). 学习阶段：Prepare请求**
+
+Proposer 选择一个新的提案 P[MN,?] 向 Acceptor 集合 S（数目在半数以上）发送请求，要求 S 中的每一个 Acceptor 做出如下响应：
+
+如果 Acceptor 没有接受过提案，则向 Proposer 保证 不再接受编号小于N的提案。
+
+如果 Acceptor 接受过请求，则向 Proposer 返回 已经接受过的编号小于N的编号最大的提案。
+
+
+**(二). 接受阶段：Acceptor请求**
+
+如果 Proposer 收到 半数以上 的 Acceptor 响应，则 生成编号为 N，value 为 V 的提案 [MN,V]，V 为所有响应中 编号最大 的提案的 value。
+
+如果 Proposer 收到的响应中 没有提案，那么 value 由 Proposer 自己生成，生成后将此提案发给 S，并期望 Acceptor 能接受此提案。
+
+##### 3.4.2. Acceptor接受提案
+Acceptor 可以忽略任何请求（包括 Prepare 请求和 Accept 请求）而不用担心破坏 算法的安全性。因此，我们这里要讨论的是什么时候 Acceptor 可以响应一个请求。
+对 Acceptor 接受提案给出如下约束：
+
+**P1b：一个 Acceptor 只要尚未响应过任何编号大于 N 的 Prepare 请求，那么就可以接受这个编号为 N 的提案。**
+
+如果 Acceptor 收到一个编号为 N 的 Prepare 请求，在此之前它已经 响应过 编号大于 N 的 Prepare 请求。根据 P1b，该 Acceptor 不可能接受编号为 N 的提案。因此，该 Acceptor 可以 忽略 编号为 N 的 Prepare 请求。当然，也可以回复一个 error，让 Proposer 尽早知道自己的提案 不会被接受。
+因此，一个 Acceptor 只需记住：
+
+1. 已接受的编号最大的提案；
+2. 已响应的请求的最大编号。
+
+<div align="center"> <img src="img/paxos7.jpg" > </div>
+
+### 4. Paxos算法描述
+
+<div align="center"> <img src="img/paxos8.jpg" > </div>
+
+### 5. Learner学习提案
+
+Learner 学习（获取）被选定的 value 有如下三种方案:
+<div align="center"> <img src="img/paxos9.jpg" > </div>
+
+### 6. 如何保证Paxos算法的活性
+
+<div align="center"> <img src="img/paxos10.jpg" > </div>
+
+### 小结
+
+Paxos 在 节点宕机恢复、消息无序或丢失、网络分化 的场景下能保证 数据的一致性。而 Paxos 的描述侧重于 理论，在实际项目应用中，处理了 N 多实际细节后，可能已经变成了另外一种算法，这时候正确性已经无法得到理论的保证。
+
+要证明分布式一致性算法的正确性通常比实现算法还困难。所以很多系统实际中使用的都是以 Paxos 理论 为基础而 衍生 出来的变种和简化版。例如 Google 的 Chubby、MegaStore、Spanner 等系统，ZooKeeper 的 ZAB 协议，还有更加容易理解的 Raft 协议。
+
+大部分系统都是靠在实践中运行很长一段时间，经过验证发现系统已可以基本运行，没有发现大的问题才能上生产环境。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 6 - \344\270\200\350\207\264\346\200\247\345\215\217\350\256\256Raft.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 6 - \344\270\200\350\207\264\346\200\247\345\215\217\350\256\256Raft.md"
similarity index 98%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 6 - \344\270\200\350\207\264\346\200\247\345\215\217\350\256\256Raft.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 6 - \344\270\200\350\207\264\346\200\247\345\215\217\350\256\256Raft.md"
index cc960ef6..d858efe4 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 6 - \344\270\200\350\207\264\346\200\247\345\215\217\350\256\256Raft.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272 6 - \344\270\200\350\207\264\346\200\247\345\215\217\350\256\256Raft.md"	
@@ -1,142 +1,142 @@
-https://juejin.im/post/5b2664bd51882574874d8a76
-
-### 前言
-Raft 也是一个 一致性算法，和 Paxos 目标相同。但它还有另一个名字 - 易于理解的一致性算法。Paxos 和 Raft 都是为了实现 一致性 产生的。这个过程如同选举一样，参选者 需要说服 大多数选民 (服务器) 投票给他，一旦选定后就跟随其操作。Paxos 和 Raft 的区别在于选举的 具体过程 不同。
-
-### 小试牛刀
-在进入正题前，给大家分享一个《数学发散思维》中的一个故事，站在不同思维角度上，了解对一个问题理解的差异性。
-
-问题: 甲乙两人轮流在一张圆桌上平放黑白围棋子，每次放一子，棋子不许重叠，谁先没有地方放就输。请问怎样放才能赢？
-
-这个问题有两层意思，第一，有没有一种放法保证必赢？第二，如果有怎么证明？
-
-<div align="center"> <img src="img/raft1.jpg" > </div>
-
-上图回答了这个问题，那就是先行者必胜，这里使用了三种不同的思维方式来阐述:
-
-1. 假如桌子只有一个围棋子那么大。
-
-2. 假如桌子无限大，先行者先占住圆心。由于圆是对称图形，所以只要对手还能找到位置放，你总能在对称的另一面找到位置放。
-
-3. 一个圆中可画单数个直径相等且互切的小圆。
-
-三种不同的思维方式在可理解性难度上逐渐加深。
-
-1. 第一种是 极简化思维，但数学上是 不严谨 的。
-
-2. 第二种是 极限思维，和第一种结合起来就是 数学归纳法，在数学上是 严谨 的。
-
-3. 第三种是 形象思维，使用了 几何学概念，但对于没有几何学基础知识的人就很难理解了。
-
-### 什么是Raft协议
-
-Raft 协议将 Server 进程分成三类，分别是 Leader，Candidate，Follower。一个 Server 进程在某一时刻，只能是其中 一种类型，但这不是固定的。不同的时刻，它可能拥有不同的类型，一个 Server 进程的类型是如何改变的，后面会有解释。
-在一个由 Raft 协议组织的集群中有三类角色：
-
-* Leader（领袖）
-* Follower（群众）
-* Candidate（候选人）
-
-就像一个民主社会，领袖由民众投票选出。刚开始没有 领袖，所有集群中的 参与者 都是 群众，那么首先开启一轮大选。在大选期间 所有群众 都能参与竞选，这时所有群众的角色就变成了 候选人，民主投票选出领袖后就开始了这届领袖的任期，然后选举结束，所有除 领袖 的 候选人 又变回 群众角色 服从领袖领导。
-
-这里提到一个概念 「任期」，用术语 Term 表达。关于 Raft 协议的核心概念和术语就这么多，而且和现实民主制度非常匹配，所以很容易理解。
-
-三类角色的变迁图如下，结合后面的选举过程来看很容易理解。
-
-<div align="center"> <img src="img/raft2.jpg" > </div>
-
-### Leader选举过程
-
-在极简的思维下，一个最小的 Raft 民主集群需要 三个参与者（如下图：A、B、C），这样才可能投出多数票。
-
-初始状态 ABC 都是 Follower，然后发起选举这时有 三种 可能的情形发生。下图中前二种都能选出 Leader，第三种则表明 本轮投票无效（Split Votes）。对于第三种，每方都投给了自己，结果没有任何一方获得多数票。之后 每个参与方 随机休息一阵（Election Timeout）重新发起投票直到一方获得多数票。这里的关键就是随机 timeout，最先从 timeout 中恢复发起投票的一方，向还在 timeout 中的另外两方 请求投票，这时它就只能投给自己，导致很快达成一致。
-
-<div align="center"> <img src="img/raft3.jpg" > </div>
-
-选出 Leader 后，Leader 通过 定期 向所有 Follower 发送 心跳信息 维持其统治。若 Follower 一段时间未收到 Leader 的 心跳，则认为 Leader 可能已经挂了，然后再次发起 选举 过程。
-
-### Leader对一致性的影响
-Raft 协议 强依赖 Leader 节点的 可用性，以确保集群 数据的一致性。数据的流向 只能从 Leader 节点向 Follower 节点转移。具体过程如下：
-
-<div align="center"> <img src="img/raft4.jpg" > </div>
-
-1. 当 Client 向集群 Leader 节点 提交数据 后，Leader 节点 接收到的数据 处于 未提交状态（Uncommitted）。
-
-2. 接着 Leader 节点会 并发地 向所有 Follower 节点 复制数据 并 等待接收响应。
-
-3. 集群中至少 超过半数 的节点 已接收 到数据后， Leader 再向 Client 确认数据 已接收。
-
-4. 一旦向 Client 发出数据接收 Ack 响应后，表明此时 数据状态 进入 已提交（Committed），Leader 节点再向 Follower 节点发通知告知该 数据状态已提交。
-
-在这个过程中，主节点 可能在 任意阶段 挂掉，看下 Raft 协议如何针对不同阶段保障 数据一致性 的。
-
-#### 1. 情形1
-
-数据到达 Leader 节点前，这个阶段 Leader 挂掉不影响一致性，不用多说。
-<div align="center"> <img src="img/raft5.jpg" > </div>
-
-#### 2. 情形2
-
-数据到达 Leader 节点，但未复制到 Follower 节点。
-
-这个阶段 Leader 挂掉，数据属于 未提交状态，Client 不会收到 Ack 会认为 超时失败 可安全发起 重试。
-
-<div align="center"> <img src="img/raft6.jpg" > </div>
-
-Follower 节点上没有该数据，重新选主 后 Client 重试 重新提交 可成功。原来的 Leader 节点 恢复 后作为 Follower 加入集群，重新从 当前任期 的新 Leader 处 同步数据，强制保持和 Leader 数据一致。
-
-#### 3. 情形3
-
-数据到达 Leader 节点，成功复制到 Follower 所有节点，但 Follower 还未向 Leader 响应接收。
-
-这个阶段 Leader 挂掉，虽然数据在 Follower 节点处于 未提交状态（Uncommitted），但是 保持一致 的。重新选出 Leader 后可完成 数据提交。
-
-<div align="center"> <img src="img/raft7.jpg" > </div>
-
-此时 Client 由于不知到底提交成功没有，可重试提交。针对这种情况 Raft 要求 RPC 请求实现 **幂等性**，也就是要实现 内部去重机制。
-
-#### 4. 情形4
-
-数据到达 Leader 节点，成功复制到 Follower 的部分节点，但这部分 Follower 节点还未向 Leader 响应接收。
-
-这个阶段 Leader 挂掉，数据在 Follower 节点处于 未提交状态（Uncommitted）且 不一致。
-
-<div align="center"> <img src="img/raft8.jpg" > </div>
-
-Raft 协议要求投票只能投给拥有 最新数据 的节点。所以拥有最新数据的节点会被选为 Leader，然后再 强制同步数据 到其他 Follower，保证 数据不会丢失并 最终一致。
-
-#### 5. 情形5
-
-数据到达 Leader 节点，成功复制到 Follower 所有或多数节点，数据在 Leader 处于已提交状态，但在 Follower 处于未提交状态。
-
-这个阶段 Leader 挂掉，重新选出 新的 Leader 后的处理流程和阶段 3 一样。
-
-<div align="center"> <img src="img/raft9.jpg" > </div>
-
-#### 6. 情形6
-
-数据到达 Leader 节点，成功复制到 Follower 所有或多数节点，数据在所有节点都处于已提交状态，但还未响应 Client。
-
-这个阶段 Leader 挂掉，集群内部数据其实已经是 一致的，Client 重复重试基于幂等策略对 一致性无影响。
-<div align="center"> <img src="img/raft10.jpg" > </div>
-
-#### 7. 情形7
-
-网络分区导致的脑裂情况，出现双 Leader 的现象。
-
-网络分区 将原先的 Leader 节点和 Follower 节点分隔开，Follower 收不到 Leader 的 心跳 将 重新 发起选举产生新的 Leader，这时就产生了 双Leader 现象。
-
-<div align="center"> <img src="img/raft11.jpg" > </div>
-
-原先的 Leader 独自在一个区，向它提交数据不可能复制到多数节点所以永远提交不成功。向新的 Leader 提交数据可以提交成功。
-网络恢复 后，旧的 Leader 发现集群中有 更新任期（Term）的新 Leader ，则 自动降级 为 Follower 并从新 Leader 处 同步数据 达成集群 数据一致。
-
-#### 验证结果
-
-综上穷举分析了 最小集群（3 节点）面临的所有情况，可以看出 Raft 协议都能很好的应对 一致性问题，并且很容易理解。
-
-### 小结
-Paxos 算法是 Leslie Lamport 在 1990 年就公开发表在了自己的网站上，想想我们是什么时候才听说的？什么时候才有一个可用的实现？而 Raft 算法是 2013 年发表的，大家在参考 Raft开源实现库，可以看到有很多基于不同语言的 开源实现库，这就是 可理解性 的重要性。
-
-Raft一致性算法论文的中文翻译
-https://github.com/maemual/raft-zh_cn/blob/master/raft-zh_cn.md
+https://juejin.im/post/5b2664bd51882574874d8a76
+
+### 前言
+Raft 也是一个 一致性算法，和 Paxos 目标相同。但它还有另一个名字 - 易于理解的一致性算法。Paxos 和 Raft 都是为了实现 一致性 产生的。这个过程如同选举一样，参选者 需要说服 大多数选民 (服务器) 投票给他，一旦选定后就跟随其操作。Paxos 和 Raft 的区别在于选举的 具体过程 不同。
+
+### 小试牛刀
+在进入正题前，给大家分享一个《数学发散思维》中的一个故事，站在不同思维角度上，了解对一个问题理解的差异性。
+
+问题: 甲乙两人轮流在一张圆桌上平放黑白围棋子，每次放一子，棋子不许重叠，谁先没有地方放就输。请问怎样放才能赢？
+
+这个问题有两层意思，第一，有没有一种放法保证必赢？第二，如果有怎么证明？
+
+<div align="center"> <img src="img/raft1.jpg" > </div>
+
+上图回答了这个问题，那就是先行者必胜，这里使用了三种不同的思维方式来阐述:
+
+1. 假如桌子只有一个围棋子那么大。
+
+2. 假如桌子无限大，先行者先占住圆心。由于圆是对称图形，所以只要对手还能找到位置放，你总能在对称的另一面找到位置放。
+
+3. 一个圆中可画单数个直径相等且互切的小圆。
+
+三种不同的思维方式在可理解性难度上逐渐加深。
+
+1. 第一种是 极简化思维，但数学上是 不严谨 的。
+
+2. 第二种是 极限思维，和第一种结合起来就是 数学归纳法，在数学上是 严谨 的。
+
+3. 第三种是 形象思维，使用了 几何学概念，但对于没有几何学基础知识的人就很难理解了。
+
+### 什么是Raft协议
+
+Raft 协议将 Server 进程分成三类，分别是 Leader，Candidate，Follower。一个 Server 进程在某一时刻，只能是其中 一种类型，但这不是固定的。不同的时刻，它可能拥有不同的类型，一个 Server 进程的类型是如何改变的，后面会有解释。
+在一个由 Raft 协议组织的集群中有三类角色：
+
+* Leader（领袖）
+* Follower（群众）
+* Candidate（候选人）
+
+就像一个民主社会，领袖由民众投票选出。刚开始没有 领袖，所有集群中的 参与者 都是 群众，那么首先开启一轮大选。在大选期间 所有群众 都能参与竞选，这时所有群众的角色就变成了 候选人，民主投票选出领袖后就开始了这届领袖的任期，然后选举结束，所有除 领袖 的 候选人 又变回 群众角色 服从领袖领导。
+
+这里提到一个概念 「任期」，用术语 Term 表达。关于 Raft 协议的核心概念和术语就这么多，而且和现实民主制度非常匹配，所以很容易理解。
+
+三类角色的变迁图如下，结合后面的选举过程来看很容易理解。
+
+<div align="center"> <img src="img/raft2.jpg" > </div>
+
+### Leader选举过程
+
+在极简的思维下，一个最小的 Raft 民主集群需要 三个参与者（如下图：A、B、C），这样才可能投出多数票。
+
+初始状态 ABC 都是 Follower，然后发起选举这时有 三种 可能的情形发生。下图中前二种都能选出 Leader，第三种则表明 本轮投票无效（Split Votes）。对于第三种，每方都投给了自己，结果没有任何一方获得多数票。之后 每个参与方 随机休息一阵（Election Timeout）重新发起投票直到一方获得多数票。这里的关键就是随机 timeout，最先从 timeout 中恢复发起投票的一方，向还在 timeout 中的另外两方 请求投票，这时它就只能投给自己，导致很快达成一致。
+
+<div align="center"> <img src="img/raft3.jpg" > </div>
+
+选出 Leader 后，Leader 通过 定期 向所有 Follower 发送 心跳信息 维持其统治。若 Follower 一段时间未收到 Leader 的 心跳，则认为 Leader 可能已经挂了，然后再次发起 选举 过程。
+
+### Leader对一致性的影响
+Raft 协议 强依赖 Leader 节点的 可用性，以确保集群 数据的一致性。数据的流向 只能从 Leader 节点向 Follower 节点转移。具体过程如下：
+
+<div align="center"> <img src="img/raft4.jpg" > </div>
+
+1. 当 Client 向集群 Leader 节点 提交数据 后，Leader 节点 接收到的数据 处于 未提交状态（Uncommitted）。
+
+2. 接着 Leader 节点会 并发地 向所有 Follower 节点 复制数据 并 等待接收响应。
+
+3. 集群中至少 超过半数 的节点 已接收 到数据后， Leader 再向 Client 确认数据 已接收。
+
+4. 一旦向 Client 发出数据接收 Ack 响应后，表明此时 数据状态 进入 已提交（Committed），Leader 节点再向 Follower 节点发通知告知该 数据状态已提交。
+
+在这个过程中，主节点 可能在 任意阶段 挂掉，看下 Raft 协议如何针对不同阶段保障 数据一致性 的。
+
+#### 1. 情形1
+
+数据到达 Leader 节点前，这个阶段 Leader 挂掉不影响一致性，不用多说。
+<div align="center"> <img src="img/raft5.jpg" > </div>
+
+#### 2. 情形2
+
+数据到达 Leader 节点，但未复制到 Follower 节点。
+
+这个阶段 Leader 挂掉，数据属于 未提交状态，Client 不会收到 Ack 会认为 超时失败 可安全发起 重试。
+
+<div align="center"> <img src="img/raft6.jpg" > </div>
+
+Follower 节点上没有该数据，重新选主 后 Client 重试 重新提交 可成功。原来的 Leader 节点 恢复 后作为 Follower 加入集群，重新从 当前任期 的新 Leader 处 同步数据，强制保持和 Leader 数据一致。
+
+#### 3. 情形3
+
+数据到达 Leader 节点，成功复制到 Follower 所有节点，但 Follower 还未向 Leader 响应接收。
+
+这个阶段 Leader 挂掉，虽然数据在 Follower 节点处于 未提交状态（Uncommitted），但是 保持一致 的。重新选出 Leader 后可完成 数据提交。
+
+<div align="center"> <img src="img/raft7.jpg" > </div>
+
+此时 Client 由于不知到底提交成功没有，可重试提交。针对这种情况 Raft 要求 RPC 请求实现 **幂等性**，也就是要实现 内部去重机制。
+
+#### 4. 情形4
+
+数据到达 Leader 节点，成功复制到 Follower 的部分节点，但这部分 Follower 节点还未向 Leader 响应接收。
+
+这个阶段 Leader 挂掉，数据在 Follower 节点处于 未提交状态（Uncommitted）且 不一致。
+
+<div align="center"> <img src="img/raft8.jpg" > </div>
+
+Raft 协议要求投票只能投给拥有 最新数据 的节点。所以拥有最新数据的节点会被选为 Leader，然后再 强制同步数据 到其他 Follower，保证 数据不会丢失并 最终一致。
+
+#### 5. 情形5
+
+数据到达 Leader 节点，成功复制到 Follower 所有或多数节点，数据在 Leader 处于已提交状态，但在 Follower 处于未提交状态。
+
+这个阶段 Leader 挂掉，重新选出 新的 Leader 后的处理流程和阶段 3 一样。
+
+<div align="center"> <img src="img/raft9.jpg" > </div>
+
+#### 6. 情形6
+
+数据到达 Leader 节点，成功复制到 Follower 所有或多数节点，数据在所有节点都处于已提交状态，但还未响应 Client。
+
+这个阶段 Leader 挂掉，集群内部数据其实已经是 一致的，Client 重复重试基于幂等策略对 一致性无影响。
+<div align="center"> <img src="img/raft10.jpg" > </div>
+
+#### 7. 情形7
+
+网络分区导致的脑裂情况，出现双 Leader 的现象。
+
+网络分区 将原先的 Leader 节点和 Follower 节点分隔开，Follower 收不到 Leader 的 心跳 将 重新 发起选举产生新的 Leader，这时就产生了 双Leader 现象。
+
+<div align="center"> <img src="img/raft11.jpg" > </div>
+
+原先的 Leader 独自在一个区，向它提交数据不可能复制到多数节点所以永远提交不成功。向新的 Leader 提交数据可以提交成功。
+网络恢复 后，旧的 Leader 发现集群中有 更新任期（Term）的新 Leader ，则 自动降级 为 Follower 并从新 Leader 处 同步数据 达成集群 数据一致。
+
+#### 验证结果
+
+综上穷举分析了 最小集群（3 节点）面临的所有情况，可以看出 Raft 协议都能很好的应对 一致性问题，并且很容易理解。
+
+### 小结
+Paxos 算法是 Leslie Lamport 在 1990 年就公开发表在了自己的网站上，想想我们是什么时候才听说的？什么时候才有一个可用的实现？而 Raft 算法是 2013 年发表的，大家在参考 Raft开源实现库，可以看到有很多基于不同语言的 开源实现库，这就是 可理解性 的重要性。
+
+Raft一致性算法论文的中文翻译
+https://github.com/maemual/raft-zh_cn/blob/master/raft-zh_cn.md
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237.md"
similarity index 97%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237.md"
index c84f6cb6..0d5c6248 100644
--- "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237.md"	
@@ -1,44 +1,44 @@
-## 分布式系统
-分布式系统（distributed system）由多台计算机和通信的 **软件组件** 通过计算机网络连接（本地网络或广域网）组成。
-
-分布式系统是建立在网络之上的软件系统。正是因为软件的特性，所以分布式系统具有高度的内聚性和透明性。
-
-因此，网络和分布式系统之间的区别更多的在于高层软件（特别是操作系统），而不是硬件。
-
-分布式系统可以应用在不同的平台上如：Pc、工作站、局域网和广域网上等。
-
-
-## 分布式计算的优点
-`可靠性（容错） `：
-分布式计算系统中的一个重要的优点是可靠性。一台服务器的系统崩溃并不影响到其余的服务器。
-
-`可扩展性`：
-在分布式计算系统可以根据需要增加更多的机器。
-
-`资源共享`：
-共享数据是必不可少的应用，如银 行，预订系统。
-
-`灵活性`：
-由于该系统是非常灵活的，它很容易安装，实施和调试新的服务。
-
-`更快的速度`：
-分布式计算系统可以有多台计算机的计算能力，使得它比其他系统有更快的处理速度。
-
-`开放系统`：
-由于它是开放的系统，本地或者远程都可以访问到该服务。
-
-`更高的性能`：
-相较于集中式计算机网络集群可以提供更高的性能（及更好的性价比）。
-
-## 分布式计算的缺点
-`故障排除`：
-故障排除和诊断问题。
-
-`软件`：
-更少的软件支持是分布式计算系统的主要缺点。
-
-`网络`：
-网络基础设施的问题，包括：传输问题，高负载，信息丢失等。
-
-`安全性`：
-开放系统的特性让分布式计算系统存在着数据的安全性和共享的风险等问题。
+## 分布式系统
+分布式系统（distributed system）由多台计算机和通信的 **软件组件** 通过计算机网络连接（本地网络或广域网）组成。
+
+分布式系统是建立在网络之上的软件系统。正是因为软件的特性，所以分布式系统具有高度的内聚性和透明性。
+
+因此，网络和分布式系统之间的区别更多的在于高层软件（特别是操作系统），而不是硬件。
+
+分布式系统可以应用在不同的平台上如：Pc、工作站、局域网和广域网上等。
+
+
+## 分布式计算的优点
+`可靠性（容错） `：
+分布式计算系统中的一个重要的优点是可靠性。一台服务器的系统崩溃并不影响到其余的服务器。
+
+`可扩展性`：
+在分布式计算系统可以根据需要增加更多的机器。
+
+`资源共享`：
+共享数据是必不可少的应用，如银 行，预订系统。
+
+`灵活性`：
+由于该系统是非常灵活的，它很容易安装，实施和调试新的服务。
+
+`更快的速度`：
+分布式计算系统可以有多台计算机的计算能力，使得它比其他系统有更快的处理速度。
+
+`开放系统`：
+由于它是开放的系统，本地或者远程都可以访问到该服务。
+
+`更高的性能`：
+相较于集中式计算机网络集群可以提供更高的性能（及更好的性价比）。
+
+## 分布式计算的缺点
+`故障排除`：
+故障排除和诊断问题。
+
+`软件`：
+更少的软件支持是分布式计算系统的主要缺点。
+
+`网络`：
+网络基础设施的问题，包括：传输问题，高负载，信息丢失等。
+
+`安全性`：
+开放系统的特性让分布式计算系统存在着数据的安全性和共享的风险等问题。
diff --git "a/15 - Distributed/\345\210\206\345\270\203\345\274\217\351\224\201.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\351\224\201.md"
similarity index 100%
rename from "15 - Distributed/\345\210\206\345\270\203\345\274\217\351\224\201.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\210\206\345\270\203\345\274\217\351\224\201.md"
diff --git "a/15 - Distributed/\345\271\202\347\255\211\346\200\247.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\271\202\347\255\211\346\200\247.md"
similarity index 97%
rename from "15 - Distributed/\345\271\202\347\255\211\346\200\247.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\345\271\202\347\255\211\346\200\247.md"
index 76fab001..bb72695b 100644
--- "a/15 - Distributed/\345\271\202\347\255\211\346\200\247.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\345\271\202\347\255\211\346\200\247.md"	
@@ -1,45 +1,45 @@
-https://www.cnblogs.com/vveiliang/p/6643874.html
-
-
-在编程中一个幂等操作的特点是其 **任意多次执行所产生的影响均与一次执行的影响相同**。
-
-幂等函数，或幂等方法，是指可以使用相同参数重复执行，并能获得相同结果的函数。这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变。
-
-在事务提交失败会重复提交达到最大重复次数时返回失败的 设计中  保持幂等性是尤为重要的
-
-
-例子：
-
-### 方法一、单次支付请求，也就是直接支付了，不需要额外的数据库操作了，这个时候发起异步请求创建一个唯一的ticketId，就是门票，这张门票只能使用一次就作废，具体步骤如下：
-
-1. 异步请求获取门票
-
-2. 调用支付，传入门票
-
-3. 根据门票ID查询此次操作是否存在，如果存在则表示该操作已经执行过，直接返回结果；如果不存在，支付扣款，保存结果
-
-4. 返回结果到客户端
-
-如果步骤4通信失败，用户再次发起请求，那么最终结果还是一样的.
-
-### 方法二、分布式环境下各个服务相互调用
-
-这边就要举例我们的系统了，我们支付的时候先要扣款，然后更新订单，这个地方就涉及到了订单服务以及支付服务了。
-
-用户调用支付，扣款成功后，更新对应订单状态，然后再保存流水。
-
-而在这个地方就没必要使用门票ticketId了，因为会比较闲的麻烦
-
-（支付状态：未支付，已支付）
-
-步骤：
-
-1. 查询订单支付状态
-
-2. 如果已经支付，直接返回结果
-
-3. 如果未支付，则支付扣款并且保存流水
-
-4. 返回支付结果
-
-如果步骤4通信失败，用户再次发起请求，那么最终结果还是一样的
+https://www.cnblogs.com/vveiliang/p/6643874.html
+
+
+在编程中一个幂等操作的特点是其 **任意多次执行所产生的影响均与一次执行的影响相同**。
+
+幂等函数，或幂等方法，是指可以使用相同参数重复执行，并能获得相同结果的函数。这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变。
+
+在事务提交失败会重复提交达到最大重复次数时返回失败的 设计中  保持幂等性是尤为重要的
+
+
+例子：
+
+### 方法一、单次支付请求，也就是直接支付了，不需要额外的数据库操作了，这个时候发起异步请求创建一个唯一的ticketId，就是门票，这张门票只能使用一次就作废，具体步骤如下：
+
+1. 异步请求获取门票
+
+2. 调用支付，传入门票
+
+3. 根据门票ID查询此次操作是否存在，如果存在则表示该操作已经执行过，直接返回结果；如果不存在，支付扣款，保存结果
+
+4. 返回结果到客户端
+
+如果步骤4通信失败，用户再次发起请求，那么最终结果还是一样的.
+
+### 方法二、分布式环境下各个服务相互调用
+
+这边就要举例我们的系统了，我们支付的时候先要扣款，然后更新订单，这个地方就涉及到了订单服务以及支付服务了。
+
+用户调用支付，扣款成功后，更新对应订单状态，然后再保存流水。
+
+而在这个地方就没必要使用门票ticketId了，因为会比较闲的麻烦
+
+（支付状态：未支付，已支付）
+
+步骤：
+
+1. 查询订单支付状态
+
+2. 如果已经支付，直接返回结果
+
+3. 如果未支付，则支付扣款并且保存流水
+
+4. 返回支付结果
+
+如果步骤4通信失败，用户再次发起请求，那么最终结果还是一样的
diff --git "a/15 - Distributed/\350\264\237\350\275\275\345\235\207\350\241\241/\346\200\273\347\273\223\344\270\216\346\200\235\350\200\203.txt" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\350\264\237\350\275\275\345\235\207\350\241\241/\346\200\273\347\273\223\344\270\216\346\200\235\350\200\203.txt"
similarity index 95%
rename from "15 - Distributed/\350\264\237\350\275\275\345\235\207\350\241\241/\346\200\273\347\273\223\344\270\216\346\200\235\350\200\203.txt"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\350\264\237\350\275\275\345\235\207\350\241\241/\346\200\273\347\273\223\344\270\216\346\200\235\350\200\203.txt"
index 214733ae..cc298f0f 100644
--- "a/15 - Distributed/\350\264\237\350\275\275\345\235\207\350\241\241/\346\200\273\347\273\223\344\270\216\346\200\235\350\200\203.txt"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\350\264\237\350\275\275\345\235\207\350\241\241/\346\200\273\347\273\223\344\270\216\346\200\235\350\200\203.txt"	
@@ -1,8 +1,8 @@
-http://www.cnblogs.com/xybaby/p/7867735.html
-
-
-算法
-
-轮训、随机、哈希
-加权轮训、加权随机、一致性hash
+http://www.cnblogs.com/xybaby/p/7867735.html
+
+
+算法
+
+轮训、随机、哈希
+加权轮训、加权随机、一致性hash
 最少连接算法（least connection）
\ No newline at end of file
diff --git "a/15 - Distributed/\351\253\230\345\271\266\345\217\221\347\263\273\347\273\237\344\271\213\351\231\220\346\265\201\347\211\271\346\212\200.md" "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\351\253\230\345\271\266\345\217\221\347\263\273\347\273\237\344\271\213\351\231\220\346\265\201\347\211\271\346\212\200.md"
similarity index 98%
rename from "15 - Distributed/\351\253\230\345\271\266\345\217\221\347\263\273\347\273\237\344\271\213\351\231\220\346\265\201\347\211\271\346\212\200.md"
rename to "15 - Distributed \345\210\206\345\270\203\345\274\217/\351\253\230\345\271\266\345\217\221\347\263\273\347\273\237\344\271\213\351\231\220\346\265\201\347\211\271\346\212\200.md"
index d3f0d5f2..d63018df 100644
--- "a/15 - Distributed/\351\253\230\345\271\266\345\217\221\347\263\273\347\273\237\344\271\213\351\231\220\346\265\201\347\211\271\346\212\200.md"	
+++ "b/15 - Distributed \345\210\206\345\270\203\345\274\217/\351\253\230\345\271\266\345\217\221\347\263\273\347\273\237\344\271\213\351\231\220\346\265\201\347\211\271\346\212\200.md"	
@@ -1,752 +1,752 @@
-转 http://jinnianshilongnian.iteye.com/blog/2305117
-
-在开发高并发系统时有三把利器用来保护系统：`缓存`、`降级`和`限流`。
-
-* **缓存** 的目的是提升系统访问速度和增大系统能处理的容量，可谓是抗高并发流量的银弹；
-
-* **降级** 是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉，待高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如稀缺资源（秒杀、抢购）、写服务（如评论、下单）、频繁的复杂查询（评论的最后几页），因此需有一种手段来限制这些场景的并发/请求量，即限流。
-
-* **限流** 的目的是通过对并发访问/请求进行限速或者一个时间窗口内的的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务（定向到错误页或告知资源没有了）、排队或等待（比如秒杀、评论、下单）、降级（返回兜底数据或默认数据，如商品详情页库存默认有货）。
-
-一般开发高并发系统 **常见的限流** 有：
-* 限制总并发数（比如数据库连接池、线程池）
-* 限制瞬时并发数（如nginx的limit_conn模块，用来限制瞬时并发连接数）
-* 限制时间窗口内的平均速率（如Guava的RateLimiter、nginx的limit_req模块，限制每秒的平均速率）；
-* 其他还有如限制远程接口调用速率、限制MQ的消费速率。
-* 另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。
-
-
-先有缓存这个银弹，后有限流来应对618、双十一高并发流量，在处理高并发问题上可以说是如虎添翼，不用担心瞬间流量导致系统挂掉或雪崩，最终做到有损服务而不是不服务；限流需要评估好，不可乱用，否则会正常流量出现一些奇怪的问题而导致用户抱怨。
-
-在实际应用时也不要太纠结算法问题，因为一些限流算法实现是一样的只是描述不一样；具体使用哪种限流技术还是要根据实际场景来选择，不要一味去找最佳模式，白猫黑猫能解决问题的就是好猫。
-
-因在实际工作中遇到过许多人来问如何进行限流，因此本文会详细介绍各种限流手段。那么接下来我们从`限流算法`、`应用级限流`、`分布式限流`、`接入层限流`来详细学习下限流技术手段。
-
-### 1. 限流算法
-
-常见的限流算法有：`令牌桶`、`漏桶`。`计数`器也可以进行粗暴限流实现。
-
-#### 1.1 令牌桶算法
-
-令牌桶算法是一个存放固定容量令牌的桶，按照固定速率往桶里添加令牌。令牌桶算法的描述如下：
-
-* 假设限制2r/s，则按照500毫秒的固定速率往桶中添加令牌；
-
-* 桶中最多存放b个令牌，当桶满时，新添加的令牌被丢弃或拒绝；
-
-* 当一个n个字节大小的数据包到达，将从桶中删除n个令牌，接着数据包被发送到网络上；
-
-* 如果桶中的令牌不足n个，则不会删除令牌，且该数据包将被限流（要么丢弃，要么缓冲区等待）。
-
-<div align="center><img src="img/xl1.png"></div>
-
-#### 1.2 漏桶算法
-
-漏桶作为计量工具（The Leaky Bucket Algorithm as a Meter）时，可以用于流量整形（Traffic Shaping）和流量控制（TrafficPolicing），漏桶算法的描述如下：
-
-一个固定容量的漏桶，按照常量固定速率流出水滴；
-
-如果桶是空的，则不需流出水滴；
-
-可以以任意速率流入水滴到漏桶；
-
-如果流入水滴超出了桶的容量，则流入的水滴溢出了（被丢弃），而漏桶容量是不变的。
-
-<div align="center><img src="img/xl2.png"></div>
-
-#### 1.3 令牌桶和漏桶对比：
-
-1. 令牌桶是按照固定速率往桶中添加令牌，请求是否被处理需要看桶中令牌是否足够，当令牌数减为零时则拒绝新的请求；
-2. 漏桶则是按照常量固定速率流出请求，流入请求速率任意，当流入的请求数累积到漏桶容量时，则新流入的请求被拒绝；
-3. 令牌桶限制的是平均流入速率（允许突发请求，只要有令牌就可以处理，支持一次拿3个令牌，4个令牌），并允许一定程度突发流量；
-4. 漏桶限制的是常量流出速率（即流出速率是一个固定常量值，比如都是1的速率流出，而不能一次是1，下次又是2），从而平滑突发流入速率；
-5. 令牌桶允许一定程度的突发，而漏桶主要目的是平滑流入速率；
-6. 两个算法实现可以一样，但是方向是相反的，对于相同的参数得到的限流效果是一样的。
-7. 另外有时候我们还使用计数器来进行限流，主要用来限制总并发数，比如数据库连接池、线程池、秒杀的并发数；只要全局总请求数或者一定时间段的总请求数设定的阀值则进行限流，是简单粗暴的总数量限流，而不是平均速率限流。
-
-到此基本的算法就介绍完了，接下来我们首先看看应用级限流。
-
-### 2. 应用级限流
-
-#### 2.1 限流总并发/连接/请求数
-
-对于一个应用系统来说一定会有极限并发/请求数，即总有一个TPS/QPS阀值，如果超了阀值则系统就会不响应用户请求或响应的非常慢，因此我们最好进行过载保护，防止大量请求涌入击垮系统。
-
-如果你使用过`Tomcat`，其Connector 其中一种配置有如下几个参数：
-
-`acceptCount`：如果Tomcat的线程都忙于响应，新来的连接会进入队列排队，如果超出排队大小，则拒绝连接；
-
-`maxConnections`： 瞬时最大连接数，超出的会排队等待；
-
-`maxThreads`：Tomcat能启动用来处理请求的最大线程数，如果请求处理量一直远远大于最大线程数则可能会僵死。
-
-详细的配置请参考官方文档。
-
-另外如Mysql（如max_connections）、Redis（如tcp-backlog）都会有类似的限制连接数的配置。
-
-#### 2.2 限流总资源数
-
-如果有的资源是稀缺资源（如数据库连接、线程），而且可能有多个系统都会去使用它，那么需要限制应用；
-可以使用池化技术来限制总资源数：连接池、线程池。
-比如分配给每个应用的数据库连接是100，那么本应用最多可以使用100个资源，超出了可以等待或者抛异常。
-
-#### 2.3 限流某个接口的总并发/请求数
-
-如果接口可能会有突发访问情况，但又担心访问量太大造成崩溃，如抢购业务；这个时候就需要限制这个接口的总并发/请求数总请求数了；因为粒度比较细，可以为每个接口都设置相应的阀值。可以使用Java中的`AtomicLong`进行限流：
-```java
-try {
-   if(atomic.incrementAndGet() > 限流数) {
-       //拒绝请求
-  }
-   //处理请求
-} finally {
-   atomic.decrementAndGet();
-}
-```
-适合对业务无损的服务或者需要过载保护的服务进行限流，如抢购业务，超出了大小要么让用户排队，要么告诉用户没货了，对用户来说是可以接受的。而一些开放平台也会限制用户调用某个接口的试用请求量，也可以用这种计数器方式实现。这种方式也是简单粗暴的限流，没有平滑处理，需要根据实际情况选择使用；
-
-#### 2.4 限流某个接口的时间窗请求数
-
-即一个时间窗口内的请求数，如想`限制某个接口/服务每秒/每分钟/每天的请求数/调用量`。
-如一些基础服务会被很多其他系统调用，比如商品详情页服务会调用基础商品服务调用，但是怕因为更新量比较大将基础服务打挂，这时我们要对每秒/每分钟的调用量进行限速；一种实现方式如下所示：
-```java
-LoadingCache<Long, AtomicLong> counter =
-       CacheBuilder.newBuilder()
-               .expireAfterWrite(2, TimeUnit.SECONDS)
-               .build(new CacheLoader<Long, AtomicLong>() {
-                   @Override
-                   public AtomicLong load(Long seconds) throws Exception {
-                       return new AtomicLong(0);
-                   }
-               });
-long limit = 1000;
-while(true) {
-   //得到当前秒
-   long currentSeconds = System.currentTimeMillis() / 1000;
-   if(counter.get(currentSeconds).incrementAndGet() > limit) {
-       System.out.println("限流了:" + currentSeconds);
-       continue;
-   }
-   //业务处理
-}
-```
-我们使用`Guava`的`Cache`来存储计数器，过期时间设置为2秒（保证1秒内的计数器是有的），然后我们获取当前时间戳然后取秒数来作为KEY进行计数统计和限流，这种方式也是简单粗暴，刚才说的场景够用了。
-
-#### 2.5 平滑限流某个接口的请求数
-
-之前的限流方式都不能很好地应对突发请求，即瞬间请求可能都被允许从而导致一些问题；因此在一些场景中需要对突发请求进行整形，整形为平均速率请求处理（比如5r/s，则每隔200毫秒处理一个请求，平滑了速率）。这个时候有两种算法满足我们的场景：令牌桶和漏桶算法。Guava框架提供了令牌桶算法实现，可直接拿来使用。
-
-Guava RateLimiter提供了令牌桶算法实现：`平滑突发限流(SmoothBursty)`和`平滑预热限流(SmoothWarmingUp)`实现。
-
-##### 2.5.1 SmoothBursty
-
-```java
-RateLimiter limiter = RateLimiter.create(5);
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-````
-将得到类似如下的输出：
-```
-0.0
-0.198239
-0.196083
-0.200609
-0.199599
-0.19961
-```
-1、RateLimiter.create(5) 表示桶容量为5且每秒新增5个令牌，即每隔200毫秒新增一个令牌；
-
-2、limiter.acquire()表示消费一个令牌，如果当前桶中有足够令牌则成功（返回值为0），如果桶中没有令牌则暂停一段时间，比如发令牌间隔是200毫秒，则等待200毫秒后再去消费令牌（如上测试用例返回的为0.198239，差不多等待了200毫秒桶中才有令牌可用），这种实现将突发请求速率平均为了固定请求速率。
-
-再看一个突发示例：
-```java
-RateLimiter limiter = RateLimiter.create(5);
-System.out.println(limiter.acquire(5));
-System.out.println(limiter.acquire(1));
-System.out.println(limiter.acquire(1));
-```
-将得到类似如下的输出：
-```
-0.0
-0.98745
-0.183553
-0.199909
-```
-limiter.acquire(5)表示桶的容量为5且每秒新增5个令牌，令牌桶算法允许一定程度的突发，所以可以一次性消费5个令牌，但接下来的limiter.acquire(1)将等待差不多1秒桶中才能有令牌，且接下来的请求也整形为固定速率了。
-```java
-RateLimiter limiter = RateLimiter.create(5);
-System.out.println(limiter.acquire(10));
-System.out.println(limiter.acquire(1));
-System.out.println(limiter.acquire(1));
-```
-将得到类似如下的输出：
-```
-0.0
-1.997428
-0.192273
-0.200616
-```
-同上边的例子类似，第一秒突发了10个请求，令牌桶算法也允许了这种突发（允许消费未来的令牌），但接下来的limiter.acquire(1)将等待差不多2秒桶中才能有令牌，且接下来的请求也整形为固定速率了。
-
-
-接下来再看一个突发的例子：
-```java
-RateLimiter limiter = RateLimiter.create(2);
-System.out.println(limiter.acquire());
-Thread.sleep(2000L);
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-System.out.println(limiter.acquire());
-```
-将得到类似如下的输出：
-```
-0.0
-0.0
-0.0
-0.0
-0.499876
-0.495799
-```
-1、创建了一个桶容量为2且每秒新增2个令牌；
-
-2、首先调用limiter.acquire()消费一个令牌，此时令牌桶可以满足（返回值为0）；
-
-3、然后线程暂停2秒，接下来的两个limiter.acquire()都能消费到令牌，第三个limiter.acquire()也同样消费到了令牌，到第四个时就需要等待500毫秒了。
-
-此处可以看到我们设置的桶容量为2（即允许的突发量），这是因为SmoothBursty中有一个参数：最大突发秒数（maxBurstSeconds）默认值是1s，突发量/桶容量=速率*maxBurstSeconds，所以本示例桶容量/突发量为2，例子中前两个是消费了之前积攒的突发量，而第三个开始就是正常计算的了。令牌桶算法允许将一段时间内没有消费的令牌暂存到令牌桶中，留待未来使用，并允许未来请求的这种突发。
-
-
-SmoothBursty通过平均速率和最后一次新增令牌的时间计算出下次新增令牌的时间的，另外需要一个桶暂存一段时间内没有使用的令牌（即可以突发的令牌数）。另外RateLimiter还提供了tryAcquire方法来进行无阻塞或可超时的令牌消费。
-
-
-因为SmoothBursty允许一定程度的突发，会有人担心如果允许这种突发，假设突然间来了很大的流量，那么系统很可能扛不住这种突发。因此需要一种平滑速率的限流工具，从而系统冷启动后慢慢的趋于平均固定速率（即刚开始速率小一些，然后慢慢趋于我们设置的固定速率）。Guava也提供了SmoothWarmingUp来实现这种需求，其可以认为是漏桶算法，但是在某些特殊场景又不太一样。
-
-##### 2.5.2 SmoothWarmingUp
-
-SmoothWarmingUp创建方式：RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit)
-
-permitsPerSecond表示每秒新增的令牌数，warmupPeriod表示在从冷启动速率过渡到平均速率的时间间隔。
-
-示例如下：
-```java
-RateLimiter limiter = RateLimiter.create(5, 1000, TimeUnit.MILLISECONDS);
-for(int i = 1; i < 5;i++) {
-   System.out.println(limiter.acquire());
-}
-Thread.sleep(1000L);
-for(int i = 1; i < 5;i++) {
-   System.out.println(limiter.acquire());
-}
-```
-将得到类似如下的输出：
-```
-0.0
-0.51767
-0.357814
-0.219992
-0.199984
-0.0
-0.360826
-0.220166
-0.199723
-0.199555
-```
-速率是梯形上升速率的，也就是说冷启动时会以一个比较大的速率慢慢到平均速率；然后趋于平均速率（梯形下降到平均速率）。可以通过调节warmupPeriod参数实现一开始就是平滑固定速率。
-
-到此应用级限流的一些方法就介绍完了。假设将应用部署到多台机器，应用级限流方式只是单应用内的请求限流，不能进行全局限流。因此我们需要分布式限流和接入层限流来解决这个问题。
-
-### 3. 分布式限流
-
-分布式限流最关键的是要将限流服务做成原子化，而解决方案可以使使用`redis+lua`或者`nginx+lua`技术进行实现，通过这两种技术可以实现的高并发和高性能。
-
-首先我们来使用redis+lua实现时间窗内某个接口的请求数限流，实现了该功能后可以改造`为限流总并发/请求数和限制总资源数`。Lua本身就是一种编程语言，也可以使用它实现复杂的令牌桶或漏桶算法。
-
-#### 3.1 redis+lua实现中的lua脚本：
-```lua
-local key = KEYS[1] --限流KEY（一秒一个）
-local limit = tonumber(ARGV[1]) --限流大小
-local current = tonumber(redis.call("INCRBY", key, "1")) --请求数+1
-if current > limit then --如果超出限流大小
-    return 0
-elseif current == 1 then --只有第一次访问需要设置2秒的过期时间
-    redis.call("expire", key,"2")
-end
-return 1
-```
-如上操作因是在一个lua脚本中，又因Redis是单线程模型，因此是线程安全的。如上方式有一个缺点就是当达到限流大小后还是会递增的，可以改造成如下方式实现：
-```lua
-local key = KEYS[1] --限流KEY（一秒一个）
-local limit = tonumber(ARGV[1]) --限流大小
-local current = tonumber(redis.call('get', key) or "0")
-if current + 1 > limit then --如果超出限流大小
-    return 0
-else --请求数+1，并设置2秒过期
-    redis.call("INCRBY", key,"1")
-    redis.call("expire", key,"2")
-    return 1
-end
-```
-如下是Java中判断是否需要限流的代码：
-```java
-public static boolean acquire() throws Exception {
-String luaScript = Files.toString(new File("limit.lua"), Charset.defaultCharset());
-Jedis jedis = new Jedis("192.168.147.52", 6379);
-String key = "ip:" + System.currentTimeMillis()/ 1000; //此处将当前时间戳取秒数
-Stringlimit = "3"; //限流大小
-return (Long)jedis.eval(luaScript,Lists.newArrayList(key), Lists.newArrayList(limit)) == 1;
-}
-```
-因为Redis的限制（Lua中有写操作不能使用带随机性质的读操作，如TIME）不能在Redis Lua中使用TIME获取时间戳，因此只好从应用获取然后传入，在某些极端情况下（机器时钟不准的情况下），限流会存在一些小问题。
-
-例子：Java并发：分布式应用限流 Redis + Lua 实践 https://juejin.im/post/5b7625e051882533122e1fc4?utm_source=gold_browser_extension
-
-#### 3.2 使用Nginx+Lua实现的Lua脚本：
-```lua
-local locks = require "resty.lock"
-local function acquire()
-    local lock =locks:new("locks")
-    local elapsed, err =lock:lock("limit_key") --互斥锁
-    local limit_counter =ngx.shared.limit_counter --计数器
-    local key = "ip:" ..os.time()
-    local limit = 5 --限流大小
-    local current =limit_counter:get(key)
-
-    if current ~= nil and current + 1> limit then --如果超出限流大小
-        lock:unlock()
-        return 0
-    end
-    if current == nil then
-        limit_counter:set(key, 1, 1) --第一次需要设置过期时间，设置key的值为1，过期时间为1秒
-    else
-        limit_counter:incr(key, 1) --第二次开始加1即可
-    end
-    lock:unlock()
-    return 1
-end
-ngx.print(acquire())
-```
-
-实现中我们需要使用lua-resty-lock互斥锁模块来解决原子性问题(在实际工程中使用时请考虑获取锁的超时问题)，并使用ngx.shared.DICT共享字典来实现计数器。如果需要限流则返回0，否则返回1。使用时需要先定义两个共享字典（分别用来存放锁和计数器数据）：
-
-Java代码
-```java
-http {  
-    ……  
-    lua_shared_dict locks 10m;  
-    lua_shared_dict limit_counter 10m;  
-}  
-```
-有人会纠结如果应用并发量非常大那么redis或者nginx是不是能抗得住；不过这个问题要从多方面考虑：你的流量是不是真的有这么大，是不是可以通过一致性哈希将分布式限流进行分片，是不是可以当并发量太大降级为应用级限流；对策非常多，可以根据实际情况调节；像在京东使用Redis+Lua来限流抢购流量，一般流量是没有问题的。
-
-对于分布式限流目前遇到的场景是业务上的限流，而不是流量入口的限流；流量入口限流应该在接入层完成，而接入层笔者一般使用Nginx。
-
-### 4. 接入层限流
-接入层通常指请求流量的入口，该层的主要目的有：负载均衡、非法请求过滤、请求聚合、缓存、降级、限流、A/B测试、服务质量监控等等，可以参考笔者写的《使用Nginx+Lua(OpenResty)开发高性能Web应用》 http://jinnianshilongnian.iteye.com/blog/2280928。
-
-* 对于Nginx接入层限流可以使用 `Nginx` 自带了两个模块：`连接数限流模块ngx_http_limit_conn_module`和`漏桶算法实现的请求限流模块ngx_http_limit_req_module`。
-* 还可以使用`OpenResty` 提供的 `Lua` 限流模块`lua-resty-limit-traffic`进行更复杂的限流场景。
-
-limit_conn用来对某个KEY对应的总的网络连接数进行限流，可以按照如IP、域名维度进行限流。limit_req用来对某个KEY对应的请求的平均速率进行限流，并有两种用法：平滑模式（delay）和允许突发模式(nodelay)。
-
-#### 4.1 ngx_http_limit_conn_module
-limit_conn是对某个KEY对应的总的网络连接数进行限流。可以按照IP来限制IP维度的总连接数，或者按照服务域名来限制某个域名的总连接数。但是记住不是每一个请求连接都会被计数器统计，只有那些被Nginx处理的且已经读取了整个请求头的请求连接才会被计数器统计。
-
-配置示例：
-```
-http {
-    limit_conn_zone$binary_remote_addr zone=addr:10m;
-    limit_conn_log_level error;
-    limit_conn_status 503;
-    ...
-    server {
-    ...
-    location /limit {
-        limit_conn addr 1;
-    }
-```
-`limit_conn`：要配置存放KEY和计数器的共享内存区域和指定KEY的最大连接数；此处指定的最大连接数是1，表示Nginx最多同时并发处理1个连接；
-`limit_conn_zone`：用来配置限流KEY、及存放KEY对应信息的共享内存区域大小；此处的KEY是“$binary_remote_addr”其表示IP地址，也可以使用如$server_name作为KEY来限制域名级别的最大连接数；
-`limit_conn_status`：配置被限流后返回的状态码，默认返回503；
-`limit_conn_log_level`：配置记录被限流后的日志级别，默认error级别。
-
-#### 4.1.1 limit_conn的主要执行过程如下所示：
-
-* 1、请求进入后首先判断当前limit_conn_zone中相应KEY的连接数是否超出了配置的最大连接数；
-
-* 2.1、如果超过了配置的最大大小，则被限流，返回limit_conn_status定义的错误状态码；
-
-* 2.2、否则相应KEY的连接数加1，并注册请求处理完成的回调函数；
-
-* 3、进行请求处理；
-
-* 4、在结束请求阶段会调用注册的回调函数对相应KEY的连接数减1。
-
-limt_conn可以限流某个KEY的总并发/请求数，KEY可以根据需要变化。
-
-#### 4.1.2 按照IP限制并发连接数配置示例：
-
-首先定义IP维度的限流区域：
-```
-limit_conn_zone $binary_remote_addrzone=perip:10m;
-```
-
-接着在要限流的location中添加限流逻辑：
-```
-location /limit {
-    limit_conn perip 2;
-    echo "123";
-}
-```
-即允许每个IP最大并发连接数为2。
-
-使用AB测试工具进行测试，并发数为5个，总的请求数为5个：
-```
-ab -n 5 -c 5 http://localhost/limit
-````
-将得到如下access.log输出：
-```
-[08/Jun/2016:20:10:51+0800] [1465373451.802] 200
-[08/Jun/2016:20:10:51+0800] [1465373451.803] 200
-[08/Jun/2016:20:10:51 +0800][1465373451.803] 503
-[08/Jun/2016:20:10:51 +0800][1465373451.803] 503
-[08/Jun/2016:20:10:51 +0800][1465373451.803] 503
-```
-此处我们把access log格式设置为log_format main  '[$time_local] [$msec] $status'；分别是“日期 日期秒/毫秒值 响应状态码”。
-
-如果被限流了，则在error.log中会看到类似如下的内容：
-```
-2016/06/08 20:10:51 [error] 5662#0: *5limiting connections by zone "perip", client: 127.0.0.1, server: _,request: "GET /limit HTTP/1.0", host: "localhost"
-```
-#### 4.1.3 按照域名限制并发连接数配置示例：
-
-首先定义域名维度的限流区域：
-
-limit_conn_zone $ server_name zone=perserver:10m;
-接着在要限流的location中添加限流逻辑：
-```
-location /limit {
-    limit_conn perserver 2;
-    echo "123";
-}
-```
-即允许每个域名最大并发请求连接数为2；这样配置可以实现服务器最大连接数限制。
-
-#### 4.2 ngx_http_limit_req_module
-
-limit_req是漏桶算法实现，用于对指定KEY对应的请求进行限流，比如按照IP维度限制请求速率。
-
-配置示例：
-```
-http {
-    limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
-    limit_conn_log_level error;
-    limit_conn_status 503;
-    ...
-    server {
-    ...
-    location /limit {
-        limit_req zone=one burst=5 nodelay;
-    }
-```
-`limit_req`：配置限流区域、桶容量（突发容量，默认0）、是否延迟模式（默认延迟）；
-
-`limit_req_zone`：配置限流KEY、及存放KEY对应信息的共享内存区域大小、固定请求速率；此处指定的KEY是“$binary_remote_addr”表示IP地址；固定请求速率使用rate参数配置，支持10r/s和60r/m，即每秒10个请求和每分钟60个请求，不过最终都会转换为每秒的固定请求速率（10r/s为每100毫秒处理一个请求；60r/m，即每1000毫秒处理一个请求）。
-
-`limit_conn_status`：配置被限流后返回的状态码，默认返回503；
-
-`limit_conn_log_level`：配置记录被限流后的日志级别，默认error级别。
-
-limit_req的主要执行过程如下所示：
-
-1、请求进入后首先判断最后一次请求时间相对于当前时间（第一次是0）是否需要限流，如果需要限流则执行步骤2，否则执行步骤3；
-
-2.1、如果没有配置桶容量（burst），则桶容量为0；按照固定速率处理请求；如果请求被限流，则直接返回相应的错误码（默认503）；
-
-2.2、如果配置了桶容量（burst>0）且延迟模式(没有配置nodelay)；如果桶满了，则新进入的请求被限流；如果没有满则请求会以固定平均速率被处理（按照固定速率并根据需要延迟处理请求，延迟使用休眠实现）；
-
-2.3、如果配置了桶容量（burst>0）且非延迟模式（配置了nodelay）；不会按照固定速率处理请求，而是允许突发处理请求；如果桶满了，则请求被限流，直接返回相应的错误码；
-
-3、如果没有被限流，则正常处理请求；
-
-4、Nginx会在相应时机进行选择一些（3个节点）限流KEY进行过期处理，进行内存回收。
-
-##### 场景2.1测试
-
-首先定义IP维度的限流区域：
-```
-limit_req_zone $binary_remote_addrzone=test:10m rate=500r/s;
-```
-限制为每秒500个请求，固定平均速率为2毫秒一个请求。
-
-接着在要限流的location中添加限流逻辑：
-```
-location /limit {
-    limit_req zone=test;
-    echo "123";
-}
-```
-即桶容量为0（burst默认为0），且延迟模式。
-
-使用AB测试工具进行测试，并发数为2个，总的请求数为10个：
-```
-ab -n 10 -c 2 http://localhost/limit
-```
-
-将得到如下access.log输出：
-```
-[08/Jun/2016:20:25:56+0800] [1465381556.410] 200
-[08/Jun/2016:20:25:56 +0800][1465381556.410] 503
-[08/Jun/2016:20:25:56 +0800][1465381556.411] 503
-[08/Jun/2016:20:25:56+0800] [1465381556.411] 200
-[08/Jun/2016:20:25:56 +0800][1465381556.412] 503
-[08/Jun/2016:20:25:56 +0800][1465381556.412] 503
-```
-
-虽然每秒允许500个请求，但是因为桶容量为0，所以流入的请求要么被处理要么被限流，无法延迟处理；另外平均速率在2毫秒左右，比如1465381556.410和1465381556.411被处理了；有朋友会说这固定平均速率不是1毫秒嘛，其实这是因为实现算法没那么精准造成的。
-
-如果被限流在error.log中会看到如下内容：
-```
-2016/06/08 20:25:56 [error] 6130#0: *1962limiting requests, excess: 1.000 by zone "test", client: 127.0.0.1,server: _, request: "GET /limit HTTP/1.0", host:"localhost"
-```
-
-如果被延迟了在error.log（日志级别要INFO级别）中会看到如下内容：
-```
-2016/06/10 09:05:23 [warn] 9766#0: *97021delaying request, excess: 0.368, by zone "test", client: 127.0.0.1,server: _, request: "GET /limit HTTP/1.0", host:"localhost"
-```
-
-##### 场景2.2测试
-
-首先定义IP维度的限流区域：
-
-limit_req_zone $binary_remote_addr zone=test:10m rate=2r/s;
-为了方便测试设置速率为每秒2个请求，即固定平均速率是500毫秒一个请求。
-
-接着在要限流的location中添加限流逻辑：
-
-location /limit {
-    limit_req zone=test burst=3;
-    echo "123";
-}
-固定平均速率为500毫秒一个请求，通容量为3，如果桶满了新的请求被限流，否则可以进入桶中排队并等待（实现延迟模式）。
-
-为了看出限流效果我们写了一个req.sh脚本：
-```
-ab -c 6 -n 6 http://localhost/limit
-sleep 0.3
-ab -c 6 -n 6 http://localhost/limit
-```
-首先进行6个并发请求6次URL，然后休眠300毫秒，然后再进行6个并发请求6次URL；中间休眠目的是为了能跨越2秒看到效果，如果看不到如下的效果可以调节休眠时间。
-
-
-将得到如下access.log输出：
-```
-[09/Jun/2016:08:46:43+0800] [1465433203.959] 200
-[09/Jun/2016:08:46:43 +0800][1465433203.959] 503
-[09/Jun/2016:08:46:43 +0800][1465433203.960] 503
-[09/Jun/2016:08:46:44+0800] [1465433204.450] 200
-[09/Jun/2016:08:46:44+0800] [1465433204.950] 200
-[09/Jun/2016:08:46:45 +0800][1465433205.453] 200
-
-[09/Jun/2016:08:46:45 +0800][1465433205.766] 503
-[09/Jun/2016:08:46:45 +0800][1465433205.766] 503
-[09/Jun/2016:08:46:45 +0800][1465433205.767] 503
-[09/Jun/2016:08:46:45+0800] [1465433205.950] 200
-[09/Jun/2016:08:46:46+0800] [1465433206.451] 200
-[09/Jun/2016:08:46:46+0800] [1465433206.952] 200
-```
-<div align="center><img src="img/xl3.png"></div>
-
-桶容量为3，即桶中在时间窗口内最多流入3个请求，且按照2r/s的固定速率处理请求（即每隔500毫秒处理一个请求）；桶计算时间窗口（1.5秒）=速率（2r/s）/桶容量(3)，也就是说在这个时间窗口内桶最多暂存3个请求。因此我们要以当前时间往前推1.5秒和1秒来计算时间窗口内的总请求数；另外因为默认是延迟模式，所以时间窗内的请求要被暂存到桶中，并以固定平均速率处理请求：
-
-第一轮：有4个请求处理成功了，按照漏桶桶容量应该最多3个才对；这是因为计算算法的问题，第一次计算因没有参考值，所以第一次计算后，后续的计算才能有参考值，因此第一次成功可以忽略；这个问题影响很小可以忽略；而且按照固定500毫秒的速率处理请求。
-
-第二轮：因为第一轮请求是突发来的，差不多都在1465433203.959时间点，只是因为漏桶将速率进行了平滑变成了固定平均速率（每500毫秒一个请求）；而第二轮计算时间应基于1465433203.959；而第二轮突发请求差不多都在1465433205.766时间点，因此计算桶容量的时间窗口应基于1465433203.959和1465433205.766来计算，计算结果为1465433205.766这个时间点漏桶为空了，可以流入桶中3个请求，其他请求被拒绝；又因为第一轮最后一次处理时间是1465433205.453，所以第二轮第一个请求被延迟到了1465433205.950。这里也要注意固定平均速率只是在配置的速率左右，存在计算精度问题，会有一些偏差。
-
-
-
-如果桶容量改为1（burst=1），执行req.sh脚本可以看到如下输出：
-```
-09/Jun/2016:09:04:30+0800] [1465434270.362] 200
-[09/Jun/2016:09:04:30 +0800][1465434270.371] 503
-[09/Jun/2016:09:04:30 +0800] [1465434270.372]503
-[09/Jun/2016:09:04:30 +0800][1465434270.372] 503
-[09/Jun/2016:09:04:30 +0800][1465434270.372] 503
-[09/Jun/2016:09:04:30+0800] [1465434270.864] 200
-
-[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
-[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
-[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
-[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
-[09/Jun/2016:09:04:31 +0800][1465434271.179] 503
-[09/Jun/2016:09:04:31+0800] [1465434271.366] 200
-```
-桶容量为1，按照每1000毫秒一个请求的固定平均速率处理请求。
-
-##### 场景2.3测试
-
-首先定义IP维度的限流区域：
-
-limit_req_zone $binary_remote_addr zone=test:10m rate=2r/s;
-为了方便测试配置为每秒2个请求，固定平均速率是500毫秒一个请求。
-
-
-
-接着在要限流的location中添加限流逻辑：
-
-location /limit {
-    limit_req zone=test burst=3 nodelay;
-    echo "123";
-}
-桶容量为3，如果桶满了直接拒绝新请求，且每秒2最多两个请求，桶按照固定500毫秒的速率以nodelay模式处理请求。
-
-
-
-为了看到限流效果我们写了一个req.sh脚本：
-``` sh
-ab -c 6 -n 6 http://localhost/limit
-sleep 1
-ab -c 6 -n 6 http://localhost/limit
-sleep 0.3
-ab -c 6 -n 6 http://localhost/limit
-sleep 0.3
-ab -c 6 -n 6 http://localhost/limit
-sleep 0.3
-ab -c 6 -n 6 http://localhost/limit
-sleep 2
-ab -c 6 -n 6 http://localhost/limit
-```
-
-将得到类似如下access.log输出：
-```
-[09/Jun/2016:14:30:11+0800] [1465453811.754] 200
-[09/Jun/2016:14:30:11+0800] [1465453811.755] 200
-[09/Jun/2016:14:30:11+0800] [1465453811.755] 200
-[09/Jun/2016:14:30:11+0800] [1465453811.759] 200
-[09/Jun/2016:14:30:11 +0800][1465453811.759] 503
-[09/Jun/2016:14:30:11 +0800][1465453811.759] 503
-
-[09/Jun/2016:14:30:12+0800] [1465453812.776] 200
-[09/Jun/2016:14:30:12+0800] [1465453812.776] 200
-[09/Jun/2016:14:30:12 +0800][1465453812.776] 503
-[09/Jun/2016:14:30:12 +0800][1465453812.777] 503
-[09/Jun/2016:14:30:12 +0800][1465453812.777] 503
-[09/Jun/2016:14:30:12 +0800][1465453812.777] 503
-
-[09/Jun/2016:14:30:13 +0800] [1465453813.095]503
-[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.098] 503
-
-[09/Jun/2016:14:30:13+0800] [1465453813.425] 200
-[09/Jun/2016:14:30:13 +0800][1465453813.425] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.425] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.426] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.426] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.426] 503
-
-[09/Jun/2016:14:30:13+0800] [1465453813.754] 200
-[09/Jun/2016:14:30:13 +0800][1465453813.755] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.755] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.756] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.756] 503
-[09/Jun/2016:14:30:13 +0800][1465453813.756] 503
-
-[09/Jun/2016:14:30:15+0800] [1465453815.278] 200
-[09/Jun/2016:14:30:15+0800] [1465453815.278] 200
-[09/Jun/2016:14:30:15+0800] [1465453815.278] 200
-[09/Jun/2016:14:30:15 +0800][1465453815.278] 503
-[09/Jun/2016:14:30:15 +0800][1465453815.279] 503
-[09/Jun/2016:14:30:15 +0800][1465453815.279] 503
-
-[09/Jun/2016:14:30:17+0800] [1465453817.300] 200
-[09/Jun/2016:14:30:17+0800] [1465453817.300] 200
-[09/Jun/2016:14:30:17+0800] [1465453817.300] 200
-[09/Jun/2016:14:30:17+0800] [1465453817.301] 200
-[09/Jun/2016:14:30:17 +0800][1465453817.301] 503
-[09/Jun/2016:14:30:17 +0800][1465453817.301] 503
-```
-<div align="center><img src="img/xl4.png"></div>
-
-桶容量为3（，即桶中在时间窗口内最多流入3个请求，且按照2r/s的固定速率处理请求（即每隔500毫秒处理一个请求）；桶计算时间窗口（1.5秒）=速率（2r/s）/桶容量(3)，也就是说在这个时间窗口内桶最多暂存3个请求。因此我们要以当前时间往前推1.5秒和1秒来计算时间窗口内的总请求数；另外因为配置了nodelay，是非延迟模式，所以允许时间窗内突发请求的；另外从本示例会看出两个问题：
-
-第一轮和第七轮：有4个请求处理成功了；这是因为计算算法的问题，本示例是如果2秒内没有请求，然后接着突然来了很多请求，第一次计算的结果将是不正确的；这个问题影响很小可以忽略；
-
-第五轮：1.0秒计算出来是3个请求；此处也是因计算精度的问题，也就是说limit_req实现的算法不是非常精准的，假设此处看成相对于2.75的话，1.0秒内只有1次请求，所以还是允许1次请求的。
-
-
-
-如果限流出错了，可以配置错误页面：
-
-proxy_intercept_errors on;
-recursive_error_pages on;
-error_page 503 //www.jd.com/error.aspx;
-limit_conn_zone/limit_req_zone定义的内存不足，则后续的请求将一直被限流，所以需要根据需求设置好相应的内存大小。
-
-此处的限流都是单Nginx的，假设我们接入层有多个nginx，此处就存在和应用级限流相同的问题；那如何处理呢？一种解决办法：建立一个负载均衡层将按照限流KEY进行一致性哈希算法将请求哈希到接入层Nginx上，从而相同KEY的将打到同一台接入层Nginx上；另一种解决方案就是使用Nginx+Lua（OpenResty）调用分布式限流逻辑实现。
-
-#### 4.3 lua-resty-limit-traffic
-之前介绍的两个模块使用上比较简单，指定KEY、指定限流速率等就可以了，如果我们想根据实际情况变化KEY、变化速率、变化桶大小等这种动态特性，使用标准模块就很难去实现了，因此我们需要一种可编程来解决我们问题；而OpenResty提供了lua限流模块lua-resty-limit-traffic，通过它可以按照更复杂的业务逻辑进行动态限流处理了。其提供了limit.conn和limit.req实现，算法与nginx limit_conn和limit_req是一样的。
-
-此处我们来实现ngx_http_limit_req_module中的【场景2.2测试】，不要忘记下载lua-resty-limit-traffic模块并添加到OpenResty的lualib中。
-
-配置用来存放限流用的共享字典：
-
-lua_shared_dict limit_req_store 100m;
-
-
-以下是实现【场景2.2测试】的限流代码limit_req.lua：
-```
-local limit_req = require "resty.limit.req"
-local rate = 2 --固定平均速率 2r/s
-local burst = 3 --桶容量
-local error_status = 503
-local nodelay = false --是否需要不延迟处理
-local lim, err = limit_req.new("limit_req_store", rate, burst)
-if not lim then --没定义共享字典
-    ngx.exit(error_status)
-end
-local key = ngx.var.binary_remote_addr --IP维度的限流
---流入请求，如果请求需要被延迟则delay > 0
-local delay, err = lim:incoming(key, true)
-if not delay and err == "rejected" then --超出桶大小了
-    ngx.exit(error_status)
-end
-if delay > 0 then --根据需要决定是延迟或者不延迟处理
-    if nodelay then
-        --直接突发处理了
-    else
-        ngx.sleep(delay) --延迟处理
-    end
-end
-```
-即限流逻辑再nginx access阶段被访问，如果不被限流继续后续流程；如果需要被限流要么sleep一段时间继续后续流程，要么返回相应的状态码拒绝请求。
-
-在分布式限流中我们使用了简单的Nginx+Lua进行分布式限流，有了这个模块也可以使用这个模块来实现分布式限流。
-
-另外在使用Nginx+Lua时也可以获取ngx.var.connections_active进行过载保护，即如果当前活跃连接数超过阈值进行限流保护。
-```
-if tonumber(ngx.var.connections_active) >= tonumber(limit) then
-    //限流
-end
-```
-nginx也提供了limit_rate用来对流量限速，如limit_rate 50k，表示限制下载速度为50k。
-
-到此笔者在工作中涉及的限流用法就介绍完，这些算法中有些允许突发，有些会整形为平滑，有些计算算法简单粗暴；其中令牌桶算法和漏桶算法实现上是类似的，只是表述的方向不太一样，对于业务来说不必刻意去区分它们；因此需要根据实际场景来决定如何限流，最好的算法不一定是最适用的。
-
-### 参考资料
-
-https://en.wikipedia.org/wiki/Token_bucket
-https://en.wikipedia.org/wiki/Leaky_bucket
-http://redis.io/commands/incr
-http://nginx.org/en/docs/http/ngx_http_limit_req_module.html
-http://nginx.org/en/docs/http/ngx_http_limit_conn_module.html
-https://github.com/openresty/lua-resty-limit-traffic
-http://nginx.org/en/docs/http/ngx_http_core_module.html#limit_rate
+转 http://jinnianshilongnian.iteye.com/blog/2305117
+
+在开发高并发系统时有三把利器用来保护系统：`缓存`、`降级`和`限流`。
+
+* **缓存** 的目的是提升系统访问速度和增大系统能处理的容量，可谓是抗高并发流量的银弹；
+
+* **降级** 是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉，待高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如稀缺资源（秒杀、抢购）、写服务（如评论、下单）、频繁的复杂查询（评论的最后几页），因此需有一种手段来限制这些场景的并发/请求量，即限流。
+
+* **限流** 的目的是通过对并发访问/请求进行限速或者一个时间窗口内的的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务（定向到错误页或告知资源没有了）、排队或等待（比如秒杀、评论、下单）、降级（返回兜底数据或默认数据，如商品详情页库存默认有货）。
+
+一般开发高并发系统 **常见的限流** 有：
+* 限制总并发数（比如数据库连接池、线程池）
+* 限制瞬时并发数（如nginx的limit_conn模块，用来限制瞬时并发连接数）
+* 限制时间窗口内的平均速率（如Guava的RateLimiter、nginx的limit_req模块，限制每秒的平均速率）；
+* 其他还有如限制远程接口调用速率、限制MQ的消费速率。
+* 另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。
+
+
+先有缓存这个银弹，后有限流来应对618、双十一高并发流量，在处理高并发问题上可以说是如虎添翼，不用担心瞬间流量导致系统挂掉或雪崩，最终做到有损服务而不是不服务；限流需要评估好，不可乱用，否则会正常流量出现一些奇怪的问题而导致用户抱怨。
+
+在实际应用时也不要太纠结算法问题，因为一些限流算法实现是一样的只是描述不一样；具体使用哪种限流技术还是要根据实际场景来选择，不要一味去找最佳模式，白猫黑猫能解决问题的就是好猫。
+
+因在实际工作中遇到过许多人来问如何进行限流，因此本文会详细介绍各种限流手段。那么接下来我们从`限流算法`、`应用级限流`、`分布式限流`、`接入层限流`来详细学习下限流技术手段。
+
+### 1. 限流算法
+
+常见的限流算法有：`令牌桶`、`漏桶`。`计数`器也可以进行粗暴限流实现。
+
+#### 1.1 令牌桶算法
+
+令牌桶算法是一个存放固定容量令牌的桶，按照固定速率往桶里添加令牌。令牌桶算法的描述如下：
+
+* 假设限制2r/s，则按照500毫秒的固定速率往桶中添加令牌；
+
+* 桶中最多存放b个令牌，当桶满时，新添加的令牌被丢弃或拒绝；
+
+* 当一个n个字节大小的数据包到达，将从桶中删除n个令牌，接着数据包被发送到网络上；
+
+* 如果桶中的令牌不足n个，则不会删除令牌，且该数据包将被限流（要么丢弃，要么缓冲区等待）。
+
+<div align="center><img src="img/xl1.png"></div>
+
+#### 1.2 漏桶算法
+
+漏桶作为计量工具（The Leaky Bucket Algorithm as a Meter）时，可以用于流量整形（Traffic Shaping）和流量控制（TrafficPolicing），漏桶算法的描述如下：
+
+一个固定容量的漏桶，按照常量固定速率流出水滴；
+
+如果桶是空的，则不需流出水滴；
+
+可以以任意速率流入水滴到漏桶；
+
+如果流入水滴超出了桶的容量，则流入的水滴溢出了（被丢弃），而漏桶容量是不变的。
+
+<div align="center><img src="img/xl2.png"></div>
+
+#### 1.3 令牌桶和漏桶对比：
+
+1. 令牌桶是按照固定速率往桶中添加令牌，请求是否被处理需要看桶中令牌是否足够，当令牌数减为零时则拒绝新的请求；
+2. 漏桶则是按照常量固定速率流出请求，流入请求速率任意，当流入的请求数累积到漏桶容量时，则新流入的请求被拒绝；
+3. 令牌桶限制的是平均流入速率（允许突发请求，只要有令牌就可以处理，支持一次拿3个令牌，4个令牌），并允许一定程度突发流量；
+4. 漏桶限制的是常量流出速率（即流出速率是一个固定常量值，比如都是1的速率流出，而不能一次是1，下次又是2），从而平滑突发流入速率；
+5. 令牌桶允许一定程度的突发，而漏桶主要目的是平滑流入速率；
+6. 两个算法实现可以一样，但是方向是相反的，对于相同的参数得到的限流效果是一样的。
+7. 另外有时候我们还使用计数器来进行限流，主要用来限制总并发数，比如数据库连接池、线程池、秒杀的并发数；只要全局总请求数或者一定时间段的总请求数设定的阀值则进行限流，是简单粗暴的总数量限流，而不是平均速率限流。
+
+到此基本的算法就介绍完了，接下来我们首先看看应用级限流。
+
+### 2. 应用级限流
+
+#### 2.1 限流总并发/连接/请求数
+
+对于一个应用系统来说一定会有极限并发/请求数，即总有一个TPS/QPS阀值，如果超了阀值则系统就会不响应用户请求或响应的非常慢，因此我们最好进行过载保护，防止大量请求涌入击垮系统。
+
+如果你使用过`Tomcat`，其Connector 其中一种配置有如下几个参数：
+
+`acceptCount`：如果Tomcat的线程都忙于响应，新来的连接会进入队列排队，如果超出排队大小，则拒绝连接；
+
+`maxConnections`： 瞬时最大连接数，超出的会排队等待；
+
+`maxThreads`：Tomcat能启动用来处理请求的最大线程数，如果请求处理量一直远远大于最大线程数则可能会僵死。
+
+详细的配置请参考官方文档。
+
+另外如Mysql（如max_connections）、Redis（如tcp-backlog）都会有类似的限制连接数的配置。
+
+#### 2.2 限流总资源数
+
+如果有的资源是稀缺资源（如数据库连接、线程），而且可能有多个系统都会去使用它，那么需要限制应用；
+可以使用池化技术来限制总资源数：连接池、线程池。
+比如分配给每个应用的数据库连接是100，那么本应用最多可以使用100个资源，超出了可以等待或者抛异常。
+
+#### 2.3 限流某个接口的总并发/请求数
+
+如果接口可能会有突发访问情况，但又担心访问量太大造成崩溃，如抢购业务；这个时候就需要限制这个接口的总并发/请求数总请求数了；因为粒度比较细，可以为每个接口都设置相应的阀值。可以使用Java中的`AtomicLong`进行限流：
+```java
+try {
+   if(atomic.incrementAndGet() > 限流数) {
+       //拒绝请求
+  }
+   //处理请求
+} finally {
+   atomic.decrementAndGet();
+}
+```
+适合对业务无损的服务或者需要过载保护的服务进行限流，如抢购业务，超出了大小要么让用户排队，要么告诉用户没货了，对用户来说是可以接受的。而一些开放平台也会限制用户调用某个接口的试用请求量，也可以用这种计数器方式实现。这种方式也是简单粗暴的限流，没有平滑处理，需要根据实际情况选择使用；
+
+#### 2.4 限流某个接口的时间窗请求数
+
+即一个时间窗口内的请求数，如想`限制某个接口/服务每秒/每分钟/每天的请求数/调用量`。
+如一些基础服务会被很多其他系统调用，比如商品详情页服务会调用基础商品服务调用，但是怕因为更新量比较大将基础服务打挂，这时我们要对每秒/每分钟的调用量进行限速；一种实现方式如下所示：
+```java
+LoadingCache<Long, AtomicLong> counter =
+       CacheBuilder.newBuilder()
+               .expireAfterWrite(2, TimeUnit.SECONDS)
+               .build(new CacheLoader<Long, AtomicLong>() {
+                   @Override
+                   public AtomicLong load(Long seconds) throws Exception {
+                       return new AtomicLong(0);
+                   }
+               });
+long limit = 1000;
+while(true) {
+   //得到当前秒
+   long currentSeconds = System.currentTimeMillis() / 1000;
+   if(counter.get(currentSeconds).incrementAndGet() > limit) {
+       System.out.println("限流了:" + currentSeconds);
+       continue;
+   }
+   //业务处理
+}
+```
+我们使用`Guava`的`Cache`来存储计数器，过期时间设置为2秒（保证1秒内的计数器是有的），然后我们获取当前时间戳然后取秒数来作为KEY进行计数统计和限流，这种方式也是简单粗暴，刚才说的场景够用了。
+
+#### 2.5 平滑限流某个接口的请求数
+
+之前的限流方式都不能很好地应对突发请求，即瞬间请求可能都被允许从而导致一些问题；因此在一些场景中需要对突发请求进行整形，整形为平均速率请求处理（比如5r/s，则每隔200毫秒处理一个请求，平滑了速率）。这个时候有两种算法满足我们的场景：令牌桶和漏桶算法。Guava框架提供了令牌桶算法实现，可直接拿来使用。
+
+Guava RateLimiter提供了令牌桶算法实现：`平滑突发限流(SmoothBursty)`和`平滑预热限流(SmoothWarmingUp)`实现。
+
+##### 2.5.1 SmoothBursty
+
+```java
+RateLimiter limiter = RateLimiter.create(5);
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+````
+将得到类似如下的输出：
+```
+0.0
+0.198239
+0.196083
+0.200609
+0.199599
+0.19961
+```
+1、RateLimiter.create(5) 表示桶容量为5且每秒新增5个令牌，即每隔200毫秒新增一个令牌；
+
+2、limiter.acquire()表示消费一个令牌，如果当前桶中有足够令牌则成功（返回值为0），如果桶中没有令牌则暂停一段时间，比如发令牌间隔是200毫秒，则等待200毫秒后再去消费令牌（如上测试用例返回的为0.198239，差不多等待了200毫秒桶中才有令牌可用），这种实现将突发请求速率平均为了固定请求速率。
+
+再看一个突发示例：
+```java
+RateLimiter limiter = RateLimiter.create(5);
+System.out.println(limiter.acquire(5));
+System.out.println(limiter.acquire(1));
+System.out.println(limiter.acquire(1));
+```
+将得到类似如下的输出：
+```
+0.0
+0.98745
+0.183553
+0.199909
+```
+limiter.acquire(5)表示桶的容量为5且每秒新增5个令牌，令牌桶算法允许一定程度的突发，所以可以一次性消费5个令牌，但接下来的limiter.acquire(1)将等待差不多1秒桶中才能有令牌，且接下来的请求也整形为固定速率了。
+```java
+RateLimiter limiter = RateLimiter.create(5);
+System.out.println(limiter.acquire(10));
+System.out.println(limiter.acquire(1));
+System.out.println(limiter.acquire(1));
+```
+将得到类似如下的输出：
+```
+0.0
+1.997428
+0.192273
+0.200616
+```
+同上边的例子类似，第一秒突发了10个请求，令牌桶算法也允许了这种突发（允许消费未来的令牌），但接下来的limiter.acquire(1)将等待差不多2秒桶中才能有令牌，且接下来的请求也整形为固定速率了。
+
+
+接下来再看一个突发的例子：
+```java
+RateLimiter limiter = RateLimiter.create(2);
+System.out.println(limiter.acquire());
+Thread.sleep(2000L);
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+System.out.println(limiter.acquire());
+```
+将得到类似如下的输出：
+```
+0.0
+0.0
+0.0
+0.0
+0.499876
+0.495799
+```
+1、创建了一个桶容量为2且每秒新增2个令牌；
+
+2、首先调用limiter.acquire()消费一个令牌，此时令牌桶可以满足（返回值为0）；
+
+3、然后线程暂停2秒，接下来的两个limiter.acquire()都能消费到令牌，第三个limiter.acquire()也同样消费到了令牌，到第四个时就需要等待500毫秒了。
+
+此处可以看到我们设置的桶容量为2（即允许的突发量），这是因为SmoothBursty中有一个参数：最大突发秒数（maxBurstSeconds）默认值是1s，突发量/桶容量=速率*maxBurstSeconds，所以本示例桶容量/突发量为2，例子中前两个是消费了之前积攒的突发量，而第三个开始就是正常计算的了。令牌桶算法允许将一段时间内没有消费的令牌暂存到令牌桶中，留待未来使用，并允许未来请求的这种突发。
+
+
+SmoothBursty通过平均速率和最后一次新增令牌的时间计算出下次新增令牌的时间的，另外需要一个桶暂存一段时间内没有使用的令牌（即可以突发的令牌数）。另外RateLimiter还提供了tryAcquire方法来进行无阻塞或可超时的令牌消费。
+
+
+因为SmoothBursty允许一定程度的突发，会有人担心如果允许这种突发，假设突然间来了很大的流量，那么系统很可能扛不住这种突发。因此需要一种平滑速率的限流工具，从而系统冷启动后慢慢的趋于平均固定速率（即刚开始速率小一些，然后慢慢趋于我们设置的固定速率）。Guava也提供了SmoothWarmingUp来实现这种需求，其可以认为是漏桶算法，但是在某些特殊场景又不太一样。
+
+##### 2.5.2 SmoothWarmingUp
+
+SmoothWarmingUp创建方式：RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit)
+
+permitsPerSecond表示每秒新增的令牌数，warmupPeriod表示在从冷启动速率过渡到平均速率的时间间隔。
+
+示例如下：
+```java
+RateLimiter limiter = RateLimiter.create(5, 1000, TimeUnit.MILLISECONDS);
+for(int i = 1; i < 5;i++) {
+   System.out.println(limiter.acquire());
+}
+Thread.sleep(1000L);
+for(int i = 1; i < 5;i++) {
+   System.out.println(limiter.acquire());
+}
+```
+将得到类似如下的输出：
+```
+0.0
+0.51767
+0.357814
+0.219992
+0.199984
+0.0
+0.360826
+0.220166
+0.199723
+0.199555
+```
+速率是梯形上升速率的，也就是说冷启动时会以一个比较大的速率慢慢到平均速率；然后趋于平均速率（梯形下降到平均速率）。可以通过调节warmupPeriod参数实现一开始就是平滑固定速率。
+
+到此应用级限流的一些方法就介绍完了。假设将应用部署到多台机器，应用级限流方式只是单应用内的请求限流，不能进行全局限流。因此我们需要分布式限流和接入层限流来解决这个问题。
+
+### 3. 分布式限流
+
+分布式限流最关键的是要将限流服务做成原子化，而解决方案可以使使用`redis+lua`或者`nginx+lua`技术进行实现，通过这两种技术可以实现的高并发和高性能。
+
+首先我们来使用redis+lua实现时间窗内某个接口的请求数限流，实现了该功能后可以改造`为限流总并发/请求数和限制总资源数`。Lua本身就是一种编程语言，也可以使用它实现复杂的令牌桶或漏桶算法。
+
+#### 3.1 redis+lua实现中的lua脚本：
+```lua
+local key = KEYS[1] --限流KEY（一秒一个）
+local limit = tonumber(ARGV[1]) --限流大小
+local current = tonumber(redis.call("INCRBY", key, "1")) --请求数+1
+if current > limit then --如果超出限流大小
+    return 0
+elseif current == 1 then --只有第一次访问需要设置2秒的过期时间
+    redis.call("expire", key,"2")
+end
+return 1
+```
+如上操作因是在一个lua脚本中，又因Redis是单线程模型，因此是线程安全的。如上方式有一个缺点就是当达到限流大小后还是会递增的，可以改造成如下方式实现：
+```lua
+local key = KEYS[1] --限流KEY（一秒一个）
+local limit = tonumber(ARGV[1]) --限流大小
+local current = tonumber(redis.call('get', key) or "0")
+if current + 1 > limit then --如果超出限流大小
+    return 0
+else --请求数+1，并设置2秒过期
+    redis.call("INCRBY", key,"1")
+    redis.call("expire", key,"2")
+    return 1
+end
+```
+如下是Java中判断是否需要限流的代码：
+```java
+public static boolean acquire() throws Exception {
+String luaScript = Files.toString(new File("limit.lua"), Charset.defaultCharset());
+Jedis jedis = new Jedis("192.168.147.52", 6379);
+String key = "ip:" + System.currentTimeMillis()/ 1000; //此处将当前时间戳取秒数
+Stringlimit = "3"; //限流大小
+return (Long)jedis.eval(luaScript,Lists.newArrayList(key), Lists.newArrayList(limit)) == 1;
+}
+```
+因为Redis的限制（Lua中有写操作不能使用带随机性质的读操作，如TIME）不能在Redis Lua中使用TIME获取时间戳，因此只好从应用获取然后传入，在某些极端情况下（机器时钟不准的情况下），限流会存在一些小问题。
+
+例子：Java并发：分布式应用限流 Redis + Lua 实践 https://juejin.im/post/5b7625e051882533122e1fc4?utm_source=gold_browser_extension
+
+#### 3.2 使用Nginx+Lua实现的Lua脚本：
+```lua
+local locks = require "resty.lock"
+local function acquire()
+    local lock =locks:new("locks")
+    local elapsed, err =lock:lock("limit_key") --互斥锁
+    local limit_counter =ngx.shared.limit_counter --计数器
+    local key = "ip:" ..os.time()
+    local limit = 5 --限流大小
+    local current =limit_counter:get(key)
+
+    if current ~= nil and current + 1> limit then --如果超出限流大小
+        lock:unlock()
+        return 0
+    end
+    if current == nil then
+        limit_counter:set(key, 1, 1) --第一次需要设置过期时间，设置key的值为1，过期时间为1秒
+    else
+        limit_counter:incr(key, 1) --第二次开始加1即可
+    end
+    lock:unlock()
+    return 1
+end
+ngx.print(acquire())
+```
+
+实现中我们需要使用lua-resty-lock互斥锁模块来解决原子性问题(在实际工程中使用时请考虑获取锁的超时问题)，并使用ngx.shared.DICT共享字典来实现计数器。如果需要限流则返回0，否则返回1。使用时需要先定义两个共享字典（分别用来存放锁和计数器数据）：
+
+Java代码
+```java
+http {  
+    ……  
+    lua_shared_dict locks 10m;  
+    lua_shared_dict limit_counter 10m;  
+}  
+```
+有人会纠结如果应用并发量非常大那么redis或者nginx是不是能抗得住；不过这个问题要从多方面考虑：你的流量是不是真的有这么大，是不是可以通过一致性哈希将分布式限流进行分片，是不是可以当并发量太大降级为应用级限流；对策非常多，可以根据实际情况调节；像在京东使用Redis+Lua来限流抢购流量，一般流量是没有问题的。
+
+对于分布式限流目前遇到的场景是业务上的限流，而不是流量入口的限流；流量入口限流应该在接入层完成，而接入层笔者一般使用Nginx。
+
+### 4. 接入层限流
+接入层通常指请求流量的入口，该层的主要目的有：负载均衡、非法请求过滤、请求聚合、缓存、降级、限流、A/B测试、服务质量监控等等，可以参考笔者写的《使用Nginx+Lua(OpenResty)开发高性能Web应用》 http://jinnianshilongnian.iteye.com/blog/2280928。
+
+* 对于Nginx接入层限流可以使用 `Nginx` 自带了两个模块：`连接数限流模块ngx_http_limit_conn_module`和`漏桶算法实现的请求限流模块ngx_http_limit_req_module`。
+* 还可以使用`OpenResty` 提供的 `Lua` 限流模块`lua-resty-limit-traffic`进行更复杂的限流场景。
+
+limit_conn用来对某个KEY对应的总的网络连接数进行限流，可以按照如IP、域名维度进行限流。limit_req用来对某个KEY对应的请求的平均速率进行限流，并有两种用法：平滑模式（delay）和允许突发模式(nodelay)。
+
+#### 4.1 ngx_http_limit_conn_module
+limit_conn是对某个KEY对应的总的网络连接数进行限流。可以按照IP来限制IP维度的总连接数，或者按照服务域名来限制某个域名的总连接数。但是记住不是每一个请求连接都会被计数器统计，只有那些被Nginx处理的且已经读取了整个请求头的请求连接才会被计数器统计。
+
+配置示例：
+```
+http {
+    limit_conn_zone$binary_remote_addr zone=addr:10m;
+    limit_conn_log_level error;
+    limit_conn_status 503;
+    ...
+    server {
+    ...
+    location /limit {
+        limit_conn addr 1;
+    }
+```
+`limit_conn`：要配置存放KEY和计数器的共享内存区域和指定KEY的最大连接数；此处指定的最大连接数是1，表示Nginx最多同时并发处理1个连接；
+`limit_conn_zone`：用来配置限流KEY、及存放KEY对应信息的共享内存区域大小；此处的KEY是“$binary_remote_addr”其表示IP地址，也可以使用如$server_name作为KEY来限制域名级别的最大连接数；
+`limit_conn_status`：配置被限流后返回的状态码，默认返回503；
+`limit_conn_log_level`：配置记录被限流后的日志级别，默认error级别。
+
+#### 4.1.1 limit_conn的主要执行过程如下所示：
+
+* 1、请求进入后首先判断当前limit_conn_zone中相应KEY的连接数是否超出了配置的最大连接数；
+
+* 2.1、如果超过了配置的最大大小，则被限流，返回limit_conn_status定义的错误状态码；
+
+* 2.2、否则相应KEY的连接数加1，并注册请求处理完成的回调函数；
+
+* 3、进行请求处理；
+
+* 4、在结束请求阶段会调用注册的回调函数对相应KEY的连接数减1。
+
+limt_conn可以限流某个KEY的总并发/请求数，KEY可以根据需要变化。
+
+#### 4.1.2 按照IP限制并发连接数配置示例：
+
+首先定义IP维度的限流区域：
+```
+limit_conn_zone $binary_remote_addrzone=perip:10m;
+```
+
+接着在要限流的location中添加限流逻辑：
+```
+location /limit {
+    limit_conn perip 2;
+    echo "123";
+}
+```
+即允许每个IP最大并发连接数为2。
+
+使用AB测试工具进行测试，并发数为5个，总的请求数为5个：
+```
+ab -n 5 -c 5 http://localhost/limit
+````
+将得到如下access.log输出：
+```
+[08/Jun/2016:20:10:51+0800] [1465373451.802] 200
+[08/Jun/2016:20:10:51+0800] [1465373451.803] 200
+[08/Jun/2016:20:10:51 +0800][1465373451.803] 503
+[08/Jun/2016:20:10:51 +0800][1465373451.803] 503
+[08/Jun/2016:20:10:51 +0800][1465373451.803] 503
+```
+此处我们把access log格式设置为log_format main  '[$time_local] [$msec] $status'；分别是“日期 日期秒/毫秒值 响应状态码”。
+
+如果被限流了，则在error.log中会看到类似如下的内容：
+```
+2016/06/08 20:10:51 [error] 5662#0: *5limiting connections by zone "perip", client: 127.0.0.1, server: _,request: "GET /limit HTTP/1.0", host: "localhost"
+```
+#### 4.1.3 按照域名限制并发连接数配置示例：
+
+首先定义域名维度的限流区域：
+
+limit_conn_zone $ server_name zone=perserver:10m;
+接着在要限流的location中添加限流逻辑：
+```
+location /limit {
+    limit_conn perserver 2;
+    echo "123";
+}
+```
+即允许每个域名最大并发请求连接数为2；这样配置可以实现服务器最大连接数限制。
+
+#### 4.2 ngx_http_limit_req_module
+
+limit_req是漏桶算法实现，用于对指定KEY对应的请求进行限流，比如按照IP维度限制请求速率。
+
+配置示例：
+```
+http {
+    limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
+    limit_conn_log_level error;
+    limit_conn_status 503;
+    ...
+    server {
+    ...
+    location /limit {
+        limit_req zone=one burst=5 nodelay;
+    }
+```
+`limit_req`：配置限流区域、桶容量（突发容量，默认0）、是否延迟模式（默认延迟）；
+
+`limit_req_zone`：配置限流KEY、及存放KEY对应信息的共享内存区域大小、固定请求速率；此处指定的KEY是“$binary_remote_addr”表示IP地址；固定请求速率使用rate参数配置，支持10r/s和60r/m，即每秒10个请求和每分钟60个请求，不过最终都会转换为每秒的固定请求速率（10r/s为每100毫秒处理一个请求；60r/m，即每1000毫秒处理一个请求）。
+
+`limit_conn_status`：配置被限流后返回的状态码，默认返回503；
+
+`limit_conn_log_level`：配置记录被限流后的日志级别，默认error级别。
+
+limit_req的主要执行过程如下所示：
+
+1、请求进入后首先判断最后一次请求时间相对于当前时间（第一次是0）是否需要限流，如果需要限流则执行步骤2，否则执行步骤3；
+
+2.1、如果没有配置桶容量（burst），则桶容量为0；按照固定速率处理请求；如果请求被限流，则直接返回相应的错误码（默认503）；
+
+2.2、如果配置了桶容量（burst>0）且延迟模式(没有配置nodelay)；如果桶满了，则新进入的请求被限流；如果没有满则请求会以固定平均速率被处理（按照固定速率并根据需要延迟处理请求，延迟使用休眠实现）；
+
+2.3、如果配置了桶容量（burst>0）且非延迟模式（配置了nodelay）；不会按照固定速率处理请求，而是允许突发处理请求；如果桶满了，则请求被限流，直接返回相应的错误码；
+
+3、如果没有被限流，则正常处理请求；
+
+4、Nginx会在相应时机进行选择一些（3个节点）限流KEY进行过期处理，进行内存回收。
+
+##### 场景2.1测试
+
+首先定义IP维度的限流区域：
+```
+limit_req_zone $binary_remote_addrzone=test:10m rate=500r/s;
+```
+限制为每秒500个请求，固定平均速率为2毫秒一个请求。
+
+接着在要限流的location中添加限流逻辑：
+```
+location /limit {
+    limit_req zone=test;
+    echo "123";
+}
+```
+即桶容量为0（burst默认为0），且延迟模式。
+
+使用AB测试工具进行测试，并发数为2个，总的请求数为10个：
+```
+ab -n 10 -c 2 http://localhost/limit
+```
+
+将得到如下access.log输出：
+```
+[08/Jun/2016:20:25:56+0800] [1465381556.410] 200
+[08/Jun/2016:20:25:56 +0800][1465381556.410] 503
+[08/Jun/2016:20:25:56 +0800][1465381556.411] 503
+[08/Jun/2016:20:25:56+0800] [1465381556.411] 200
+[08/Jun/2016:20:25:56 +0800][1465381556.412] 503
+[08/Jun/2016:20:25:56 +0800][1465381556.412] 503
+```
+
+虽然每秒允许500个请求，但是因为桶容量为0，所以流入的请求要么被处理要么被限流，无法延迟处理；另外平均速率在2毫秒左右，比如1465381556.410和1465381556.411被处理了；有朋友会说这固定平均速率不是1毫秒嘛，其实这是因为实现算法没那么精准造成的。
+
+如果被限流在error.log中会看到如下内容：
+```
+2016/06/08 20:25:56 [error] 6130#0: *1962limiting requests, excess: 1.000 by zone "test", client: 127.0.0.1,server: _, request: "GET /limit HTTP/1.0", host:"localhost"
+```
+
+如果被延迟了在error.log（日志级别要INFO级别）中会看到如下内容：
+```
+2016/06/10 09:05:23 [warn] 9766#0: *97021delaying request, excess: 0.368, by zone "test", client: 127.0.0.1,server: _, request: "GET /limit HTTP/1.0", host:"localhost"
+```
+
+##### 场景2.2测试
+
+首先定义IP维度的限流区域：
+
+limit_req_zone $binary_remote_addr zone=test:10m rate=2r/s;
+为了方便测试设置速率为每秒2个请求，即固定平均速率是500毫秒一个请求。
+
+接着在要限流的location中添加限流逻辑：
+
+location /limit {
+    limit_req zone=test burst=3;
+    echo "123";
+}
+固定平均速率为500毫秒一个请求，通容量为3，如果桶满了新的请求被限流，否则可以进入桶中排队并等待（实现延迟模式）。
+
+为了看出限流效果我们写了一个req.sh脚本：
+```
+ab -c 6 -n 6 http://localhost/limit
+sleep 0.3
+ab -c 6 -n 6 http://localhost/limit
+```
+首先进行6个并发请求6次URL，然后休眠300毫秒，然后再进行6个并发请求6次URL；中间休眠目的是为了能跨越2秒看到效果，如果看不到如下的效果可以调节休眠时间。
+
+
+将得到如下access.log输出：
+```
+[09/Jun/2016:08:46:43+0800] [1465433203.959] 200
+[09/Jun/2016:08:46:43 +0800][1465433203.959] 503
+[09/Jun/2016:08:46:43 +0800][1465433203.960] 503
+[09/Jun/2016:08:46:44+0800] [1465433204.450] 200
+[09/Jun/2016:08:46:44+0800] [1465433204.950] 200
+[09/Jun/2016:08:46:45 +0800][1465433205.453] 200
+
+[09/Jun/2016:08:46:45 +0800][1465433205.766] 503
+[09/Jun/2016:08:46:45 +0800][1465433205.766] 503
+[09/Jun/2016:08:46:45 +0800][1465433205.767] 503
+[09/Jun/2016:08:46:45+0800] [1465433205.950] 200
+[09/Jun/2016:08:46:46+0800] [1465433206.451] 200
+[09/Jun/2016:08:46:46+0800] [1465433206.952] 200
+```
+<div align="center><img src="img/xl3.png"></div>
+
+桶容量为3，即桶中在时间窗口内最多流入3个请求，且按照2r/s的固定速率处理请求（即每隔500毫秒处理一个请求）；桶计算时间窗口（1.5秒）=速率（2r/s）/桶容量(3)，也就是说在这个时间窗口内桶最多暂存3个请求。因此我们要以当前时间往前推1.5秒和1秒来计算时间窗口内的总请求数；另外因为默认是延迟模式，所以时间窗内的请求要被暂存到桶中，并以固定平均速率处理请求：
+
+第一轮：有4个请求处理成功了，按照漏桶桶容量应该最多3个才对；这是因为计算算法的问题，第一次计算因没有参考值，所以第一次计算后，后续的计算才能有参考值，因此第一次成功可以忽略；这个问题影响很小可以忽略；而且按照固定500毫秒的速率处理请求。
+
+第二轮：因为第一轮请求是突发来的，差不多都在1465433203.959时间点，只是因为漏桶将速率进行了平滑变成了固定平均速率（每500毫秒一个请求）；而第二轮计算时间应基于1465433203.959；而第二轮突发请求差不多都在1465433205.766时间点，因此计算桶容量的时间窗口应基于1465433203.959和1465433205.766来计算，计算结果为1465433205.766这个时间点漏桶为空了，可以流入桶中3个请求，其他请求被拒绝；又因为第一轮最后一次处理时间是1465433205.453，所以第二轮第一个请求被延迟到了1465433205.950。这里也要注意固定平均速率只是在配置的速率左右，存在计算精度问题，会有一些偏差。
+
+
+
+如果桶容量改为1（burst=1），执行req.sh脚本可以看到如下输出：
+```
+09/Jun/2016:09:04:30+0800] [1465434270.362] 200
+[09/Jun/2016:09:04:30 +0800][1465434270.371] 503
+[09/Jun/2016:09:04:30 +0800] [1465434270.372]503
+[09/Jun/2016:09:04:30 +0800][1465434270.372] 503
+[09/Jun/2016:09:04:30 +0800][1465434270.372] 503
+[09/Jun/2016:09:04:30+0800] [1465434270.864] 200
+
+[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
+[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
+[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
+[09/Jun/2016:09:04:31 +0800][1465434271.178] 503
+[09/Jun/2016:09:04:31 +0800][1465434271.179] 503
+[09/Jun/2016:09:04:31+0800] [1465434271.366] 200
+```
+桶容量为1，按照每1000毫秒一个请求的固定平均速率处理请求。
+
+##### 场景2.3测试
+
+首先定义IP维度的限流区域：
+
+limit_req_zone $binary_remote_addr zone=test:10m rate=2r/s;
+为了方便测试配置为每秒2个请求，固定平均速率是500毫秒一个请求。
+
+
+
+接着在要限流的location中添加限流逻辑：
+
+location /limit {
+    limit_req zone=test burst=3 nodelay;
+    echo "123";
+}
+桶容量为3，如果桶满了直接拒绝新请求，且每秒2最多两个请求，桶按照固定500毫秒的速率以nodelay模式处理请求。
+
+
+
+为了看到限流效果我们写了一个req.sh脚本：
+``` sh
+ab -c 6 -n 6 http://localhost/limit
+sleep 1
+ab -c 6 -n 6 http://localhost/limit
+sleep 0.3
+ab -c 6 -n 6 http://localhost/limit
+sleep 0.3
+ab -c 6 -n 6 http://localhost/limit
+sleep 0.3
+ab -c 6 -n 6 http://localhost/limit
+sleep 2
+ab -c 6 -n 6 http://localhost/limit
+```
+
+将得到类似如下access.log输出：
+```
+[09/Jun/2016:14:30:11+0800] [1465453811.754] 200
+[09/Jun/2016:14:30:11+0800] [1465453811.755] 200
+[09/Jun/2016:14:30:11+0800] [1465453811.755] 200
+[09/Jun/2016:14:30:11+0800] [1465453811.759] 200
+[09/Jun/2016:14:30:11 +0800][1465453811.759] 503
+[09/Jun/2016:14:30:11 +0800][1465453811.759] 503
+
+[09/Jun/2016:14:30:12+0800] [1465453812.776] 200
+[09/Jun/2016:14:30:12+0800] [1465453812.776] 200
+[09/Jun/2016:14:30:12 +0800][1465453812.776] 503
+[09/Jun/2016:14:30:12 +0800][1465453812.777] 503
+[09/Jun/2016:14:30:12 +0800][1465453812.777] 503
+[09/Jun/2016:14:30:12 +0800][1465453812.777] 503
+
+[09/Jun/2016:14:30:13 +0800] [1465453813.095]503
+[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.097] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.098] 503
+
+[09/Jun/2016:14:30:13+0800] [1465453813.425] 200
+[09/Jun/2016:14:30:13 +0800][1465453813.425] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.425] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.426] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.426] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.426] 503
+
+[09/Jun/2016:14:30:13+0800] [1465453813.754] 200
+[09/Jun/2016:14:30:13 +0800][1465453813.755] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.755] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.756] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.756] 503
+[09/Jun/2016:14:30:13 +0800][1465453813.756] 503
+
+[09/Jun/2016:14:30:15+0800] [1465453815.278] 200
+[09/Jun/2016:14:30:15+0800] [1465453815.278] 200
+[09/Jun/2016:14:30:15+0800] [1465453815.278] 200
+[09/Jun/2016:14:30:15 +0800][1465453815.278] 503
+[09/Jun/2016:14:30:15 +0800][1465453815.279] 503
+[09/Jun/2016:14:30:15 +0800][1465453815.279] 503
+
+[09/Jun/2016:14:30:17+0800] [1465453817.300] 200
+[09/Jun/2016:14:30:17+0800] [1465453817.300] 200
+[09/Jun/2016:14:30:17+0800] [1465453817.300] 200
+[09/Jun/2016:14:30:17+0800] [1465453817.301] 200
+[09/Jun/2016:14:30:17 +0800][1465453817.301] 503
+[09/Jun/2016:14:30:17 +0800][1465453817.301] 503
+```
+<div align="center><img src="img/xl4.png"></div>
+
+桶容量为3（，即桶中在时间窗口内最多流入3个请求，且按照2r/s的固定速率处理请求（即每隔500毫秒处理一个请求）；桶计算时间窗口（1.5秒）=速率（2r/s）/桶容量(3)，也就是说在这个时间窗口内桶最多暂存3个请求。因此我们要以当前时间往前推1.5秒和1秒来计算时间窗口内的总请求数；另外因为配置了nodelay，是非延迟模式，所以允许时间窗内突发请求的；另外从本示例会看出两个问题：
+
+第一轮和第七轮：有4个请求处理成功了；这是因为计算算法的问题，本示例是如果2秒内没有请求，然后接着突然来了很多请求，第一次计算的结果将是不正确的；这个问题影响很小可以忽略；
+
+第五轮：1.0秒计算出来是3个请求；此处也是因计算精度的问题，也就是说limit_req实现的算法不是非常精准的，假设此处看成相对于2.75的话，1.0秒内只有1次请求，所以还是允许1次请求的。
+
+
+
+如果限流出错了，可以配置错误页面：
+
+proxy_intercept_errors on;
+recursive_error_pages on;
+error_page 503 //www.jd.com/error.aspx;
+limit_conn_zone/limit_req_zone定义的内存不足，则后续的请求将一直被限流，所以需要根据需求设置好相应的内存大小。
+
+此处的限流都是单Nginx的，假设我们接入层有多个nginx，此处就存在和应用级限流相同的问题；那如何处理呢？一种解决办法：建立一个负载均衡层将按照限流KEY进行一致性哈希算法将请求哈希到接入层Nginx上，从而相同KEY的将打到同一台接入层Nginx上；另一种解决方案就是使用Nginx+Lua（OpenResty）调用分布式限流逻辑实现。
+
+#### 4.3 lua-resty-limit-traffic
+之前介绍的两个模块使用上比较简单，指定KEY、指定限流速率等就可以了，如果我们想根据实际情况变化KEY、变化速率、变化桶大小等这种动态特性，使用标准模块就很难去实现了，因此我们需要一种可编程来解决我们问题；而OpenResty提供了lua限流模块lua-resty-limit-traffic，通过它可以按照更复杂的业务逻辑进行动态限流处理了。其提供了limit.conn和limit.req实现，算法与nginx limit_conn和limit_req是一样的。
+
+此处我们来实现ngx_http_limit_req_module中的【场景2.2测试】，不要忘记下载lua-resty-limit-traffic模块并添加到OpenResty的lualib中。
+
+配置用来存放限流用的共享字典：
+
+lua_shared_dict limit_req_store 100m;
+
+
+以下是实现【场景2.2测试】的限流代码limit_req.lua：
+```
+local limit_req = require "resty.limit.req"
+local rate = 2 --固定平均速率 2r/s
+local burst = 3 --桶容量
+local error_status = 503
+local nodelay = false --是否需要不延迟处理
+local lim, err = limit_req.new("limit_req_store", rate, burst)
+if not lim then --没定义共享字典
+    ngx.exit(error_status)
+end
+local key = ngx.var.binary_remote_addr --IP维度的限流
+--流入请求，如果请求需要被延迟则delay > 0
+local delay, err = lim:incoming(key, true)
+if not delay and err == "rejected" then --超出桶大小了
+    ngx.exit(error_status)
+end
+if delay > 0 then --根据需要决定是延迟或者不延迟处理
+    if nodelay then
+        --直接突发处理了
+    else
+        ngx.sleep(delay) --延迟处理
+    end
+end
+```
+即限流逻辑再nginx access阶段被访问，如果不被限流继续后续流程；如果需要被限流要么sleep一段时间继续后续流程，要么返回相应的状态码拒绝请求。
+
+在分布式限流中我们使用了简单的Nginx+Lua进行分布式限流，有了这个模块也可以使用这个模块来实现分布式限流。
+
+另外在使用Nginx+Lua时也可以获取ngx.var.connections_active进行过载保护，即如果当前活跃连接数超过阈值进行限流保护。
+```
+if tonumber(ngx.var.connections_active) >= tonumber(limit) then
+    //限流
+end
+```
+nginx也提供了limit_rate用来对流量限速，如limit_rate 50k，表示限制下载速度为50k。
+
+到此笔者在工作中涉及的限流用法就介绍完，这些算法中有些允许突发，有些会整形为平滑，有些计算算法简单粗暴；其中令牌桶算法和漏桶算法实现上是类似的，只是表述的方向不太一样，对于业务来说不必刻意去区分它们；因此需要根据实际场景来决定如何限流，最好的算法不一定是最适用的。
+
+### 参考资料
+
+https://en.wikipedia.org/wiki/Token_bucket
+https://en.wikipedia.org/wiki/Leaky_bucket
+http://redis.io/commands/incr
+http://nginx.org/en/docs/http/ngx_http_limit_req_module.html
+http://nginx.org/en/docs/http/ngx_http_limit_conn_module.html
+https://github.com/openresty/lua-resty-limit-traffic
+http://nginx.org/en/docs/http/ngx_http_core_module.html#limit_rate
diff --git "a/16 - Software Engineering/UML\346\234\200\350\257\246\347\273\206\350\265\204\346\272\220.pdf" "b/16 - Software Engineering \350\275\257\344\273\266\345\267\245\347\250\213/UML\346\234\200\350\257\246\347\273\206\350\265\204\346\272\220.pdf"
similarity index 100%
rename from "16 - Software Engineering/UML\346\234\200\350\257\246\347\273\206\350\265\204\346\272\220.pdf"
rename to "16 - Software Engineering \350\275\257\344\273\266\345\267\245\347\250\213/UML\346\234\200\350\257\246\347\273\206\350\265\204\346\272\220.pdf"
diff --git "a/16 - Software Engineering/\350\223\235\347\273\277\351\203\250\347\275\262 \346\273\232\345\212\250\351\203\250\347\275\262.md" "b/16 - Software Engineering \350\275\257\344\273\266\345\267\245\347\250\213/\350\223\235\347\273\277\351\203\250\347\275\262 \346\273\232\345\212\250\351\203\250\347\275\262.md"
similarity index 100%
rename from "16 - Software Engineering/\350\223\235\347\273\277\351\203\250\347\275\262 \346\273\232\345\212\250\351\203\250\347\275\262.md"
rename to "16 - Software Engineering \350\275\257\344\273\266\345\267\245\347\250\213/\350\223\235\347\273\277\351\203\250\347\275\262 \346\273\232\345\212\250\351\203\250\347\275\262.md"
diff --git a/17 - Scripting language/cleanfile.py "b/17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/cleanfile.py"
similarity index 96%
rename from 17 - Scripting language/cleanfile.py
rename to "17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/cleanfile.py"
index e695e50f..208911d6 100644
--- a/17 - Scripting language/cleanfile.py	
+++ "b/17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/cleanfile.py"	
@@ -1,48 +1,48 @@
-#coding=utf-8
-import time
-import datetime
-import os
-
-# 删除目录下的 一小时以前的文件夹及内容
-def delete_dir():
-
-    # /var/nms/devversion/cf/
-    t = time.time()
-    print (t)                       #原始时间数据
-    print (int(t))                  #秒级时间戳
-    print (int(round(t * 1000)))    #毫秒级时间戳
-
-    # 1 小时 3600000 
-    before1hour = int(round(t * 1000)) - 3600000
-    print (before1hour) #一小时前的时间戳
-    
-    print (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))   #日期格式化
-
-    fs = os.listdir("/var/nms/devversion/cf/")
-    for f1 in fs:
-        tmp_path = os.path.join("/var/nms/devversion/cf/",f1)
-        if not os.path.isdir(tmp_path):
-            print('文件: %s'%tmp_path)
-        else:
-            print(f1)
-            print(int(f1)<before1hour)
-            if(int(f1)<before1hour):
-                print('文件夹：%s 在一小时前创建的，执行删除'%tmp_path)
-                del_file(tmp_path)
-                os.rmdir(tmp_path)
-
-
-#递归删除文件夹下的所有文件
-def del_file(path):
-    ls = os.listdir(path)
-    for i in ls:
-        c_path = os.path.join(path, i)
-        if os.path.isdir(c_path):
-            del_file(c_path)
-            #如果是空目录
-            if not os.listdir(c_path):
-                os.rmdir(c_path)
-        else:
-            os.remove(c_path)
-
+#coding=utf-8
+import time
+import datetime
+import os
+
+# 删除目录下的 一小时以前的文件夹及内容
+def delete_dir():
+
+    # /var/nms/devversion/cf/
+    t = time.time()
+    print (t)                       #原始时间数据
+    print (int(t))                  #秒级时间戳
+    print (int(round(t * 1000)))    #毫秒级时间戳
+
+    # 1 小时 3600000 
+    before1hour = int(round(t * 1000)) - 3600000
+    print (before1hour) #一小时前的时间戳
+    
+    print (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))   #日期格式化
+
+    fs = os.listdir("/var/nms/devversion/cf/")
+    for f1 in fs:
+        tmp_path = os.path.join("/var/nms/devversion/cf/",f1)
+        if not os.path.isdir(tmp_path):
+            print('文件: %s'%tmp_path)
+        else:
+            print(f1)
+            print(int(f1)<before1hour)
+            if(int(f1)<before1hour):
+                print('文件夹：%s 在一小时前创建的，执行删除'%tmp_path)
+                del_file(tmp_path)
+                os.rmdir(tmp_path)
+
+
+#递归删除文件夹下的所有文件
+def del_file(path):
+    ls = os.listdir(path)
+    for i in ls:
+        c_path = os.path.join(path, i)
+        if os.path.isdir(c_path):
+            del_file(c_path)
+            #如果是空目录
+            if not os.listdir(c_path):
+                os.rmdir(c_path)
+        else:
+            os.remove(c_path)
+
 delete_dir()
\ No newline at end of file
diff --git "a/17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/lua.txt" "b/17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/lua.txt"
new file mode 100644
index 00000000..e69de29b
diff --git a/17 - Scripting language/luaRedis.lua "b/17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/luaRedis.lua"
similarity index 100%
rename from 17 - Scripting language/luaRedis.lua
rename to "17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/luaRedis.lua"
diff --git a/17 - Scripting language/mysql2redis.py "b/17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/mysql2redis.py"
similarity index 100%
rename from 17 - Scripting language/mysql2redis.py
rename to "17 - Scripting language \350\204\232\346\234\254\350\257\255\350\250\200/mysql2redis.py"
diff --git a/18 - Common code/CacheMap.java "b/18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/CacheMap.java"
similarity index 96%
rename from 18 - Common code/CacheMap.java
rename to "18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/CacheMap.java"
index 168ecc9a..903c49b0 100644
--- a/18 - Common code/CacheMap.java	
+++ "b/18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/CacheMap.java"	
@@ -1,102 +1,102 @@
-package com.kedacom.tsu.util;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class CacheMap {
-private static Map<String,Object> map=null;
-	
-	private long cacheTime=30000;//单位秒,默认值为30s
-	
-	private static CacheMap instance = new CacheMap();
-	
-	public static CacheMap getInstance() {
-		return instance;
-	}
-	
-	public CacheMap(){		
-		//线程，定时清除超时的缓存
-		synchronized ("lazy") {
-			if(map == null){				
-				map=new HashMap<String, Object>();
-			}		
-		}
-		
-	}
-	
-	//存值,不设置时，超时时间默认为30s
-	public void put(String key,Object value){
-		synchronized(map){
-			clearTimeOutCache();
-			Map<String,Object> dataWithTime=new HashMap<String, Object>();
-			dataWithTime.put("lastTimeMillis", System.currentTimeMillis());
-			dataWithTime.put("outTimeMillis", cacheTime);
-			dataWithTime.put("data", value);
-			map.put(key, dataWithTime);
-		}
-	}
-	
-	//存值带超时时间,超时时间小于0时，永不超时
-	public void put(String key,Object value,Long outTimeMillis){
-		synchronized(map){
-			clearTimeOutCache();
-			
-			Map<String,Object> dataWithTime=new HashMap<String, Object>();
-			dataWithTime.put("lastTimeMillis", System.currentTimeMillis());
-			dataWithTime.put("outTimeMillis", outTimeMillis);
-			dataWithTime.put("data", value);
-			map.put(key, dataWithTime);
-		}
-	}
-	
-	//取值
-	public Object get(String key){
-		synchronized (map) {	
-			Map<String,Object> dataWithTime=(Map<String, Object>) map.get(key);
-			if(dataWithTime !=null){							
-				dataWithTime.put("lastTimeMillis", System.currentTimeMillis());				
-				return dataWithTime.get("data");
-			}else{
-				return null;
-			}
-		}
-	}
-	
-	//移除
-	public void remove(String key){
-		synchronized (map) {
-			map.remove(key);
-			System.out.println("clearMapCache :=====> key:"+key);
-		}
-	}
-	
-	
-	//移除过期缓存
-	public void clearTimeOutCache(){
-		synchronized (map) {	
-			List<String> keyList=new ArrayList<String>();
-			for(Map.Entry<String, Object> entry : map.entrySet()){
-				String key=entry.getKey();
-				Map<String, Object> dataWithTime=(Map<String, Object>) entry.getValue();
-				
-				if(dataWithTime !=null){				
-					Long lastTimeMillis=(Long) dataWithTime.get("lastTimeMillis");
-					Long outTimeMillis=(Long) dataWithTime.get("outTimeMillis");
-					Long currentTimeMillis=System.currentTimeMillis();
-					if(outTimeMillis<0){//小于0时，永不超时
-						continue;
-					}
-					if(currentTimeMillis-lastTimeMillis>outTimeMillis){	
-						keyList.add(key);
-					}
-				}
-			}
-			for(String key:keyList){
-				map.remove(key);
-				System.out.println("clearMapCache :=====> key:"+key);
-			}
-		}
-	}
-}
+package com.kedacom.tsu.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class CacheMap {
+private static Map<String,Object> map=null;
+	
+	private long cacheTime=30000;//单位秒,默认值为30s
+	
+	private static CacheMap instance = new CacheMap();
+	
+	public static CacheMap getInstance() {
+		return instance;
+	}
+	
+	public CacheMap(){		
+		//线程，定时清除超时的缓存
+		synchronized ("lazy") {
+			if(map == null){				
+				map=new HashMap<String, Object>();
+			}		
+		}
+		
+	}
+	
+	//存值,不设置时，超时时间默认为30s
+	public void put(String key,Object value){
+		synchronized(map){
+			clearTimeOutCache();
+			Map<String,Object> dataWithTime=new HashMap<String, Object>();
+			dataWithTime.put("lastTimeMillis", System.currentTimeMillis());
+			dataWithTime.put("outTimeMillis", cacheTime);
+			dataWithTime.put("data", value);
+			map.put(key, dataWithTime);
+		}
+	}
+	
+	//存值带超时时间,超时时间小于0时，永不超时
+	public void put(String key,Object value,Long outTimeMillis){
+		synchronized(map){
+			clearTimeOutCache();
+			
+			Map<String,Object> dataWithTime=new HashMap<String, Object>();
+			dataWithTime.put("lastTimeMillis", System.currentTimeMillis());
+			dataWithTime.put("outTimeMillis", outTimeMillis);
+			dataWithTime.put("data", value);
+			map.put(key, dataWithTime);
+		}
+	}
+	
+	//取值
+	public Object get(String key){
+		synchronized (map) {	
+			Map<String,Object> dataWithTime=(Map<String, Object>) map.get(key);
+			if(dataWithTime !=null){							
+				dataWithTime.put("lastTimeMillis", System.currentTimeMillis());				
+				return dataWithTime.get("data");
+			}else{
+				return null;
+			}
+		}
+	}
+	
+	//移除
+	public void remove(String key){
+		synchronized (map) {
+			map.remove(key);
+			System.out.println("clearMapCache :=====> key:"+key);
+		}
+	}
+	
+	
+	//移除过期缓存
+	public void clearTimeOutCache(){
+		synchronized (map) {	
+			List<String> keyList=new ArrayList<String>();
+			for(Map.Entry<String, Object> entry : map.entrySet()){
+				String key=entry.getKey();
+				Map<String, Object> dataWithTime=(Map<String, Object>) entry.getValue();
+				
+				if(dataWithTime !=null){				
+					Long lastTimeMillis=(Long) dataWithTime.get("lastTimeMillis");
+					Long outTimeMillis=(Long) dataWithTime.get("outTimeMillis");
+					Long currentTimeMillis=System.currentTimeMillis();
+					if(outTimeMillis<0){//小于0时，永不超时
+						continue;
+					}
+					if(currentTimeMillis-lastTimeMillis>outTimeMillis){	
+						keyList.add(key);
+					}
+				}
+			}
+			for(String key:keyList){
+				map.remove(key);
+				System.out.println("clearMapCache :=====> key:"+key);
+			}
+		}
+	}
+}
diff --git "a/18 - Common code/\345\233\276\347\211\207\350\275\254Base64\345\271\266\345\216\213\347\274\251.md" "b/18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/\345\233\276\347\211\207\350\275\254Base64\345\271\266\345\216\213\347\274\251.md"
similarity index 100%
rename from "18 - Common code/\345\233\276\347\211\207\350\275\254Base64\345\271\266\345\216\213\347\274\251.md"
rename to "18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/\345\233\276\347\211\207\350\275\254Base64\345\271\266\345\216\213\347\274\251.md"
diff --git "a/18 - Common code/\350\216\267\345\217\226\345\256\242\346\210\267\347\253\257\347\234\237\345\256\236\347\232\204IP\345\234\260\345\235\200.md" "b/18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/\350\216\267\345\217\226\345\256\242\346\210\267\347\253\257\347\234\237\345\256\236\347\232\204IP\345\234\260\345\235\200.md"
similarity index 100%
rename from "18 - Common code/\350\216\267\345\217\226\345\256\242\346\210\267\347\253\257\347\234\237\345\256\236\347\232\204IP\345\234\260\345\235\200.md"
rename to "18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/\350\216\267\345\217\226\345\256\242\346\210\267\347\253\257\347\234\237\345\256\236\347\232\204IP\345\234\260\345\235\200.md"
diff --git "a/18 - Common code/\351\232\217\346\234\272\347\224\237\346\210\220\345\220\215\345\255\227.txt" "b/18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/\351\232\217\346\234\272\347\224\237\346\210\220\345\220\215\345\255\227.txt"
similarity index 100%
rename from "18 - Common code/\351\232\217\346\234\272\347\224\237\346\210\220\345\220\215\345\255\227.txt"
rename to "18 - Common code \345\270\270\347\224\250\344\273\243\347\240\201/\351\232\217\346\234\272\347\224\237\346\210\220\345\220\215\345\255\227.txt"
diff --git "a/19 - Standard/GoogleJava\347\274\226\347\250\213\350\247\204\350\214\203.pdf" "b/19 - Standard \346\240\207\345\207\206/GoogleJava\347\274\226\347\250\213\350\247\204\350\214\203.pdf"
similarity index 100%
rename from "19 - Standard/GoogleJava\347\274\226\347\250\213\350\247\204\350\214\203.pdf"
rename to "19 - Standard \346\240\207\345\207\206/GoogleJava\347\274\226\347\250\213\350\247\204\350\214\203.pdf"
diff --git a/19 - Standard/Mysql-ORM.txt "b/19 - Standard \346\240\207\345\207\206/Mysql-ORM.txt"
similarity index 98%
rename from 19 - Standard/Mysql-ORM.txt
rename to "19 - Standard \346\240\207\345\207\206/Mysql-ORM.txt"
index 880fd5c7..e199194a 100644
--- a/19 - Standard/Mysql-ORM.txt	
+++ "b/19 - Standard \346\240\207\345\207\206/Mysql-ORM.txt"	
@@ -1,31 +1,31 @@
-1 在表查询中，一律不要使用 * 作为查询的字段列表，需要哪些字段必须明确写明。 
-	说明：
-	1）增加查询分析器解析成本。
-	2）增减字段容易与resultMap配置不一致。
-	
-2 POJO类的布尔属性不能加is，而数据库字段必须加is_，要求在resultMap中进行字段与属性之间的映射。 
-	说明：参见定义POJO类以及数据库字段定义规定，在<resultMap>中增加映射，是必须的。
-	在MyBatis Generator生成的代码中，需要进行对应的修改。
-	
-3 不要用resultClass当返回参数，即使所有类属性名与数据库字段一一对应，也需要定义；反过来，每一个表也必然有一个与之对应。 
-	说明：配置映射关系，使字段与DO类解耦，方便维护。
-	
-4 sql.xml配置参数使用：#{}，#param# 不要使用${} 此种方式容易出现SQL注入。
-
-5 iBATIS自带的queryForList(String statementName,int start,int size)不推荐使用。 
-	说明：其实现方式是在数据库取到statementName对应的SQL语句的所有记录，再通过subList取start,size的子集合。
-	正例：Map<String, Object> map = new HashMap<String, Object>();
-		map.put("start", start);
-		map.put("size", size);
-		
-6 不允许直接拿HashMap与Hashtable作为查询结果集的输出。 
-	说明：resultClass=”Hashtable”，会置入字段名和属性值，但是值的类型不可控。
-
-7 更新数据表记录时，必须同时更新记录对应的gmt_modified字段值为当前时间。
-
-8 不要写一个大而全的数据更新接口。传入为POJO类，不管是不是自己的目标更新字段，都进行update table set c1=value1,c2=value2,c3=value3; 这是不对的。
-	执行SQL时，不要更新无改动的字段，一是易出错；二是效率低；三是增加binlog存储。
-	
-9 @Transactional事务不要滥用。事务会影响数据库的QPS，另外使用事务的地方需要考虑各方面的回滚方案，包括缓存回滚、搜索引擎回滚、消息补偿、统计修正等。
-
+1 在表查询中，一律不要使用 * 作为查询的字段列表，需要哪些字段必须明确写明。 
+	说明：
+	1）增加查询分析器解析成本。
+	2）增减字段容易与resultMap配置不一致。
+	
+2 POJO类的布尔属性不能加is，而数据库字段必须加is_，要求在resultMap中进行字段与属性之间的映射。 
+	说明：参见定义POJO类以及数据库字段定义规定，在<resultMap>中增加映射，是必须的。
+	在MyBatis Generator生成的代码中，需要进行对应的修改。
+	
+3 不要用resultClass当返回参数，即使所有类属性名与数据库字段一一对应，也需要定义；反过来，每一个表也必然有一个与之对应。 
+	说明：配置映射关系，使字段与DO类解耦，方便维护。
+	
+4 sql.xml配置参数使用：#{}，#param# 不要使用${} 此种方式容易出现SQL注入。
+
+5 iBATIS自带的queryForList(String statementName,int start,int size)不推荐使用。 
+	说明：其实现方式是在数据库取到statementName对应的SQL语句的所有记录，再通过subList取start,size的子集合。
+	正例：Map<String, Object> map = new HashMap<String, Object>();
+		map.put("start", start);
+		map.put("size", size);
+		
+6 不允许直接拿HashMap与Hashtable作为查询结果集的输出。 
+	说明：resultClass=”Hashtable”，会置入字段名和属性值，但是值的类型不可控。
+
+7 更新数据表记录时，必须同时更新记录对应的gmt_modified字段值为当前时间。
+
+8 不要写一个大而全的数据更新接口。传入为POJO类，不管是不是自己的目标更新字段，都进行update table set c1=value1,c2=value2,c3=value3; 这是不对的。
+	执行SQL时，不要更新无改动的字段，一是易出错；二是效率低；三是增加binlog存储。
+	
+9 @Transactional事务不要滥用。事务会影响数据库的QPS，另外使用事务的地方需要考虑各方面的回滚方案，包括缓存回滚、搜索引擎回滚、消息补偿、统计修正等。
+
 10 <isEqual>中的compareValue是与属性值对比的常量，一般是数字，表示相等时带上此条件；<isNotEmpty>表示不为空且不为null时执行；<isNotNull>表示不为null值时执行。
\ No newline at end of file
diff --git "a/19 - Standard/Mysql-\345\273\272\350\241\250.txt" "b/19 - Standard \346\240\207\345\207\206/Mysql-\345\273\272\350\241\250.txt"
similarity index 98%
rename from "19 - Standard/Mysql-\345\273\272\350\241\250.txt"
rename to "19 - Standard \346\240\207\345\207\206/Mysql-\345\273\272\350\241\250.txt"
index 8e7f6e02..b261fb44 100644
--- "a/19 - Standard/Mysql-\345\273\272\350\241\250.txt"	
+++ "b/19 - Standard \346\240\207\345\207\206/Mysql-\345\273\272\350\241\250.txt"	
@@ -1,50 +1,50 @@
-1 表达是与否概念的字段，必须使用is_xxx的方式命名，数据类型是unsigned tinyint（ 1表示是，0表示否）。 
-	说明：任何字段如果为非负数，必须是unsigned。 
-	正例： 表达逻辑删除的字段名 is_deleted，1表示删除， 0表示未删除。 表示未删除。
-
-2 表名、字段名必须使用小写字母或数字，禁止出现数字开头，禁止两个下划线中间只出现数字。数据库字段名的修改代价很大，因为无法进行预发布，所以字段名称需要慎重考虑。 
-	说明： MySQL 在 Windows 下不区分大小写，但在 下不区分大小写，但在 Linux下默认是区分大小写。因此，数据库 名、表名、字段名都不允许出现任何大写母避免节外生枝。 
-	正例：aliyun_admin，rdc_config，level3_name 
-	反例：AliyunAdmin，rdcConfig，level_3_name
-
-3 表名不使用复数名词。 
-		说明：表名应该仅仅表示表里面的实体内容，不应该表示实体数量，对应于DO类名也是单数形式，符合表达习惯。
-
-4 禁用保留字，如desc、range、match、delayed等，请参考MySQL官方保留字。
-
-5 主键索引名为pk_字段名；唯一索引名为uk_字段名；普通索引名则为idx_字段名。 
-	说明：pk_ 即primary key；uk_ 即 unique key；idx_ 即index的简称。
-
-6 小数类型为decimal，禁止使用float和double。 说明：float和double在存储的时候，存在精度损失的问题，很可能在值的比较时，得到不正确的结果。如果存储的数据范围超过decimal的范围，建议将数据拆成整数和小数分开存储。
-
-7 如果存储的字符串长度几乎相等，使用char定长字符串类型。
-
-8 varchar是可变长字符串，不预先分配存储空间，长度不要超过5000，如果存储长度大于此值，定义字段类型为text，独立出来一张表，用主键来对应，避免影响其它字段索引效率。
-
-9 表必备三字段：id, gmt_create, gmt_modified。 
-	说明： 其中 
-		id必为 主键，类型为 unsigned bigint、单表时自增、步长为 1。
-		gmt_create, gmt_modified的类型均为 date_time类型，前者现在时表示主动创建，后者过去分词表示被动更新。
-
-10 表的命名最好是加上“业务名称_表的作用”。 
-	正例：alipay_task / force_project / trade_config
-
-11 库名与应用名称尽量一致。
-
-12 如果修改字段含义或对字段表示的状态追加时，需要及时更新字段注释。
-
-13 字段允许适当冗余，以提高查询性能，但必须考虑数据一致。冗余字段应遵循： 
-	1）不是频繁修改的字段。 
-	2）不是varchar超长字段，更不能是text字段。 
-	正例：商品类目名称使用频率高，字段长度短，名称基本一成不变，可在相关联的表中冗余存储类目名称，避免关联查询。
-
-14 单表行数超过500万行或者单表容量超过2GB，才推荐进行分库分表。 
-	说明：如果预计三年后的数据量根本达不到这个级别，请不要在创建表时就分库分表。
-
-15 合适的字符存储长度，不但节约数据库表空间、节约索引存储，更重要的是提升检索速度。 
-	正例：如下表，其中无符号值可以避免误存负数，且扩大了表示范围。
-	对象 		年龄区间 			类型 			   字节 		表示范围
-	人 			150岁以内 		unsigned tinyint 		1 		无符号值 0到255
-	龟 			数百岁 			unsigned smallint 		2 		无符号值 0到65535
-	恐龙化石 	数千万年 		unsigned int 			4 		无符号值 0到42.9亿
+1 表达是与否概念的字段，必须使用is_xxx的方式命名，数据类型是unsigned tinyint（ 1表示是，0表示否）。 
+	说明：任何字段如果为非负数，必须是unsigned。 
+	正例： 表达逻辑删除的字段名 is_deleted，1表示删除， 0表示未删除。 表示未删除。
+
+2 表名、字段名必须使用小写字母或数字，禁止出现数字开头，禁止两个下划线中间只出现数字。数据库字段名的修改代价很大，因为无法进行预发布，所以字段名称需要慎重考虑。 
+	说明： MySQL 在 Windows 下不区分大小写，但在 下不区分大小写，但在 Linux下默认是区分大小写。因此，数据库 名、表名、字段名都不允许出现任何大写母避免节外生枝。 
+	正例：aliyun_admin，rdc_config，level3_name 
+	反例：AliyunAdmin，rdcConfig，level_3_name
+
+3 表名不使用复数名词。 
+		说明：表名应该仅仅表示表里面的实体内容，不应该表示实体数量，对应于DO类名也是单数形式，符合表达习惯。
+
+4 禁用保留字，如desc、range、match、delayed等，请参考MySQL官方保留字。
+
+5 主键索引名为pk_字段名；唯一索引名为uk_字段名；普通索引名则为idx_字段名。 
+	说明：pk_ 即primary key；uk_ 即 unique key；idx_ 即index的简称。
+
+6 小数类型为decimal，禁止使用float和double。 说明：float和double在存储的时候，存在精度损失的问题，很可能在值的比较时，得到不正确的结果。如果存储的数据范围超过decimal的范围，建议将数据拆成整数和小数分开存储。
+
+7 如果存储的字符串长度几乎相等，使用char定长字符串类型。
+
+8 varchar是可变长字符串，不预先分配存储空间，长度不要超过5000，如果存储长度大于此值，定义字段类型为text，独立出来一张表，用主键来对应，避免影响其它字段索引效率。
+
+9 表必备三字段：id, gmt_create, gmt_modified。 
+	说明： 其中 
+		id必为 主键，类型为 unsigned bigint、单表时自增、步长为 1。
+		gmt_create, gmt_modified的类型均为 date_time类型，前者现在时表示主动创建，后者过去分词表示被动更新。
+
+10 表的命名最好是加上“业务名称_表的作用”。 
+	正例：alipay_task / force_project / trade_config
+
+11 库名与应用名称尽量一致。
+
+12 如果修改字段含义或对字段表示的状态追加时，需要及时更新字段注释。
+
+13 字段允许适当冗余，以提高查询性能，但必须考虑数据一致。冗余字段应遵循： 
+	1）不是频繁修改的字段。 
+	2）不是varchar超长字段，更不能是text字段。 
+	正例：商品类目名称使用频率高，字段长度短，名称基本一成不变，可在相关联的表中冗余存储类目名称，避免关联查询。
+
+14 单表行数超过500万行或者单表容量超过2GB，才推荐进行分库分表。 
+	说明：如果预计三年后的数据量根本达不到这个级别，请不要在创建表时就分库分表。
+
+15 合适的字符存储长度，不但节约数据库表空间、节约索引存储，更重要的是提升检索速度。 
+	正例：如下表，其中无符号值可以避免误存负数，且扩大了表示范围。
+	对象 		年龄区间 			类型 			   字节 		表示范围
+	人 			150岁以内 		unsigned tinyint 		1 		无符号值 0到255
+	龟 			数百岁 			unsigned smallint 		2 		无符号值 0到65535
+	恐龙化石 	数千万年 		unsigned int 			4 		无符号值 0到42.9亿
 	太阳 		约50万亿年 		unsigned bigint 		8 		无符号值 0到约10的19次方
\ No newline at end of file
diff --git "a/19 - Standard/Mysql-\347\264\242\345\274\225.txt" "b/19 - Standard \346\240\207\345\207\206/Mysql-\347\264\242\345\274\225.txt"
similarity index 98%
rename from "19 - Standard/Mysql-\347\264\242\345\274\225.txt"
rename to "19 - Standard \346\240\207\345\207\206/Mysql-\347\264\242\345\274\225.txt"
index 082829a4..8afe3af7 100644
--- "a/19 - Standard/Mysql-\347\264\242\345\274\225.txt"	
+++ "b/19 - Standard \346\240\207\345\207\206/Mysql-\347\264\242\345\274\225.txt"	
@@ -1,47 +1,47 @@
-1 业务上具有唯一特性的字段，即使是多个字段的组合，也必须建成唯一索引。 
-	说明：不要以为唯一索引影响了insert速度，这个速度损耗可以忽略，但提高查找速度是明显的；另外，即使在应用层做了非常完善的校验控制，只要没有唯一索引，根据墨菲定律，必然有脏数据产生。
-
-2 超过三个表禁止join。需要join的字段，数据类型必须绝对一致；多表关联查询时，保证被关联的字段需要有索引。 
-	说明：即使双表join也要注意表索引、SQL性能。
-
-3 在varchar字段上建立索引时，必须指定索引长度，没必要对全字段建立索引，根据实际文本区分度决定索引长度即可。
-	说明：索引的长度与区分度是一对矛盾体，一般对字符串类型数据，长度为20的索引，区分度会高达90%以上，可以使用count(distinct left(列名, 索引长度))/count(*)的区分度来确定。
-
-4 页面搜索严禁左模糊或者全模糊，如果需要请走搜索引擎来解决。 
-	说明：索引文件具有B-Tree的最左前缀匹配特性，如果左边的值未确定，那么无法使用此索引。
-
-5 如果有order by的场景，请注意利用索引的有序性。order by 最后的字段是组合索引的一部分，并且放在索引组合顺序的最后，避免出现file_sort的情况，影响查询性能。 
-	
-	正例：where a=? and b=? order by c; 索引：a_b_c 
-	
-	反例：索引中有范围查找，那么索引有序性无法利用，如：WHERE a>10 ORDER BY b; 索引a_b无法排序。
-
-6 利用覆盖索引来进行查询操作，避免回表。 
-
-	说明：如果一本书需要知道第11章是什么标题，会翻开第11章对应的那一页吗？目录浏览一下就好，这个目录就是起到覆盖索引的作用。 
-	
-	正例：能够建立索引的种类：主键索引、唯一索引、普通索引，而覆盖索引是一种查询的一种效果，用explain的结果，extra列会出现：using index。
-	
-7 利用延迟关联或者子查询优化超多分页场景。 
-	说明：MySQL并不是跳过offset行，而是取offset+N行，然后返回放弃前offset行，返回N行，那当offset特别大的时候，效率就非常的低下，
-			要么控制返回的总页数，要么对超过特定阈值的页数进行SQL改写。 
-	正例：先快速定位需要获取的id段，然后再关联： SELECT a.* FROM 表1 a, (select id from 表1 where 条件 LIMIT 100000,20 ) b where a.id=b.id
-	
-8 SQL性能优化的目标：至少要达到 range 级别，要求是ref级别，如果可以是consts最好。 	
-	说明： 
-	1）consts 单表中最多只有一个匹配行（主键或者唯一索引），在优化阶段即可读取到数据。 
-	2）ref 指的是使用普通的索引（normal index）。 
-	3）range 对索引进行范围检索。 
-	反例：explain表的结果，type=index，索引物理文件全扫描，速度非常慢，这个index级别比较range还低，与全表扫描是小巫见大巫。
-
-9 建组合索引的时候，区分度最高的在最左边。 
-	正例：如果where a=? and b=? ，a列的几乎接近于唯一值，那么只需要单建idx_a索引即可。 
-	说明：存在非等号和等号混合判断条件时，在建索引时，请把等号条件的列前置。
-	如：where a>? and b=? 那么即使a的区分度更高，也必须把b放在索引的最前列。
-
-10 防止因字段类型不同造成的隐式转换，导致索引失效。
-
-11 创建索引时避免有如下极端误解： 
-	1）宁滥勿缺。认为一个查询就需要建一个索引。 
-	2）宁缺勿滥。认为索引会消耗空间、严重拖慢更新和新增速度。 
+1 业务上具有唯一特性的字段，即使是多个字段的组合，也必须建成唯一索引。 
+	说明：不要以为唯一索引影响了insert速度，这个速度损耗可以忽略，但提高查找速度是明显的；另外，即使在应用层做了非常完善的校验控制，只要没有唯一索引，根据墨菲定律，必然有脏数据产生。
+
+2 超过三个表禁止join。需要join的字段，数据类型必须绝对一致；多表关联查询时，保证被关联的字段需要有索引。 
+	说明：即使双表join也要注意表索引、SQL性能。
+
+3 在varchar字段上建立索引时，必须指定索引长度，没必要对全字段建立索引，根据实际文本区分度决定索引长度即可。
+	说明：索引的长度与区分度是一对矛盾体，一般对字符串类型数据，长度为20的索引，区分度会高达90%以上，可以使用count(distinct left(列名, 索引长度))/count(*)的区分度来确定。
+
+4 页面搜索严禁左模糊或者全模糊，如果需要请走搜索引擎来解决。 
+	说明：索引文件具有B-Tree的最左前缀匹配特性，如果左边的值未确定，那么无法使用此索引。
+
+5 如果有order by的场景，请注意利用索引的有序性。order by 最后的字段是组合索引的一部分，并且放在索引组合顺序的最后，避免出现file_sort的情况，影响查询性能。 
+	
+	正例：where a=? and b=? order by c; 索引：a_b_c 
+	
+	反例：索引中有范围查找，那么索引有序性无法利用，如：WHERE a>10 ORDER BY b; 索引a_b无法排序。
+
+6 利用覆盖索引来进行查询操作，避免回表。 
+
+	说明：如果一本书需要知道第11章是什么标题，会翻开第11章对应的那一页吗？目录浏览一下就好，这个目录就是起到覆盖索引的作用。 
+	
+	正例：能够建立索引的种类：主键索引、唯一索引、普通索引，而覆盖索引是一种查询的一种效果，用explain的结果，extra列会出现：using index。
+	
+7 利用延迟关联或者子查询优化超多分页场景。 
+	说明：MySQL并不是跳过offset行，而是取offset+N行，然后返回放弃前offset行，返回N行，那当offset特别大的时候，效率就非常的低下，
+			要么控制返回的总页数，要么对超过特定阈值的页数进行SQL改写。 
+	正例：先快速定位需要获取的id段，然后再关联： SELECT a.* FROM 表1 a, (select id from 表1 where 条件 LIMIT 100000,20 ) b where a.id=b.id
+	
+8 SQL性能优化的目标：至少要达到 range 级别，要求是ref级别，如果可以是consts最好。 	
+	说明： 
+	1）consts 单表中最多只有一个匹配行（主键或者唯一索引），在优化阶段即可读取到数据。 
+	2）ref 指的是使用普通的索引（normal index）。 
+	3）range 对索引进行范围检索。 
+	反例：explain表的结果，type=index，索引物理文件全扫描，速度非常慢，这个index级别比较range还低，与全表扫描是小巫见大巫。
+
+9 建组合索引的时候，区分度最高的在最左边。 
+	正例：如果where a=? and b=? ，a列的几乎接近于唯一值，那么只需要单建idx_a索引即可。 
+	说明：存在非等号和等号混合判断条件时，在建索引时，请把等号条件的列前置。
+	如：where a>? and b=? 那么即使a的区分度更高，也必须把b放在索引的最前列。
+
+10 防止因字段类型不同造成的隐式转换，导致索引失效。
+
+11 创建索引时避免有如下极端误解： 
+	1）宁滥勿缺。认为一个查询就需要建一个索引。 
+	2）宁缺勿滥。认为索引会消耗空间、严重拖慢更新和新增速度。 
 	3）抵制惟一索引。认为业务的惟一性一律需要在应用层通过“先查后插”方式解决。
\ No newline at end of file
diff --git a/19 - Standard/Mysql.txt "b/19 - Standard \346\240\207\345\207\206/Mysql.txt"
similarity index 98%
rename from 19 - Standard/Mysql.txt
rename to "19 - Standard \346\240\207\345\207\206/Mysql.txt"
index f7cdb30a..4529b281 100644
--- a/19 - Standard/Mysql.txt	
+++ "b/19 - Standard \346\240\207\345\207\206/Mysql.txt"	
@@ -1,42 +1,42 @@
-SQL
-
-1 不要使用count(列名) 或 count(常量)来替代count(*)，count(*)是SQL92定义的标准统计行数的语法，跟数据库无关，跟NULL和非NULL无关。
-
-	说明：count(*)会统计值为NULL的行，而count(列名)不会统计此列为NULL值的行。
-	
-2 count(distinct col) 计算该列除NULL之外的不重复行数，注意 count(distinct col1, col2) 如果其中一列全为NULL，那么即使另一列有不同的值，也返回为0。
-
-3 当某一列的值全是NULL时，count(col)的返回结果为0，但sum(col)的返回结果为NULL，因此使用sum()时需注意NPE问题。 
-
-	正例：可以使用如下方式来避免sum的NPE问题：SELECT IF(ISNULL(SUM(g)),0,SUM(g)) FROM table;
-	
-4 使用ISNULL()来判断是否为NULL值。 
-	说明：NULL与任何值的直接比较都为NULL。 
-	1） NULL<>NULL的返回结果是NULL，而不是false。 
-	2） NULL=NULL的返回结果是NULL，而不是true。 
-	3） NULL<>1的返回结果是NULL，而不是true。
-
-5 在代码中写分页查询逻辑时，若count为0应直接返回，避免执行后面的分页语句。
-
-6 不得使用外键与级联，一切外键概念必须在应用层解决。
-	
-	说明：以学生和成绩的关系为例，学生表中的student_id是主键，那么成绩表中的student_id则为外键。
-			如果更新学生表中的student_id，同时触发成绩表中的student_id更新，即为级联更新。
-			外键与级联更新适用于单机低并发，不适合分布式、高并发集群；级联更新是强阻塞，存在数据库更新风暴的风险；外键影响数据库的插入速度。
-			
-7 禁止使用存储过程，存储过程难以调试和扩展，更没有移植性。
-
-8 数据订正时，删除和修改记录时，要先select，避免出现误删除，确认无误才能执行更新语句。
-
-9 in操作能避免则避免，若实在避免不了，需要仔细评估in后边的集合元素数量，控制在1000个之内。
-
-10 如果有全球化需要，所有的字符存储与表示，均以utf-8编码，注意字符统计函数的区别。
-
-	说明： 
-		SELECT LENGTH("轻松工作")； 返回为12 
-		SELECT CHARACTER_LENGTH("轻松工作")； 返回为4 
-		如果需要存储表情，那么选择utfmb4来进行存储，注意它与utf-8编码的区别。
-
-11 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少，但TRUNCATE无事务且不触发trigger，有可能造成事故，故不建议在开发代码中使用此语句。
-	
+SQL
+
+1 不要使用count(列名) 或 count(常量)来替代count(*)，count(*)是SQL92定义的标准统计行数的语法，跟数据库无关，跟NULL和非NULL无关。
+
+	说明：count(*)会统计值为NULL的行，而count(列名)不会统计此列为NULL值的行。
+	
+2 count(distinct col) 计算该列除NULL之外的不重复行数，注意 count(distinct col1, col2) 如果其中一列全为NULL，那么即使另一列有不同的值，也返回为0。
+
+3 当某一列的值全是NULL时，count(col)的返回结果为0，但sum(col)的返回结果为NULL，因此使用sum()时需注意NPE问题。 
+
+	正例：可以使用如下方式来避免sum的NPE问题：SELECT IF(ISNULL(SUM(g)),0,SUM(g)) FROM table;
+	
+4 使用ISNULL()来判断是否为NULL值。 
+	说明：NULL与任何值的直接比较都为NULL。 
+	1） NULL<>NULL的返回结果是NULL，而不是false。 
+	2） NULL=NULL的返回结果是NULL，而不是true。 
+	3） NULL<>1的返回结果是NULL，而不是true。
+
+5 在代码中写分页查询逻辑时，若count为0应直接返回，避免执行后面的分页语句。
+
+6 不得使用外键与级联，一切外键概念必须在应用层解决。
+	
+	说明：以学生和成绩的关系为例，学生表中的student_id是主键，那么成绩表中的student_id则为外键。
+			如果更新学生表中的student_id，同时触发成绩表中的student_id更新，即为级联更新。
+			外键与级联更新适用于单机低并发，不适合分布式、高并发集群；级联更新是强阻塞，存在数据库更新风暴的风险；外键影响数据库的插入速度。
+			
+7 禁止使用存储过程，存储过程难以调试和扩展，更没有移植性。
+
+8 数据订正时，删除和修改记录时，要先select，避免出现误删除，确认无误才能执行更新语句。
+
+9 in操作能避免则避免，若实在避免不了，需要仔细评估in后边的集合元素数量，控制在1000个之内。
+
+10 如果有全球化需要，所有的字符存储与表示，均以utf-8编码，注意字符统计函数的区别。
+
+	说明： 
+		SELECT LENGTH("轻松工作")； 返回为12 
+		SELECT CHARACTER_LENGTH("轻松工作")； 返回为4 
+		如果需要存储表情，那么选择utfmb4来进行存储，注意它与utf-8编码的区别。
+
+11 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少，但TRUNCATE无事务且不触发trigger，有可能造成事故，故不建议在开发代码中使用此语句。
+	
 	说明：TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同。
\ No newline at end of file
diff --git "a/19 - Standard \346\240\207\345\207\206/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214 \345\215\216\345\261\261\347\211\210.pdf" "b/19 - Standard \346\240\207\345\207\206/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214 \345\215\216\345\261\261\347\211\210.pdf"
new file mode 100644
index 00000000..7cf51a91
Binary files /dev/null and "b/19 - Standard \346\240\207\345\207\206/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214 \345\215\216\345\261\261\347\211\210.pdf" differ
diff --git "a/19 - Standard \346\240\207\345\207\206/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214 \346\263\260\345\261\261\347\211\210.pdf" "b/19 - Standard \346\240\207\345\207\206/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214 \346\263\260\345\261\261\347\211\210.pdf"
new file mode 100644
index 00000000..d15ea7e7
Binary files /dev/null and "b/19 - Standard \346\240\207\345\207\206/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214 \346\263\260\345\261\261\347\211\210.pdf" differ
diff --git "a/19 - Standard/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214\347\273\210\346\236\201\347\211\210v1.3.0.pdf" "b/19 - Standard/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214\347\273\210\346\236\201\347\211\210v1.3.0.pdf"
deleted file mode 100644
index e6ed0c52..00000000
Binary files "a/19 - Standard/\351\230\277\351\207\214\345\267\264\345\267\264Java\345\274\200\345\217\221\346\211\213\345\206\214\347\273\210\346\236\201\347\211\210v1.3.0.pdf" and /dev/null differ
diff --git "a/20 - Commands(Commonly used) & Vocabulary/Git\345\221\275\344\273\244.md" "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/Git\345\221\275\344\273\244.md"
similarity index 100%
rename from "20 - Commands(Commonly used) & Vocabulary/Git\345\221\275\344\273\244.md"
rename to "20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/Git\345\221\275\344\273\244.md"
diff --git a/20 - Commands(Commonly used) & Vocabulary/ci.txt "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/ci.txt"
similarity index 98%
rename from 20 - Commands(Commonly used) & Vocabulary/ci.txt
rename to "20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/ci.txt"
index c5d074f5..36e08989 100644
--- a/20 - Commands(Commonly used) & Vocabulary/ci.txt	
+++ "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/ci.txt"	
@@ -1,3 +1,3 @@
-CDN Content Delivery Network 内容分发网络
-SOA Service-Oriented Architecture 面向服务的架构
-AOP Aspect Oriented Programming  面向切面编程
+CDN Content Delivery Network 内容分发网络
+SOA Service-Oriented Architecture 面向服务的架构
+AOP Aspect Oriented Programming  面向切面编程
diff --git a/20 - Commands(Commonly used) & Vocabulary/cmd.md "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/cmd.md"
similarity index 100%
rename from 20 - Commands(Commonly used) & Vocabulary/cmd.md
rename to "20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/cmd.md"
diff --git "a/20 - Commands(Commonly used) & Vocabulary/\347\273\210\347\253\257" "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/\347\273\210\347\253\257"
similarity index 90%
rename from "20 - Commands(Commonly used) & Vocabulary/\347\273\210\347\253\257"
rename to "20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/\347\273\210\347\253\257"
index ee982210..445aa243 100644
--- "a/20 - Commands(Commonly used) & Vocabulary/\347\273\210\347\253\257"	
+++ "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/\347\273\210\347\253\257"	
@@ -1,7 +1,7 @@
-sz 下载
-
-rz
-
-日志存储
-
-清空文件内容 echo "" > filename
+sz 下载
+
+rz
+
+日志存储
+
+清空文件内容 echo "" > filename
diff --git "a/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/\350\213\261\350\257\255\345\215\225\350\257\215.md" "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/\350\213\261\350\257\255\345\215\225\350\257\215.md"
new file mode 100644
index 00000000..f1dcfda3
--- /dev/null
+++ "b/20 - Commands(Commonly used) & Vocabulary \345\221\275\344\273\244/\350\213\261\350\257\255\345\215\225\350\257\215.md"	
@@ -0,0 +1,35 @@
+catalina [kætə'li:nə] 远程轰炸机
+
+synchronize  [ˈsɪŋkrənaɪz] 使同步
+
+volatile [ˈvɑ:lətl] 易变的，不稳定的; （液体或油） 易挥发的; 爆炸性的; 快活的，轻快的;
+
+survivor [sərˈvaɪvə(r)] 生还者; 幸存者，残存者; 遗物，残存物; 重新正常生活的人;
+
+Partition 分区
+Broker  经纪人
+
+RPC 远程调用
+
+TDD	测试驱动开发（Test-Driven Development）是敏捷开发中的一项核心实践和技术，也是一种设计方法论。
+	TDD的原理是在开发功能代码之前，先编写单元测试用例代码，测试代码确定需要编写什么产品代码。
+
+DRY
+
+	DRY是“Don't Repeat Yourself”的缩写。不要重复自己
+
+　　意思是说，在一个设计里，对于任何东西，都应该有且只有一个表示，其它的地方都应该引用这一处。
+
+　　这样需要改动的时候，只需调整这一处，所有的地方就都变更过来了。
+
+单一职责
+
+	单一职责原则（SRP：Single responsibility principle）又称单一功能原则，它规定一个类应该只有一个发生变化的原因。该原则由罗伯特·C·马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中给出的。马丁表示此原则是基于汤姆·狄马克(Tom DeMarco)和Meilir Page-Jones的著作中的内聚性原则发展出的。
+
+　　所谓职责是指类变化的原因。如果一个类有多于一个的动机被改变，那么这个类就具有多于一个的职责。而单一职责原则就是指一个类或者模块应该有且只有一个改变的原因。
+
+开闭原则
+
+	开闭原则（OCP）是面向对象设计中“可复用设计”的基石，是面向对象设计中最重要的原则之一，其它很多的设计原则都是实现开闭原则的一种手段。对于扩展是开放的，对于修改是关闭的，这意味着模块的行为是可以扩展的。当应用的需求改变时，我们可以对模块进行扩展，使其具有满足那些改变的新行为。也就是说，我们可以改变模块的功能。对模块行为进行扩展时，不必改动模块的源代码或者二进制代码。模块的二进制可执行版本，无论是可链接的库、DLL或者.EXE文件，都无需改动。
+
+SOA	Service-Oriented Architecture 面向服务的架构
diff --git "a/20 - Commands(Commonly used) & Vocabulary/\350\213\261\350\257\255\345\215\225\350\257\215.md" "b/20 - Commands(Commonly used) & Vocabulary/\350\213\261\350\257\255\345\215\225\350\257\215.md"
deleted file mode 100644
index 0320a6a9..00000000
--- "a/20 - Commands(Commonly used) & Vocabulary/\350\213\261\350\257\255\345\215\225\350\257\215.md"	
+++ /dev/null
@@ -1,10 +0,0 @@
-catalina [kætə'li:nə] 远程轰炸机
-
-synchronize  [ˈsɪŋkrənaɪz] 使同步
-
-volatile [ˈvɑ:lətl] 易变的，不稳定的; （液体或油） 易挥发的; 爆炸性的; 快活的，轻快的;
-
-survivor [sərˈvaɪvə(r)] 生还者; 幸存者，残存者; 遗物，残存物; 重新正常生活的人;
-
-Partition 分区
-Broker  经纪人
diff --git a/999 - blog/README.md b/999 - blog/README.md
new file mode 100644
index 00000000..17629d2e
--- /dev/null
+++ b/999 - blog/README.md	
@@ -0,0 +1 @@
+### 999 - blog
diff --git "a/999 - blog/mac \345\215\207\347\272\247catalina.md" "b/999 - blog/mac \345\215\207\347\272\247catalina.md"
new file mode 100644
index 00000000..fb1b666f
--- /dev/null
+++ "b/999 - blog/mac \345\215\207\347\272\247catalina.md"	
@@ -0,0 +1,7 @@
+1、重启mac，按住`Command+R`，等到系统进入安全模式。
+2、选择一个账户，然后点击屏幕上方的工具栏找到命令行工具。
+3、执行，命令`csrutil disable`
+4、重启电脑后，不要进入安全模式，执行命令`sudo mount -uw /`
+5、执行命令 `sudo mkdir /data`
+6、执行命令 `sudo chmod 777 /data`
+7、重启电脑，进入安全模式，执行命令 `csrutil enable` （开启SIP）
diff --git "a/999 - blog/mybatis \344\272\213\345\212\241 \347\274\223\345\255\230\351\227\256\351\242\230.md" "b/999 - blog/mybatis \344\272\213\345\212\241 \347\274\223\345\255\230\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..420a4b05
--- /dev/null
+++ "b/999 - blog/mybatis \344\272\213\345\212\241 \347\274\223\345\255\230\351\227\256\351\242\230.md"	
@@ -0,0 +1 @@
+在 **同一个事务** 里，mybatis 查询出来的 同一个val 是同一个对象，缓存。 mybatis的一级缓存
diff --git "a/999 - blog/spring - \345\274\204\346\207\202\345\276\252\347\216\257\344\276\235\350\265\226\351\207\214\347\232\204\344\270\211\347\272\247\347\274\223\345\255\230.md" "b/999 - blog/spring - \345\274\204\346\207\202\345\276\252\347\216\257\344\276\235\350\265\226\351\207\214\347\232\204\344\270\211\347\272\247\347\274\223\345\255\230.md"
new file mode 100644
index 00000000..0122198b
--- /dev/null
+++ "b/999 - blog/spring - \345\274\204\346\207\202\345\276\252\347\216\257\344\276\235\350\265\226\351\207\214\347\232\204\344\270\211\347\272\247\347\274\223\345\255\230.md"	
@@ -0,0 +1,22 @@
+循环依赖
+  * 构造器循环依赖
+    Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException
+  * setter循环依赖 默认单例
+  * setter循环依赖 prototype  
+    Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException
+
+一级缓存 singletonObjects       单例bean缓存
+二级缓存 singletonFactories     工厂对象缓存
+三级缓存 earlySingletonObjects  早期单例bean缓存
+```java
+/** Cache of singleton objects: bean name --> bean instance */
+private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
+
+/** Cache of singleton factories: bean name --> ObjectFactory */
+private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
+
+/** Cache of early singleton objects: bean name --> bean instance */
+private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
+```
+
+创建Bean的过程
diff --git a/README.md b/README.md
index 3d710bae..d4d99a18 100644
--- a/README.md
+++ b/README.md
@@ -1,124 +1,104 @@
-# Java-Notes
+## loveincode's notes
 
 <p align='center'>
-<img src="https://img.shields.io/badge/build-passing-brightgreen.svg">
-<a href="https://github.com/loveincode/Java-Notes"><img src="https://img.shields.io/github/stars/loveincode/Java-Notes.svg?style=social&label=Stars"></a>
-<a href="https://github.com/loveincode/Java-Notes"><img src="https://img.shields.io/github/forks/loveincode/Java-Notes.svg?style=social&label=Forks"></a>
+<a href="https://github.com/loveincode/notes"><img src="https://img.shields.io/github/stars/loveincode/notes.svg?style=social&label=Stars"></a>
+<a href="https://github.com/loveincode/notes"><img src="https://img.shields.io/github/forks/loveincode/notes.svg?style=social&label=Forks"></a>
+<a href="https://github.com/loveincode/notes"><img src="https://img.shields.io/github/issues/loveincode/notes.svg?style=social&label=Issues"></a>
 <br/>
 <img src="https://img.shields.io/badge/platform-Java-ff69b4.svg">
 <img src="https://img.shields.io/badge/language-Python-orange.svg">
-<a href=""><img src="https://img.shields.io/badge/license-Apache--2.0-000000.svg"></a>
 <a href="https://loveincode.cnblogs.com/"><img src="https://img.shields.io/badge/Blog-loveincode-80d4f9.svg?style=flat"></a>
+<br/>
+<img src="https://img.shields.io/badge/build-passing-brightgreen.svg">
+<a href="https://github.com/996icu/996.ICU/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-Anti%20996-blue.svg"></a>
+<a href="https://996.icu/#/zh_CN"><img src="https://img.shields.io/badge/link-996.icu-red.svg"></a>
+<a href="http://makeapullrequest.com"><img src="https://badgen.net/badge/PRs/welcome/green"></a>
+</br>
+<a href="https://gitter.im/loveincode-notes/community"><img src="https://badgen.net/badge/gitter/join chat/green"></a>
 </p>
 
-## 介绍
-### 项目介绍
-   Java后端工程师的学习技术栈
-
-### 学习交流
-微 信: 9088584 , 验证暗号：Java后端学习 loveincode
-
-EMAIL: huonevan@gmail.com
-
-
-
-
-   [人气很高的链接库](https://github.com/loveincode/Java-Notes/blob/master/%E6%94%B6%E8%97%8F/%E5%A5%BD%E9%93%BE%E6%8E%A5.md)
-
-* [计算机基础相关笔记](https://github.com/loveincode/Java-Notes/tree/master/000%20-%201%20Computer%20Basics)
-
-  `操作系统` , `编译原理` , `计算机网络` , `互联网协议`...
-
-* [常用数据结构与算法](https://github.com/loveincode/Java-Notes/tree/master/000%20-%202%20Data%20%26%20Algorithm)
-
-  [Java 实现 数据结构 与 排序算法](https://github.com/loveincode/Data-structures-and-algorithms)
-
-* [常用设计模式](https://github.com/loveincode/Java-Notes/tree/master/000%20-%203%20Design%20Patterns)
-
-  `单例模式` , `工厂模式` , `装饰者模式` ,  `代理模式` ...
-
-* [Java基础核心](https://github.com/loveincode/Java-Notes/tree/master/01%20-%20JavaSE)
-
-  `JVM` , `集合` , `类型` ，`关键字`...
+学习工作中的一些记录，收藏。
 
-* [Java高级特性](https://github.com/loveincode/Java-Notes/tree/master/02%20-%20Java-High-Ranking)
+[人气很高的链接库](https://github.com/loveincode/notes/blob/master/%E6%94%B6%E8%97%8F/%E5%A5%BD%E9%93%BE%E6%8E%A5.md)
 
-  `多线程`
 
-* [框架](https://github.com/loveincode/Java-Notes/tree/master/03%20-%20Framework)
+##### [计算机基础相关笔记](https://github.com/loveincode/notes/tree/master/000%20-%201%20Computer%20Basics%20%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9F%BA%E7%A1%80)
 
-  `Spring` , `Mybatis` , `SpringBoot` , `SpringMVC` ...
+  * `操作系统` , `编译原理` , `计算机网络` , `互联网协议`...
 
-* [中间件](https://github.com/loveincode/Java-Notes/tree/master/04%20-%20Middleware)
+##### [常用数据结构与算法](https://github.com/loveincode/notes/tree/master/000%20-%202%20Data%20%26%20Algorithm%20%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%26%E7%AE%97%E6%B3%95)
 
-  `RPC` , `MQ` , `elasticsearch`  ...
+  * [Java 实现 数据结构 与 排序算法](https://github.com/loveincode/Data-structures-and-algorithms)
 
-* [操作系统linux](https://github.com/loveincode/Java-Notes/tree/master/05%20-%20OS%20(linux))
+##### [常用设计模式](https://github.com/loveincode/notes/tree/master/000%20-%203%20Design%20Patterns%20%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F)
 
-* [数据库](https://github.com/loveincode/Java-Notes/tree/master/06%20-%20DB%20(mysql))
+  * `单例模式` , `工厂模式` , `装饰者模式` ,  `代理模式` ...
 
-  `Mysql` , `MongoDB` , `HBase`  ...
+##### [Java基础核心](https://github.com/loveincode/notes/tree/master/01%20-%20JavaSE%20Java%E6%A0%B8%E5%BF%83)
 
-* [优化](https://github.com/loveincode/Java-Notes/tree/master/07%20-%20%E4%BC%98%E5%8C%96)
+  * `JVM` , `集合` , `类型` ，`关键字`...
 
-* [常用工具](https://github.com/loveincode/Java-Notes/tree/master/08%20-%20Utils)
+##### [Java高级特性](https://github.com/loveincode/notes/tree/master/02%20-%20Java-High-Ranking%20Java%E9%AB%98%E7%BA%A7)
 
-  `git` , `svn` , `效率` , `aliyun` , `mac` , `windows`
+  * `多线程`、`锁`、`并发`
 
-* [职业面经](https://github.com/loveincode/Java-Notes/tree/master/09%20-%20J)
+##### [框架](https://github.com/loveincode/notes/tree/master/03%20-%20Framework%20%E6%A1%86%E6%9E%B6)
 
-* [读书笔记](https://github.com/loveincode/Java-Notes/tree/master/10%20-%20Reading%20Notes)
+  * `Spring` , `Mybatis` , `SpringBoot` , `SpringMVC` ...
 
-  `Effective Java` , `HTTP权威指南` ,  `Java多线程编程核心技术` , `Java并发编程实战` ,  `Java虚拟机规范(Java SE 7版)` , `深入理解java虚拟机` ...
+##### [中间件](https://github.com/loveincode/notes/tree/master/04%20-%20Middleware%20%E4%B8%AD%E9%97%B4%E4%BB%B6)
 
-* [服务器](https://github.com/loveincode/Java-Notes/tree/master/11%20-%20Server)
+  * `RPC` , `MQ` , `elasticsearch`  ...
 
-  `tomcat` , `nginx`
+##### [操作系统linux](https://github.com/loveincode/notes/tree/master/05%20-%20OS%20(linux)%20%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F)
 
-* [实践中遇到的问题](https://github.com/loveincode/Java-Notes/tree/master/12%20-%20Practice%20(problems%20encountered%20during%20development))
+##### [数据库](https://github.com/loveincode/notes/tree/master/06%20-%20DB%20%E6%95%B0%E6%8D%AE%E5%BA%93)
 
-* [前端（JS）相关](https://github.com/loveincode/Java-Notes/tree/master/14%20-%20Front-end)
+  * `Mysql` , `MongoDB` , `HBase`  ...
 
-* [分布式](https://github.com/loveincode/Java-Notes/tree/master/15%20-%20Distributed)
+##### [优化](https://github.com/loveincode/notes/tree/master/07%20-%20%E4%BC%98%E5%8C%96)
 
-  `负载均衡` ， `分布式锁` ...
+##### [常用工具](https://github.com/loveincode/notes/tree/master/08%20-%20Utils%20%E5%B7%A5%E5%85%B7)
 
-* [软件工程](https://github.com/loveincode/Java-Notes/tree/master/16%20-%20Software%20Engineering)
+  * `git` , `svn` , `效率` , `aliyun` , `mac` , `windows`
 
-* [脚本语言](https://github.com/loveincode/Java-Notes/tree/master/17%20-%20Scripting%20language)
+##### [职业面经](https://github.com/loveincode/notes/tree/master/09%20-%20J%20%E9%9D%A2%E7%BB%8F)
 
-  `lua` , `Ruby` ...
+##### [读书笔记](https://github.com/loveincode/notes/tree/master/10%20-%20Reading%20Notes%20%E8%AF%BB%E4%B9%A6%E7%AC%94%E8%AE%B0)
 
-* [常用代码](https://github.com/loveincode/Java-Notes/tree/master/18%20-%20Common%20code)
+  * `Effective Java` , `HTTP权威指南` ,  `Java多线程编程核心技术` , `Java并发编程实战` ,  `Java虚拟机规范(Java SE 7版)` , `深入理解java虚拟机` ...
 
-* [规范](https://github.com/loveincode/Java-Notes/tree/master/19%20-%20Standard)
+##### [服务器](https://github.com/loveincode/notes/tree/master/11%20-%20Server%20%E6%9C%8D%E5%8A%A1%E5%99%A8)
 
-  `阿里巴巴Java开发手册终极版v1.3.0.pdf` ...
+  * `tomcat` , `nginx`
 
-* [常用命令](https://github.com/loveincode/Java-Notes/tree/master/20%20-%20Commands(Commonly%20used)%20%26%20Vocabulary)
+##### [实践中遇到的问题](https://github.com/loveincode/notes/tree/master/12%20-%20Practice%20(problems%20encountered%20during%20development)%20%E5%AE%9E%E8%B7%B5%E9%97%AE%E9%A2%98)
 
-RPC 远程调用
+##### [前端（JS）相关](https://github.com/loveincode/notes/tree/master/14%20-%20Front-end%20%E5%89%8D%E7%AB%AF)
 
-TDD	测试驱动开发（Test-Driven Development）是敏捷开发中的一项核心实践和技术，也是一种设计方法论。
-	TDD的原理是在开发功能代码之前，先编写单元测试用例代码，测试代码确定需要编写什么产品代码。
+##### [分布式](https://github.com/loveincode/notes/tree/master/15%20-%20Distributed%20%E5%88%86%E5%B8%83%E5%BC%8F)
 
-DRY
+  * `负载均衡` ， `分布式锁` ...
 
-	DRY是“Don't Repeat Yourself”的缩写。不要重复自己
+##### [软件工程](https://github.com/loveincode/notes/tree/master/16%20-%20Software%20Engineering%20%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B)
 
-　　意思是说，在一个设计里，对于任何东西，都应该有且只有一个表示，其它的地方都应该引用这一处。
+##### [脚本语言](https://github.com/loveincode/notes/tree/master/17%20-%20Scripting%20language%20%E8%84%9A%E6%9C%AC%E8%AF%AD%E8%A8%80)
 
-　　这样需要改动的时候，只需调整这一处，所有的地方就都变更过来了。
+  * `lua` , `Ruby` ...
 
+##### [常用代码](https://github.com/loveincode/notes/tree/master/18%20-%20Common%20code%20%E5%B8%B8%E7%94%A8%E4%BB%A3%E7%A0%81)
 
-单一职责
+##### [规范](https://github.com/loveincode/notes/tree/master/19%20-%20Standard%20%E6%A0%87%E5%87%86)
 
-	单一职责原则（SRP：Single responsibility principle）又称单一功能原则，它规定一个类应该只有一个发生变化的原因。该原则由罗伯特·C·马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中给出的。马丁表示此原则是基于汤姆·狄马克(Tom DeMarco)和Meilir Page-Jones的著作中的内聚性原则发展出的。
+  * `阿里巴巴Java开发手册终极版v1.3.0.pdf` ...
 
-　　所谓职责是指类变化的原因。如果一个类有多于一个的动机被改变，那么这个类就具有多于一个的职责。而单一职责原则就是指一个类或者模块应该有且只有一个改变的原因。
+##### [常用命令](https://github.com/loveincode/notes/tree/master/20%20-%20Commands(Commonly%20used)%20%26%20Vocabulary%20%E5%91%BD%E4%BB%A4)
 
-开闭原则
+  * `git`、`终端`
 
-	开闭原则（OCP）是面向对象设计中“可复用设计”的基石，是面向对象设计中最重要的原则之一，其它很多的设计原则都是实现开闭原则的一种手段。对于扩展是开放的，对于修改是关闭的，这意味着模块的行为是可以扩展的。当应用的需求改变时，我们可以对模块进行扩展，使其具有满足那些改变的新行为。也就是说，我们可以改变模块的功能。对模块行为进行扩展时，不必改动模块的源代码或者二进制代码。模块的二进制可执行版本，无论是可链接的库、DLL或者.EXE文件，都无需改动。
+##### 学习交流
+    WeChat : 9088584 , 验证暗号：java学习
+    EMAIL  : 9088584@qq.com
 
-SOA	Service-Oriented Architecture 面向服务的架构
+### Contributors
+[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/0)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/0)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/1)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/1)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/2)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/2)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/3)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/3)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/4)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/4)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/5)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/5)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/6)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/6)[![](https://sourcerer.io/fame/loveincode/loveincode/notes/images/7)](https://sourcerer.io/fame/loveincode/loveincode/notes/links/7)
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 00000000..a17017f7
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1,3 @@
+theme: jekyll-theme-minimal
+logo: /assets/img/logo.png
+show_downloads: true
diff --git a/assets/img/logo.png b/assets/img/logo.png
new file mode 100644
index 00000000..256d2685
Binary files /dev/null and b/assets/img/logo.png differ
diff --git "a/\346\224\266\350\227\217/\345\245\275\351\223\276\346\216\245.md" "b/\346\224\266\350\227\217/\345\245\275\351\223\276\346\216\245.md"
index 58047d84..26a665e5 100644
--- "a/\346\224\266\350\227\217/\345\245\275\351\223\276\346\216\245.md"
+++ "b/\346\224\266\350\227\217/\345\245\275\351\223\276\346\216\245.md"
@@ -19,6 +19,9 @@
   * [spring-boot](https://github.com/spring-projects/spring-boot)
   * [Java设计模式](https://github.com/iluwatar/java-design-patterns)
   * [小马哥 - Segment Fault 在线讲堂](https://github.com/mercyblitz/segmentfault-lessons)
+  * [springboot-analysis](https://github.com/fangjian0423/springboot-analysis)
+  * [SoftwareEngineering-Series](https://github.com/wx-chevalier/SoftwareEngineering-Series)
+  * [Micro-Service-Skeleton](https://github.com/babylikebird/Micro-Service-Skeleton)
 
 ### 1. 常用
 
@@ -70,6 +73,14 @@
 * [springsource](https://repo.springsource.org/webapp/#/home)
 * [发布项目](https://pivotal.io/) [文档](http://docs.run.pivotal.io/cf-cli/install-go-cli.html)
 * [charles抓包](https://www.charlesproxy.com/)
+    ```
+      mac Proxy -> 点击Proxy Setting，Port填8888, IP地址 Charles->Help->Local IP Addres
+      iphone 与mac在同一wifi下， 设置http代理 IP地址 8888
+
+      https:
+      iphone : 通用->关于本机->证书信任设置，找到当前要作为代理的电脑名，打开信任开关。
+      Proxy:Proxy -> 点击SSL Proxying Setting，增加需要https的域名，勾选 Enable SSL Proxying
+    ```
 * [JD-GUI 编译jar包](http://jd.benow.ca/)
 * [OmniPlan 项目管理](https://www.omnigroup.com/omniplan/)
 
@@ -114,7 +125,7 @@
   * [Baidu EFE](https://github.com/ecomfe)
   * [Baidu FEX](https://github.com/fex-team/)
   * [网易](https://github.com/netease)
-  * [美团点评](https://github.com/Meituan-Dianping)
+  * [美团点评](https://github.com/meituan-dianping)
   * [饿了么](https://github.com/eleme)
   * [豆瓣](https://github.com/douban)
   * [Bilibili](https://github.com/Bilibili)
@@ -182,6 +193,14 @@
   * [eclipse 主题色](http://blog.csdn.net/songxingfeng/article/details/7790582)
   * [eclipse主题](http://www.cnblogs.com/csulennon/p/4231405.html)
   * [在Intellij IDEA中使用Debug](http://www.cnblogs.com/chiangchou/p/idea-debug.html)
+      ```
+      Step Over 程序向下执行一行（如果当前行有方法调用，这个方法将被执行完毕返回，然后到下一行）
+      Step Into 程序向下执行一行。如果该行有自定义方法，则运行进入自定义方法（不会进入官方类库的方法）。
+      Force Step Into 该按钮在调试的时候能进入任何方法。
+      Step Out 跳出该方法，返回到该方法被调用处的下一行语句。
+      Drop Frame 你将返回到当前方法的调用处重新执行，并且所有上下文变量的值也回到那个时候。只要调用链中还有上级方法，可以跳到其中的任何一个方法。
+      Run to Cursor 运行到光标处，你可以将光标定位到你需要查看的那一行，然后使用这个功能，代码会运行至光标行，而不需要打断点。
+      ```
   * [下载 pdf: 新浪爱问共享资料](http://ishare.iask.sina.com.cn/)
 
 
@@ -200,7 +219,7 @@
   * [binyue](http://www.cnblogs.com/binyue/)
   * [xlgen157387](https://blog.csdn.net/xlgen157387)
 
-
+  * [林晓斌 丁奇 mysql](https://dinglin.iteye.com/)
 
 ### 4. 论坛社区